@@ -5375,23 +5375,28 @@ export class KimiTUI {
   }
 
   // Handles the /logout command. Lists every credential currently held — the
-  // Kimi Code OAuth token (when present) plus each configured API-key provider
-  // — and lets the user pick which one to drop. managed:kimi-code is also
-  // written into config.providers, so it must be filtered out of the API-key
-  // list to avoid showing twice; OAuth tokens go through auth.logout for
-  // proper revocation, everything else through removeProvider.
+  // Kimi Code OAuth token (or a stale config entry for it) plus each configured
+  // API-key provider — and lets the user pick which one to drop. OAuth tokens
+  // go through auth.logout for proper revocation, everything else through
+  // removeProvider.
   private async handleLogoutCommand(): Promise<void> {
     const oauthStatus = await this.harness.auth.status(DEFAULT_OAUTH_PROVIDER_NAME);
-    const hasOAuth = oauthStatus.providers.some(
+    const hasOAuthToken = oauthStatus.providers.some(
       (p) => p.providerName === DEFAULT_OAUTH_PROVIDER_NAME && p.hasToken,
     );
     const config = await this.harness.getConfig();
+    // Offer the managed provider whenever something points at it — either a
+    // live OAuth token or a stale providers[] entry left over from a previous
+    // login. auth.logout cleans the config regardless of whether the token
+    // is still present, so this avoids leaving residue with no way to reach it.
+    const hasManagedRemnant =
+      hasOAuthToken || config.providers[DEFAULT_OAUTH_PROVIDER_NAME] !== undefined;
     const apiKeyProviderIds = Object.keys(config.providers ?? {})
       .filter((id) => id !== DEFAULT_OAUTH_PROVIDER_NAME)
       .toSorted();
 
     const options: ChoiceOption[] = [];
-    if (hasOAuth) {
+    if (hasManagedRemnant) {
       options.push({
         value: DEFAULT_OAUTH_PROVIDER_NAME,
         label: PRODUCT_NAME,
@@ -5423,8 +5428,22 @@ export class KimiTUI {
     } else {
       await this.harness.removeProvider(target);
     }
-    await this.refreshConfigAfterLogout();
-    await this.clearActiveSessionAfterLogout();
+
+    if (target === currentProvider) {
+      // The active session is backed by the provider we just removed, so it
+      // can no longer make requests — tear it down along with the model state.
+      await this.refreshConfigAfterLogout();
+      await this.clearActiveSessionAfterLogout();
+    } else {
+      // Refresh provider/model listings so the picker reflects the change,
+      // but leave the user's current session running.
+      const updated = await this.harness.getConfig({ reload: true });
+      this.setAppState({
+        availableModels: updated.models ?? {},
+        availableProviders: updated.providers ?? {},
+      });
+    }
+
     this.track('logout', { provider: target });
     const label = target === DEFAULT_OAUTH_PROVIDER_NAME ? PRODUCT_NAME : target;
     this.showStatus(`Logged out from ${label}.`);
 
@@ -568,6 +568,12 @@ describe("KimiTUI startup", () => {
   it("tracks logout after managed credentials and session state are cleared", async () => {
     const session = makeSession();
     const harness = makeHarness(session, {
+      getConfig: vi.fn(async () => ({
+        models: {
+          k2: { provider: "managed:kimi-code", model: "moonshot-v1", maxContextSize: 100 },
+        },
+        providers: { "managed:kimi-code": { type: "kimi" } },
+      })),
       auth: {
         status: vi.fn(async () => ({
           providers: [{ providerName: "managed:kimi-code", hasToken: true }],
@@ -597,6 +603,79 @@ describe("KimiTUI startup", () => {
     expect(harness.track).toHaveBeenCalledWith("logout", { provider: "managed:kimi-code" });
   });
 
+  it("keeps the active session when logging out a different provider", async () => {
+    const session = makeSession();
+    const removeProvider = vi.fn(async () => {});
+    const harness = makeHarness(session, {
+      getConfig: vi.fn(async () => ({
+        models: {
+          k2: { provider: "managed:kimi-code", model: "moonshot-v1", maxContextSize: 100 },
+        },
+        providers: {
+          "managed:kimi-code": { type: "kimi" },
+          openai: { type: "openai", baseUrl: "https://api.openai.com/v1" },
+        },
+      })),
+      removeProvider,
+      auth: {
+        status: vi.fn(async () => ({
+          providers: [{ providerName: "managed:kimi-code", hasToken: true }],
+        })),
+        login: vi.fn(async () => {}),
+        logout: vi.fn(),
+        getManagedUsage: vi.fn(),
+      },
+    });
+    const driver = makeDriver(harness, makeStartupInput());
+
+    await expect(driver.init()).resolves.toBe(false);
+    harness.track.mockClear();
+
+    vi.spyOn(driver as any, "promptLogoutProviderSelection").mockResolvedValue("openai");
+    await driver.handleLogoutCommand();
+
+    expect(removeProvider).toHaveBeenCalledWith("openai");
+    expect(harness.auth.logout).not.toHaveBeenCalled();
+    expect(session.close).not.toHaveBeenCalled();
+    expect(driver.state.appState).toMatchObject({
+      sessionId: "ses-1",
+      model: "k2",
+    });
+    expect(harness.track).toHaveBeenCalledWith("logout", { provider: "openai" });
+  });
+
+  it("can log out a stale managed entry even after the OAuth token is gone", async () => {
+    const session = makeSession();
+    const harness = makeHarness(session, {
+      getConfig: vi.fn(async () => ({
+        models: {
+          k2: { provider: "managed:kimi-code", model: "moonshot-v1", maxContextSize: 100 },
+        },
+        providers: { "managed:kimi-code": { type: "kimi" } },
+      })),
+      auth: {
+        // Token gone (e.g. credentials file deleted) but the managed entry
+        // is still sitting in config.providers.
+        status: vi.fn(async () => ({
+          providers: [{ providerName: "managed:kimi-code", hasToken: false }],
+        })),
+        login: vi.fn(async () => {}),
+        logout: vi.fn(),
+        getManagedUsage: vi.fn(),
+      },
+    });
+    const driver = makeDriver(harness, makeStartupInput());
+
+    await expect(driver.init()).resolves.toBe(false);
+
+    vi.spyOn(driver as any, "promptLogoutProviderSelection").mockResolvedValue(
+      "managed:kimi-code",
+    );
+    await driver.handleLogoutCommand();
+
+    expect(harness.auth.logout).toHaveBeenCalledWith("managed:kimi-code");
+  });
+
   it("starts TUI without replaying when --continue needs OAuth login", async () => {
     const harness = makeHarness(makeSession(), {
       listSessions: vi.fn(async () => [{ id: "ses-latest" }]),