From ad239cb1c08266a442c9ca0382fefed87bcb1fd4 Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Fri, 12 Jun 2026 14:17:12 +0800
Subject: [PATCH 01/17] fix(cli,tui): allow --auto, --yolo, and --plan with
 resumed sessions (#683)

* fix(cli,tui): allow --auto, --yolo, and --plan with resumed sessions

* docs(cli): update flag conflict docs for resumed sessions

* fix(tui): apply startup permission/plan overrides after picker selection
---
 ...llow-auto-yolo-plan-with-session-resume.md |   5 +
 apps/kimi-code/src/cli/options.ts             |   9 -
 apps/kimi-code/src/tui/kimi-tui.ts            | 144 ++--
 apps/kimi-code/test/cli/options.test.ts       |  70 +-
 .../test/tui/kimi-tui-startup.test.ts         | 751 ++++++++++++------
 docs/en/guides/sessions.md                    |   2 +-
 docs/en/reference/kimi-command.md             |   4 +-
 docs/zh/guides/sessions.md                    |   2 +-
 docs/zh/reference/kimi-command.md             |   4 +-
 9 files changed, 652 insertions(+), 339 deletions(-)
 create mode 100644 .changeset/allow-auto-yolo-plan-with-session-resume.md

diff --git a/.changeset/allow-auto-yolo-plan-with-session-resume.md b/.changeset/allow-auto-yolo-plan-with-session-resume.md
new file mode 100644
index 000000000..17ef5eeb0
--- /dev/null
+++ b/.changeset/allow-auto-yolo-plan-with-session-resume.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Allow `--auto`, `--yolo`, and `--plan` to be combined with `--session` or `--continue` by applying the requested mode to the resumed session.
diff --git a/apps/kimi-code/src/cli/options.ts b/apps/kimi-code/src/cli/options.ts
index 5b1c50699..98f4cb196 100644
--- a/apps/kimi-code/src/cli/options.ts
+++ b/apps/kimi-code/src/cli/options.ts
@@ -55,14 +55,5 @@ export function validateOptions(opts: CLIOptions): ValidatedOptions {
   if (opts.yolo && opts.auto) {
     throw new OptionConflictError('Cannot combine --yolo with --auto.');
   }
-  if (!promptMode && (opts.continue || opts.session !== undefined) && opts.yolo) {
-    throw new OptionConflictError('Cannot combine --yolo with --continue or --session.');
-  }
-  if (!promptMode && (opts.continue || opts.session !== undefined) && opts.auto) {
-    throw new OptionConflictError('Cannot combine --auto with --continue or --session.');
-  }
-  if (!promptMode && (opts.continue || opts.session !== undefined) && opts.plan) {
-    throw new OptionConflictError('Cannot combine --plan with --continue or --session.');
-  }
   return { options: opts, uiMode: promptMode ? 'print' : 'shell' };
 }
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 7a43affc5..759a92667 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -8,7 +8,6 @@ import {
   getCapabilities,
   Spacer,
 } from '@earendil-works/pi-tui';
-import type { MigrationPlan } from '@moonshot-ai/migration-legacy';
 import type { DeviceAuthorization } from '@moonshot-ai/kimi-code-oauth';
 import type {
   ApprovalRequest,
@@ -20,14 +19,17 @@ import type {
   PromptPart,
   Session,
 } from '@moonshot-ai/kimi-code-sdk';
+import type { MigrationPlan } from '@moonshot-ai/migration-legacy';
 import { resolve } from 'pathe';
 
 import type { CLIOptions } from '#/cli/options';
 import { MigrationScreenComponent, type MigrationScreenResult } from '#/migration/index';
 import { appendInputHistory, loadInputHistory } from '#/utils/history/input-history';
+import { openUrl } from '#/utils/open-url';
 import { getInputHistoryFile } from '#/utils/paths';
 import { detectFdPath, ensureFdPath } from '#/utils/process/fd-detect';
 
+import { BannerProvider } from './banner/banner-provider';
 import {
   BUILTIN_SLASH_COMMANDS,
   buildSkillSlashCommands,
@@ -37,9 +39,10 @@ import {
   type KimiSlashCommand,
   type SkillListSession,
 } from './commands';
+import * as slashCommands from './commands/dispatch';
+import { BannerComponent } from './components/chrome/banner';
 import { DeviceCodeBoxComponent } from './components/chrome/device-code-box';
 import { GutterContainer } from './components/chrome/gutter-container';
-import { CHROME_GUTTER } from './constant/rendering';
 import { MoonLoader, type SpinnerStyle } from './components/chrome/moon-loader';
 import { WelcomeComponent } from './components/chrome/welcome';
 import {
@@ -54,15 +57,6 @@ import { CompactionComponent } from './components/dialogs/compaction';
 import { HelpPanelComponent } from './components/dialogs/help-panel';
 import { QuestionDialogComponent } from './components/dialogs/question-dialog';
 import { SessionPickerComponent } from './components/dialogs/session-picker';
-import { AuthFlowController } from './controllers/auth-flow';
-import { BtwPanelController } from './controllers/btw-panel';
-import { EditorKeyboardController } from './controllers/editor-keyboard';
-import { SessionEventHandler } from './controllers/session-event-handler';
-import * as slashCommands from './commands/dispatch';
-import { SessionReplayRenderer } from './controllers/session-replay';
-import { StreamingUIController } from './controllers/streaming-ui';
-import { TasksBrowserController } from './controllers/tasks-browser';
-import { installRainbowDance } from './easter-eggs/dance';
 import {
   FileMentionProvider,
   type SlashAutocompleteCommand,
@@ -92,19 +86,26 @@ import {
   NO_ACTIVE_SESSION_MESSAGE,
   PRODUCT_NAME,
 } from './constant/kimi-tui';
+import { CHROME_GUTTER } from './constant/rendering';
 import { MAX_TERMINAL_TITLE_LENGTH } from './constant/terminal';
-import { combineStartupNotice, isOAuthLoginRequiredError } from './utils/startup';
+import { AuthFlowController } from './controllers/auth-flow';
+import { BtwPanelController } from './controllers/btw-panel';
+import { EditorKeyboardController } from './controllers/editor-keyboard';
+import { SessionEventHandler } from './controllers/session-event-handler';
+import { SessionReplayRenderer } from './controllers/session-replay';
+import { StreamingUIController } from './controllers/streaming-ui';
+import { TasksBrowserController } from './controllers/tasks-browser';
+import { installRainbowDance } from './easter-eggs/dance';
 import { adaptPanelResponse } from './reverse-rpc/approval/adapter';
 import { ApprovalController } from './reverse-rpc/approval/controller';
 import { createApprovalRequestHandler } from './reverse-rpc/approval/handler';
-import { BannerProvider } from './banner/banner-provider';
-import { BannerComponent } from './components/chrome/banner';
 import { registerReverseRPCHandlers } from './reverse-rpc/index';
 import { QuestionController } from './reverse-rpc/question/controller';
 import { createQuestionAskHandler } from './reverse-rpc/question/handler';
 import type { ApprovalPanelData, QuestionPanelData } from './reverse-rpc/types';
 import { currentTheme, getColorPalette, getBuiltInPalette, isBuiltInTheme } from './theme';
 import type { ColorToken, ResolvedTheme, ThemeName } from './theme';
+import { createTUIState, type TUIState } from './tui-state';
 import {
   INITIAL_LIVE_PANE,
   type AppState,
@@ -116,15 +117,14 @@ import {
   type TUIStartupOptions,
   type TUIStartupState,
 } from './types';
-import { createTUIState, type TUIState } from './tui-state';
 import { isExpandable } from './utils/component-capabilities';
 import { isDeadTerminalError } from './utils/dead-terminal';
 import { formatErrorMessage } from './utils/event-payload';
 import { ImageAttachmentStore, type ImageAttachment } from './utils/image-attachment-store';
 import { extractMediaAttachments } from './utils/image-placeholder';
 import { hasPatchChanges } from './utils/object-patch';
-import { openUrl } from '#/utils/open-url';
 import { sessionRowsForPicker } from './utils/session-picker-rows';
+import { combineStartupNotice, isOAuthLoginRequiredError } from './utils/startup';
 import { installTerminalFocusTracking } from './utils/terminal-focus';
 import { notifyTerminalOnce } from './utils/terminal-notification';
 import { installTerminalThemeTracking } from './utils/terminal-theme';
@@ -246,10 +246,7 @@ export class KimiTUI {
 
   public onExit?: (exitCode?: number) => Promise<void>;
 
-  track(
-    event: string,
-    properties?: Parameters<KimiHarness['track']>[1],
-  ): void {
+  track(event: string, properties?: Parameters<KimiHarness['track']>[1]): void {
     this.harness.track(event, properties);
   }
 
@@ -377,8 +374,7 @@ export class KimiTUI {
         try {
           const migrationResult = await this.runMigrationScreen(this.migrationPlan);
           if (this.migrateOnly) {
-            const failed =
-              migrationResult.decision === 'now' && migrationResult.migrated === false;
+            const failed = migrationResult.decision === 'now' && migrationResult.migrated === false;
             this.disposeTerminalTracking();
             this.state.ui.stop();
             await this.onExit?.(failed ? 1 : 0);
@@ -424,11 +420,7 @@ export class KimiTUI {
     if (this.state.appState.banner === null || this.state.appState.banner === undefined) {
       return;
     }
-    if (
-      this.state.transcriptContainer.children.some(
-        (child) => child instanceof BannerComponent,
-      )
-    ) {
+    if (this.state.transcriptContainer.children.some((child) => child instanceof BannerComponent)) {
       return;
     }
     const welcomeIndex = this.state.transcriptContainer.children.findIndex(
@@ -489,10 +481,7 @@ export class KimiTUI {
         this.showStatus(parts.join(' · ') + '.');
       }
       for (const f of result.failed) {
-        this.showStatus(
-          `Skipped refreshing ${f.provider}: ${f.reason}`,
-          'warning',
-        );
+        this.showStatus(`Skipped refreshing ${f.provider}: ${f.reason}`, 'warning');
       }
     } catch {
       // Best-effort: startup must not crash on background refresh failures.
@@ -511,6 +500,7 @@ export class KimiTUI {
     }
     if (shouldReplayHistory) {
       await this.sessionReplay.hydrateFromReplay(this.requireSession());
+      this.applyStartupPermissionAndPlanToAppState();
     }
     const resumeState = this.session?.getResumeState();
     if (resumeState?.warning !== undefined) {
@@ -568,7 +558,8 @@ export class KimiTUI {
           if (resolve(target.workDir) !== resolve(workDir)) {
             this.state.ui.stop();
             process.stderr.write(
-              `${currentTheme.fg('warning',
+              `${currentTheme.fg(
+                'warning',
                 `Session "${startup.sessionFlag}" was created under a different directory.\n` +
                   `  cd "${target.workDir}" && kimi -r ${startup.sessionFlag}`,
               )}\n\n`,
@@ -596,8 +587,18 @@ export class KimiTUI {
       } else {
         session = await this.harness.createSession(createSessionOptions);
       }
-      if (session !== undefined && startup.model !== undefined && isResumeStartup) {
-        await session.setModel(startup.model);
+      if (session !== undefined && shouldReplayHistory) {
+        if (startup.auto) {
+          await session.setPermission('auto');
+        } else if (startup.yolo) {
+          await session.setPermission('yolo');
+        }
+        if (startup.plan) {
+          await session.setPlanMode(true);
+        }
+        if (startup.model !== undefined) {
+          await session.setModel(startup.model);
+        }
       }
     } catch (error) {
       if (!isOAuthLoginRequiredError(error)) throw error;
@@ -610,6 +611,7 @@ export class KimiTUI {
     }
     await this.setSession(session);
     await this.syncRuntimeState(session);
+    this.applyStartupPermissionAndPlanToAppState();
     this.state.startupState = 'ready';
     return shouldReplayHistory;
   }
@@ -1079,10 +1081,7 @@ export class KimiTUI {
   }
 
   async syncRuntimeState(session: Session = this.requireSession()): Promise<void> {
-    const [status, goalResult] = await Promise.all([
-      session.getStatus(),
-      session.getGoal(),
-    ]);
+    const [status, goalResult] = await Promise.all([session.getStatus(), session.getGoal()]);
     this.setAppState({
       sessionId: session.id,
       model: status.model ?? '',
@@ -1098,6 +1097,21 @@ export class KimiTUI {
     });
   }
 
+  // Re-apply startup flags that the user explicitly passed on the command line.
+  // syncRuntimeState and session-replay hydration can both read stale persisted
+  // values, so this guarantees the footer reflects the CLI intent.
+  private applyStartupPermissionAndPlanToAppState(): void {
+    const { startup } = this.options;
+    if (startup.auto) {
+      this.setAppState({ permissionMode: 'auto' });
+    } else if (startup.yolo) {
+      this.setAppState({ permissionMode: 'yolo' });
+    }
+    if (startup.plan) {
+      this.setAppState({ planMode: true });
+    }
+  }
+
   // Plan mode is set by createSession — do not re-enter it here.
   private async activateRuntime(): Promise<void> {
     const session = this.requireSession();
@@ -1336,10 +1350,7 @@ export class KimiTUI {
           return new GoalSetMessageComponent();
         }
         if (entry.goalData?.kind === 'lifecycle') {
-          return buildGoalMarker(
-            entry.goalData.change,
-            this.state.toolOutputExpanded,
-          );
+          return buildGoalMarker(entry.goalData.change, this.state.toolOutputExpanded);
         }
         return null;
       case 'assistant': {
@@ -1396,7 +1407,10 @@ export class KimiTUI {
     }
   }
 
-  private appendApprovalTranscriptEntry(request: ApprovalRequest, response: ApprovalResponse): void {
+  private appendApprovalTranscriptEntry(
+    request: ApprovalRequest,
+    response: ApprovalResponse,
+  ): void {
     if (request.toolName === 'ExitPlanMode' || request.display.kind === 'plan_review') return;
     const parts: string[] = [];
     switch (response.decision) {
@@ -1425,9 +1439,7 @@ export class KimiTUI {
 
   private renderWelcome(): void {
     if (
-      this.state.transcriptContainer.children.some(
-        (child) => child instanceof WelcomeComponent,
-      )
+      this.state.transcriptContainer.children.some((child) => child instanceof WelcomeComponent)
     ) {
       return;
     }
@@ -1457,16 +1469,12 @@ export class KimiTUI {
   }
 
   showStatus(message: string, color?: ColorToken): void {
-    this.state.transcriptContainer.addChild(
-      new StatusMessageComponent(message, color),
-    );
+    this.state.transcriptContainer.addChild(new StatusMessageComponent(message, color));
     this.state.ui.requestRender();
   }
 
   showNotice(title: string, detail?: string): void {
-    this.state.transcriptContainer.addChild(
-      new NoticeMessageComponent(title, detail),
-    );
+    this.state.transcriptContainer.addChild(new NoticeMessageComponent(title, detail));
     this.state.ui.requestRender();
   }
 
@@ -1641,9 +1649,7 @@ export class KimiTUI {
   }
 
   async applyTheme(themeName: ThemeName, resolved?: ResolvedTheme): Promise<void> {
-    const palette = await getColorPalette(
-      themeName === 'auto' ? (resolved ?? 'dark') : themeName,
-    );
+    const palette = await getColorPalette(themeName === 'auto' ? (resolved ?? 'dark') : themeName);
     currentTheme.setPalette(palette);
     this.setAppState({ theme: themeName });
     this.updateEditorBorderHighlight();
@@ -1689,7 +1695,9 @@ export class KimiTUI {
     );
   }
 
-  private shouldPlaceActivitySpinnerInAgentSwarm(effectiveMode: EffectiveActivityPaneMode): boolean {
+  private shouldPlaceActivitySpinnerInAgentSwarm(
+    effectiveMode: EffectiveActivityPaneMode,
+  ): boolean {
     return (
       this.sessionEventHandler.hasActiveAgentSwarmToolCall() &&
       (effectiveMode === 'waiting' || effectiveMode === 'tool')
@@ -1781,11 +1789,7 @@ export class KimiTUI {
       // Persist the skip marker `detectPendingMigration` checks, so "Never ask
       // again" actually stops the prompt from reappearing every launch.
       try {
-        writeFileSync(
-          join(this.harness.homeDir, '.skip-migration-from-kimi-cli'),
-          '',
-          'utf-8',
-        );
+        writeFileSync(join(this.harness.homeDir, '.skip-migration-from-kimi-cli'), '', 'utf-8');
       } catch {
         // Non-blocking: a failed marker write must never crash startup.
       }
@@ -1852,10 +1856,21 @@ export class KimiTUI {
         loading: this.state.loadingSessions,
         currentSessionId: this.state.appState.sessionId,
         onSelect: (sessionId: string) => {
-          void this.resumeSession(sessionId).then((switched) => {
-            if (switched) {
-              this.hideSessionPicker();
+          void this.resumeSession(sessionId).then(async (switched) => {
+            if (!switched) {
+              return;
             }
+            const session = this.requireSession();
+            if (this.options.startup.auto) {
+              await session.setPermission('auto');
+            } else if (this.options.startup.yolo) {
+              await session.setPermission('yolo');
+            }
+            if (this.options.startup.plan) {
+              await session.setPlanMode(true);
+            }
+            this.applyStartupPermissionAndPlanToAppState();
+            this.hideSessionPicker();
           });
         },
         onCancel,
@@ -1955,5 +1970,4 @@ export class KimiTUI {
     this.patchLivePane({ pendingQuestion: null });
     this.restoreEditor();
   }
-
 }
diff --git a/apps/kimi-code/test/cli/options.test.ts b/apps/kimi-code/test/cli/options.test.ts
index 90fb53ecf..e14629e01 100644
--- a/apps/kimi-code/test/cli/options.test.ts
+++ b/apps/kimi-code/test/cli/options.test.ts
@@ -47,7 +47,11 @@ describe('CLI options parsing', () => {
   describe('--version', () => {
     it('prints the version string and exits', () => {
       let output = '';
-      const program = createProgram('1.2.3', () => {}, () => {});
+      const program = createProgram(
+        '1.2.3',
+        () => {},
+        () => {},
+      );
       program.exitOverride();
       program.configureOutput({
         writeOut: (s) => {
@@ -61,7 +65,11 @@ describe('CLI options parsing', () => {
 
     it('supports -V as a short alias', () => {
       let output = '';
-      const program = createProgram('4.5.6', () => {}, () => {});
+      const program = createProgram(
+        '4.5.6',
+        () => {},
+        () => {},
+      );
       program.exitOverride();
       program.configureOutput({
         writeOut: (s) => {
@@ -103,9 +111,7 @@ describe('CLI options parsing', () => {
         '--flag',
       ]);
 
-      expect(pluginRunnerCalls).toEqual([
-        { entry: '/plugin/tool.mjs', args: ['query', '--flag'] },
-      ]);
+      expect(pluginRunnerCalls).toEqual([{ entry: '/plugin/tool.mjs', args: ['query', '--flag'] }]);
     });
   });
 
@@ -161,6 +167,50 @@ describe('CLI options parsing', () => {
     });
   });
 
+  describe('--auto / --yolo / --plan with --session / --continue', () => {
+    it('allows --auto with --continue', () => {
+      const opts = parse(['--auto', '--continue']);
+      expect(opts.auto).toBe(true);
+      expect(opts.continue).toBe(true);
+      expect(validateOptions(opts).uiMode).toBe('shell');
+    });
+
+    it('allows --auto with an explicit session id', () => {
+      const opts = parse(['--auto', '--session', 'ses_123']);
+      expect(opts.auto).toBe(true);
+      expect(opts.session).toBe('ses_123');
+      expect(validateOptions(opts).uiMode).toBe('shell');
+    });
+
+    it('allows --yolo with --continue', () => {
+      const opts = parse(['--yolo', '--continue']);
+      expect(opts.yolo).toBe(true);
+      expect(opts.continue).toBe(true);
+      expect(validateOptions(opts).uiMode).toBe('shell');
+    });
+
+    it('allows --yolo with an explicit session id', () => {
+      const opts = parse(['--yolo', '--session', 'ses_123']);
+      expect(opts.yolo).toBe(true);
+      expect(opts.session).toBe('ses_123');
+      expect(validateOptions(opts).uiMode).toBe('shell');
+    });
+
+    it('allows --plan with --continue', () => {
+      const opts = parse(['--plan', '--continue']);
+      expect(opts.plan).toBe(true);
+      expect(opts.continue).toBe(true);
+      expect(validateOptions(opts).uiMode).toBe('shell');
+    });
+
+    it('allows --plan with an explicit session id', () => {
+      const opts = parse(['--plan', '--session', 'ses_123']);
+      expect(opts.plan).toBe(true);
+      expect(opts.session).toBe('ses_123');
+      expect(validateOptions(opts).uiMode).toBe('shell');
+    });
+  });
+
   describe('--model / -m', () => {
     it('parses -m as a model override', () => {
       expect(parse(['-m', 'kimi-code/k2']).model).toBe('kimi-code/k2');
@@ -211,7 +261,9 @@ describe('CLI options parsing', () => {
     it('rejects prompt mode with bare --session picker', () => {
       const opts = parse(['-p', 'resume here', '--session']);
       expect(() => validateOptions(opts)).toThrow(OptionConflictError);
-      expect(() => validateOptions(opts)).toThrow('Cannot use --session without an id in prompt mode.');
+      expect(() => validateOptions(opts)).toThrow(
+        'Cannot use --session without an id in prompt mode.',
+      );
     });
 
     it('rejects prompt mode with --yolo because prompt mode always uses auto permission', () => {
@@ -281,7 +333,11 @@ describe('CLI options parsing', () => {
     });
 
     it('registers the visible sub-commands', () => {
-      const program = createProgram('0.0.0', () => {}, () => {});
+      const program = createProgram(
+        '0.0.0',
+        () => {},
+        () => {},
+      );
       const commandNames: string[] = program.commands
         .filter((command) => !command.name().startsWith('__'))
         .map((command) => command.name());
diff --git a/apps/kimi-code/test/tui/kimi-tui-startup.test.ts b/apps/kimi-code/test/tui/kimi-tui-startup.test.ts
index f207d3914..a46d67466 100644
--- a/apps/kimi-code/test/tui/kimi-tui-startup.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-startup.test.ts
@@ -1,30 +1,23 @@
-import { describe, expect, it, vi } from "vitest";
+import { log, type GoalSnapshot } from '@moonshot-ai/kimi-code-sdk';
+import type { MigrationPlan } from '@moonshot-ai/migration-legacy';
+import { describe, expect, it, vi } from 'vitest';
 
-import type { MigrationPlan } from "@moonshot-ai/migration-legacy";
-import { log, type GoalSnapshot } from "@moonshot-ai/kimi-code-sdk";
-
-import { KimiTUI, type KimiTUIStartupInput, type TUIState } from "#/tui/kimi-tui";
-import { BannerProvider } from "#/tui/banner/banner-provider";
-import { BannerComponent } from "#/tui/components/chrome/banner";
-import { WelcomeComponent } from "#/tui/components/chrome/welcome";
-import {
-  handleLoginCommand,
-  handleLogoutCommand,
-} from "#/tui/commands/auth";
-import {
-  promptPlatformSelection,
-  promptLogoutProviderSelection,
-} from "#/tui/commands/prompts";
+import { BannerProvider } from '#/tui/banner/banner-provider';
+import { handleLoginCommand, handleLogoutCommand } from '#/tui/commands/auth';
+import { promptPlatformSelection, promptLogoutProviderSelection } from '#/tui/commands/prompts';
+import { BannerComponent } from '#/tui/components/chrome/banner';
+import { WelcomeComponent } from '#/tui/components/chrome/welcome';
+import { KimiTUI, type KimiTUIStartupInput, type TUIState } from '#/tui/kimi-tui';
 import {
   DISABLE_TERMINAL_THEME_REPORTING,
   ENABLE_TERMINAL_THEME_REPORTING,
   OSC11_QUERY,
   QUERY_TERMINAL_THEME,
   TERMINAL_THEME_LIGHT,
-} from "#/tui/utils/terminal-theme";
+} from '#/tui/utils/terminal-theme';
 
-vi.mock("#/tui/commands/prompts", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("#/tui/commands/prompts")>();
+vi.mock('#/tui/commands/prompts', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('#/tui/commands/prompts')>();
   return { ...actual, promptPlatformSelection: vi.fn(), promptLogoutProviderSelection: vi.fn() };
 });
 
@@ -53,7 +46,7 @@ interface MigrateExitDriver extends StartupDriver {
 }
 
 const MIGRATION_PLAN: MigrationPlan = {
-  sourceHome: "/x/.kimi",
+  sourceHome: '/x/.kimi',
   hasConfig: false,
   hasMcp: false,
   hasUserHistory: false,
@@ -65,8 +58,8 @@ const MIGRATION_PLAN: MigrationPlan = {
 };
 
 function makeStartupInput(
-  cliOptions: Partial<KimiTUIStartupInput["cliOptions"]> = {},
-  tuiConfig: Partial<KimiTUIStartupInput["tuiConfig"]> = {},
+  cliOptions: Partial<KimiTUIStartupInput['cliOptions']> = {},
+  tuiConfig: Partial<KimiTUIStartupInput['tuiConfig']> = {},
 ): KimiTUIStartupInput {
   return {
     cliOptions: {
@@ -82,26 +75,26 @@ function makeStartupInput(
       ...cliOptions,
     },
     tuiConfig: {
-      theme: "dark",
+      theme: 'dark',
       editorCommand: null,
-      notifications: { enabled: true, condition: "unfocused" },
+      notifications: { enabled: true, condition: 'unfocused' },
       upgrade: { autoInstall: true },
       ...tuiConfig,
     },
-    version: "0.0.0-test",
-    workDir: "/tmp/proj-a",
+    version: '0.0.0-test',
+    workDir: '/tmp/proj-a',
   };
 }
 
 function makeSession(overrides: Record<string, unknown> = {}) {
   return {
-    id: "ses-1",
-    model: "k2",
-    summary: { title: "Session title" },
+    id: 'ses-1',
+    model: 'k2',
+    summary: { title: 'Session title' },
     getStatus: vi.fn(async () => ({
-      model: "k2",
-      thinkingLevel: "off",
-      permission: "manual",
+      model: 'k2',
+      thinkingLevel: 'off',
+      permission: 'manual',
       planMode: false,
       contextTokens: 10,
       maxContextTokens: 100,
@@ -124,9 +117,9 @@ function makeSession(overrides: Record<string, unknown> = {}) {
 
 function goalSnapshot(overrides: Partial<GoalSnapshot> = {}): GoalSnapshot {
   return {
-    goalId: "goal-1",
-    objective: "Ship feature X",
-    status: "paused",
+    goalId: 'goal-1',
+    objective: 'Ship feature X',
+    status: 'paused',
     turnsUsed: 2,
     tokensUsed: 100,
     wallClockMs: 1000,
@@ -146,9 +139,39 @@ function goalSnapshot(overrides: Partial<GoalSnapshot> = {}): GoalSnapshot {
   };
 }
 
+function createResumeState(overrides: { permissionMode?: string; planMode?: boolean } = {}) {
+  return {
+    id: 'ses-latest',
+    workDir: '/tmp/proj-a',
+    sessionDir: '/tmp/proj-a/.kimi/sessions/ses-latest',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    sessionMetadata: {},
+    agents: {
+      main: {
+        type: 'main',
+        config: {
+          cwd: '/tmp/proj-a',
+          modelCapabilities: { max_context_tokens: 100 },
+          thinkingLevel: 'off',
+          systemPrompt: '',
+        },
+        context: { history: [], tokenCount: 10 },
+        replay: [],
+        permission: { mode: overrides.permissionMode ?? 'manual', rules: [] },
+        plan: overrides.planMode ? { id: 'plan-1', content: '', path: '/tmp/plan.md' } : null,
+        swarmMode: false,
+        usage: {},
+        tools: [],
+        background: [],
+      },
+    },
+  } as never;
+}
+
 function loginRequiredError(): Error & { readonly code: string } {
   return Object.assign(new Error('OAuth provider "managed:kimi-code" requires login.'), {
-    code: "auth.login_required",
+    code: 'auth.login_required',
   });
 }
 
@@ -156,7 +179,7 @@ function makeHarness(session = makeSession(), overrides: Record<string, unknown>
   return {
     getConfig: vi.fn(async () => ({
       models: {
-        k2: { model: "moonshot-v1", maxContextSize: 100 },
+        k2: { model: 'moonshot-v1', maxContextSize: 100 },
       },
     })),
     createSession: vi.fn(async () => session),
@@ -178,21 +201,21 @@ function makeHarness(session = makeSession(), overrides: Record<string, unknown>
 
 function makeDriver(harness: ReturnType<typeof makeHarness>, input: KimiTUIStartupInput) {
   const driver = new KimiTUI(harness as never, input) as unknown as StartupDriver;
-  vi.spyOn(driver.state.ui, "requestRender").mockImplementation(() => {});
-  vi.spyOn(driver.state.terminal, "setProgress").mockImplementation(() => {});
+  vi.spyOn(driver.state.ui, 'requestRender').mockImplementation(() => {});
+  vi.spyOn(driver.state.terminal, 'setProgress').mockImplementation(() => {});
   return driver;
 }
 
-type InputListener = Parameters<TUIState["ui"]["addInputListener"]>[0];
-const DARK_OSC11_REPORT = "\u001B]11;rgb:2828/2c2c/3434\u0007";
-const LIGHT_OSC11_REPORT = "\u001B]11;rgb:fafa/fbfb/fcfc\u0007";
+type InputListener = Parameters<TUIState['ui']['addInputListener']>[0];
+const DARK_OSC11_REPORT = '\u001B]11;rgb:2828/2c2c/3434\u0007';
+const LIGHT_OSC11_REPORT = '\u001B]11;rgb:fafa/fbfb/fcfc\u0007';
 
 function captureInputListeners(driver: StartupDriver) {
   const listeners: InputListener[] = [];
   const removeInputListener = vi.fn<() => void>();
-  const write = vi.spyOn(driver.state.terminal, "write").mockImplementation(() => {});
+  const write = vi.spyOn(driver.state.terminal, 'write').mockImplementation(() => {});
   const addInputListener = vi
-    .spyOn(driver.state.ui, "addInputListener")
+    .spyOn(driver.state.ui, 'addInputListener')
     .mockImplementation((listener: InputListener) => {
       listeners.push(listener);
       return removeInputListener;
@@ -201,13 +224,13 @@ function captureInputListeners(driver: StartupDriver) {
   return { listeners, removeInputListener, write, addInputListener };
 }
 
-describe("KimiTUI startup", () => {
-  it("creates a fresh session from startup flags and syncs runtime state", async () => {
+describe('KimiTUI startup', () => {
+  it('creates a fresh session from startup flags and syncs runtime state', async () => {
     const session = makeSession({
       getStatus: vi.fn(async () => ({
-        model: "k2",
-        thinkingLevel: "off",
-        permission: "yolo",
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'yolo',
         planMode: true,
         contextTokens: 25,
         maxContextTokens: 200,
@@ -220,51 +243,253 @@ describe("KimiTUI startup", () => {
     await expect(driver.init()).resolves.toBe(false);
 
     expect(harness.createSession).toHaveBeenCalledWith({
-      workDir: "/tmp/proj-a",
-      permission: "yolo",
+      workDir: '/tmp/proj-a',
+      permission: 'yolo',
       planMode: true,
     });
     expect(session.setApprovalHandler).toHaveBeenCalledOnce();
     expect(session.setQuestionHandler).toHaveBeenCalledOnce();
     expect(harness.setTelemetryContext).toHaveBeenCalledWith({ sessionId: null });
-    expect(harness.setTelemetryContext).toHaveBeenLastCalledWith({ sessionId: "ses-1" });
-    expect(driver.state.startupState).toBe("ready");
+    expect(harness.setTelemetryContext).toHaveBeenLastCalledWith({ sessionId: 'ses-1' });
+    expect(driver.state.startupState).toBe('ready');
     expect(driver.state.appState).toMatchObject({
-      sessionId: "ses-1",
-      model: "k2",
-      permissionMode: "yolo",
+      sessionId: 'ses-1',
+      model: 'k2',
+      permissionMode: 'yolo',
       planMode: true,
       contextTokens: 25,
       maxContextTokens: 200,
       contextUsage: 0.125,
-      sessionTitle: "Session title",
+      sessionTitle: 'Session title',
     });
   });
 
-  it("resumes the latest session for --continue and marks history for replay", async () => {
-    const session = makeSession({ id: "ses-latest" });
+  it('resumes the latest session for --continue and marks history for replay', async () => {
+    const session = makeSession({ id: 'ses-latest' });
     const harness = makeHarness(session, {
-      listSessions: vi.fn(async () => [{ id: "ses-latest" }, { id: "ses-old" }]),
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }, { id: 'ses-old' }]),
     });
     const driver = makeDriver(harness, makeStartupInput({ continue: true }));
 
     await expect(driver.init()).resolves.toBe(true);
 
-    expect(harness.resumeSession).toHaveBeenCalledWith({ id: "ses-latest" });
+    expect(harness.resumeSession).toHaveBeenCalledWith({ id: 'ses-latest' });
     expect(harness.createSession).not.toHaveBeenCalled();
-    expect(driver.state.startupState).toBe("ready");
-    expect(driver.state.appState.sessionId).toBe("ses-latest");
+    expect(driver.state.startupState).toBe('ready');
+    expect(driver.state.appState.sessionId).toBe('ses-latest');
   });
 
-  it("syncs a persisted goal when resuming a session", async () => {
-    const goal = goalSnapshot({ status: "blocked", terminalReason: "needs input" });
+  it('applies --auto permission when resuming a session via --continue', async () => {
+    let permission = 'manual';
     const session = makeSession({
-      id: "ses-latest",
+      id: 'ses-latest',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission,
+        planMode: false,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPermission: vi.fn(async (mode: string) => {
+        permission = mode;
+      }),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, auto: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+
+    expect(session.setPermission).toHaveBeenCalledWith('auto');
+    expect(driver.state.appState.permissionMode).toBe('auto');
+  });
+
+  it('applies --yolo permission when resuming a session via --continue', async () => {
+    let permission = 'manual';
+    const session = makeSession({
+      id: 'ses-latest',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission,
+        planMode: false,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPermission: vi.fn(async (mode: string) => {
+        permission = mode;
+      }),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, yolo: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+
+    expect(session.setPermission).toHaveBeenCalledWith('yolo');
+    expect(driver.state.appState.permissionMode).toBe('yolo');
+  });
+
+  it('applies --plan mode when resuming a session via --continue', async () => {
+    let planMode = false;
+    const session = makeSession({
+      id: 'ses-latest',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'manual',
+        planMode,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPlanMode: vi.fn(async (enabled: boolean) => {
+        planMode = enabled;
+      }),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, plan: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+
+    expect(session.setPlanMode).toHaveBeenCalledWith(true);
+    expect(driver.state.appState.planMode).toBe(true);
+  });
+
+  it('forces footer state to reflect --auto even if getStatus lags behind', async () => {
+    const session = makeSession({
+      id: 'ses-latest',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'manual',
+        planMode: false,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPermission: vi.fn(async () => {}),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, auto: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+
+    expect(session.setPermission).toHaveBeenCalledWith('auto');
+    expect(driver.state.appState.permissionMode).toBe('auto');
+  });
+
+  it('forces footer state to reflect --plan even if getStatus lags behind', async () => {
+    const session = makeSession({
+      id: 'ses-latest',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'manual',
+        planMode: false,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPlanMode: vi.fn(async () => {}),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, plan: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+
+    expect(session.setPlanMode).toHaveBeenCalledWith(true);
+    expect(driver.state.appState.planMode).toBe(true);
+  });
+
+  it('keeps --auto in the footer after session replay hydration', async () => {
+    const session = makeSession({
+      id: 'ses-latest',
+      getResumeState: vi.fn(() => createResumeState({ permissionMode: 'manual', planMode: false })),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, auto: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+    await (
+      driver as unknown as {
+        finishStartup(shouldReplayHistory: boolean): Promise<void>;
+      }
+    ).finishStartup(true);
+
+    expect(driver.state.appState.permissionMode).toBe('auto');
+  });
+
+  it('keeps --plan in the footer after session replay hydration', async () => {
+    const session = makeSession({
+      id: 'ses-latest',
+      getResumeState: vi.fn(() => createResumeState({ permissionMode: 'manual', planMode: false })),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, plan: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+    await (
+      driver as unknown as {
+        finishStartup(shouldReplayHistory: boolean): Promise<void>;
+      }
+    ).finishStartup(true);
+
+    expect(driver.state.appState.planMode).toBe(true);
+  });
+
+  it('applies --auto permission when resuming an explicit session', async () => {
+    let permission = 'manual';
+    const session = makeSession({
+      id: 'ses-target',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission,
+        planMode: false,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPermission: vi.fn(async (mode: string) => {
+        permission = mode;
+      }),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-target', workDir: '/tmp/proj-a' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ session: 'ses-target', auto: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+
+    expect(session.setPermission).toHaveBeenCalledWith('auto');
+    expect(driver.state.appState.permissionMode).toBe('auto');
+  });
+
+  it('syncs a persisted goal when resuming a session', async () => {
+    const goal = goalSnapshot({ status: 'blocked', terminalReason: 'needs input' });
+    const session = makeSession({
+      id: 'ses-latest',
       getGoal: vi.fn(async () => ({ goal })),
     });
     const harness = makeHarness(session, {
-      listSessions: vi.fn(async () => [{ id: "ses-latest" }]),
-      getExperimentalFeatures: vi.fn(async () => [{ id: "micro_compaction", enabled: true }]),
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+      getExperimentalFeatures: vi.fn(async () => [{ id: 'micro_compaction', enabled: true }]),
     });
     const driver = makeDriver(harness, makeStartupInput({ continue: true }));
 
@@ -274,7 +499,7 @@ describe("KimiTUI startup", () => {
     expect(driver.state.appState.goal).toEqual(goal);
   });
 
-  it("syncs goal state regardless of the goal flag", async () => {
+  it('syncs goal state regardless of the goal flag', async () => {
     const goal = goalSnapshot();
     const session = makeSession({
       getGoal: vi.fn(async () => ({ goal })),
@@ -288,48 +513,48 @@ describe("KimiTUI startup", () => {
     expect(driver.state.appState.goal).toEqual(goal);
   });
 
-  it("clears goal state when closing the current session", async () => {
+  it('clears goal state when closing the current session', async () => {
     const goal = goalSnapshot();
     const session = makeSession({
       getGoal: vi.fn(async () => ({ goal })),
     });
     const harness = makeHarness(session, {
-      getExperimentalFeatures: vi.fn(async () => [{ id: "micro_compaction", enabled: true }]),
+      getExperimentalFeatures: vi.fn(async () => [{ id: 'micro_compaction', enabled: true }]),
     });
     const driver = makeDriver(harness, makeStartupInput()) as unknown as RuntimeStateDriver;
 
     await expect(driver.init()).resolves.toBe(false);
     expect(driver.state.appState.goal).toEqual(goal);
 
-    await driver.closeSession("test close");
+    await driver.closeSession('test close');
 
     expect(driver.state.appState.goal).toBeNull();
   });
 
-  it("passes the CLI model override when creating a fresh startup session", async () => {
+  it('passes the CLI model override when creating a fresh startup session', async () => {
     const harness = makeHarness();
-    const driver = makeDriver(harness, makeStartupInput({ model: "kimi-code/k2.5" }));
+    const driver = makeDriver(harness, makeStartupInput({ model: 'kimi-code/k2.5' }));
 
     await expect(driver.init()).resolves.toBe(false);
 
     expect(harness.createSession).toHaveBeenCalledWith({
-      workDir: "/tmp/proj-a",
-      model: "kimi-code/k2.5",
+      workDir: '/tmp/proj-a',
+      model: 'kimi-code/k2.5',
       permission: undefined,
       planMode: undefined,
     });
   });
 
-  it("applies the CLI model override when resuming a startup session", async () => {
-    let model = "k2";
+  it('applies the CLI model override when resuming a startup session', async () => {
+    let model = 'k2';
     const session = makeSession({
       setModel: vi.fn(async (nextModel: string) => {
         model = nextModel;
       }),
       getStatus: vi.fn(async () => ({
         model,
-        thinkingLevel: "off",
-        permission: "manual",
+        thinkingLevel: 'off',
+        permission: 'manual',
         planMode: false,
         contextTokens: 10,
         maxContextTokens: 100,
@@ -337,51 +562,92 @@ describe("KimiTUI startup", () => {
       })),
     });
     const harness = makeHarness(session, {
-      listSessions: vi.fn(async () => [{ id: "ses-latest" }]),
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
     });
     const driver = makeDriver(
       harness,
-      makeStartupInput({ continue: true, model: "kimi-code/k2.5" }),
+      makeStartupInput({ continue: true, model: 'kimi-code/k2.5' }),
     );
 
     await expect(driver.init()).resolves.toBe(true);
 
-    expect(session.setModel).toHaveBeenCalledWith("kimi-code/k2.5");
-    expect(driver.state.appState.model).toBe("kimi-code/k2.5");
+    expect(session.setModel).toHaveBeenCalledWith('kimi-code/k2.5');
+    expect(driver.state.appState.model).toBe('kimi-code/k2.5');
   });
 
-  it("enters picker startup for bare --session without creating a session", async () => {
+  it('enters picker startup for bare --session without creating a session', async () => {
     const harness = makeHarness();
-    const driver = makeDriver(harness, makeStartupInput({ session: "" }));
+    const driver = makeDriver(harness, makeStartupInput({ session: '' }));
 
     await expect(driver.init()).resolves.toBe(false);
 
     expect(harness.createSession).not.toHaveBeenCalled();
     expect(harness.resumeSession).not.toHaveBeenCalled();
-    expect(driver.state.startupState).toBe("picker");
+    expect(driver.state.startupState).toBe('picker');
   });
 
-  it("clears startup picker exit confirmation before resuming a selected session", async () => {
-    const session = makeSession({ id: "ses-picked" });
+  it('applies --auto after picking a session from bare --session', async () => {
+    let permission = 'manual';
+    const session = makeSession({
+      id: 'ses-picked',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission,
+        planMode: false,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPermission: vi.fn(async (mode: string) => {
+        permission = mode;
+      }),
+    });
     const harness = makeHarness(session, {
       listSessions: vi.fn(async () => [
         {
-          id: "ses-picked",
-          title: "Picked session",
-          workDir: "/tmp/proj-a",
+          id: 'ses-picked',
+          title: 'Picked session',
+          workDir: '/tmp/proj-a',
           updatedAt: Date.now(),
         },
       ]),
     });
-    const driver = makeDriver(harness, makeStartupInput({ session: "" }));
-    const stop = vi.spyOn(driver, "stop").mockResolvedValue(undefined);
+    const driver = makeDriver(harness, makeStartupInput({ session: '', auto: true }));
+
+    await (driver as unknown as { initMainTui(): Promise<boolean> }).initMainTui();
+    expect(driver.state.startupState).toBe('picker');
+    await (driver as unknown as { bootstrapFromPicker(): Promise<void> }).bootstrapFromPicker();
+
+    const picker = driver.state.editorContainer.children[0] as { handleInput(data: string): void };
+    picker.handleInput('\r');
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(session.setPermission).toHaveBeenCalledWith('auto');
+    expect(driver.state.appState.permissionMode).toBe('auto');
+  });
+
+  it('clears startup picker exit confirmation before resuming a selected session', async () => {
+    const session = makeSession({ id: 'ses-picked' });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [
+        {
+          id: 'ses-picked',
+          title: 'Picked session',
+          workDir: '/tmp/proj-a',
+          updatedAt: Date.now(),
+        },
+      ]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ session: '' }));
+    const stop = vi.spyOn(driver, 'stop').mockResolvedValue(undefined);
 
     await expect((driver as unknown as MigrateExitDriver).initMainTui()).resolves.toBe(false);
     await (driver as unknown as { bootstrapFromPicker(): Promise<void> }).bootstrapFromPicker();
 
     const picker = driver.state.editorContainer.children[0] as { handleInput(data: string): void };
-    picker.handleInput("\u0003");
-    picker.handleInput("\r");
+    picker.handleInput('\u0003');
+    picker.handleInput('\r');
     await new Promise((resolve) => setImmediate(resolve));
 
     driver.state.editor.onCtrlC?.();
@@ -389,11 +655,11 @@ describe("KimiTUI startup", () => {
     expect(stop).not.toHaveBeenCalled();
   });
 
-  it("tracks terminal theme reports while auto theme is active", () => {
+  it('tracks terminal theme reports while auto theme is active', () => {
     const harness = makeHarness();
     const driver = makeDriver(
       harness,
-      makeStartupInput({}, { theme: "auto" }),
+      makeStartupInput({}, { theme: 'auto' }),
     ) as unknown as ThemeTrackingDriver;
     const { listeners, write, addInputListener } = captureInputListeners(driver);
 
@@ -408,19 +674,19 @@ describe("KimiTUI startup", () => {
     write.mockClear();
     expect(listeners[0]?.(TERMINAL_THEME_LIGHT)).toEqual({ consume: true });
     expect(write).toHaveBeenCalledWith(OSC11_QUERY);
-    expect(driver.state.appState.theme).toBe("auto");
+    expect(driver.state.appState.theme).toBe('auto');
     expect(driver.state.ui.requestRender).not.toHaveBeenCalled();
 
     expect(listeners[0]?.(DARK_OSC11_REPORT)).toEqual({ consume: true });
-    expect(driver.state.appState.theme).toBe("auto");
+    expect(driver.state.appState.theme).toBe('auto');
     expect(driver.state.ui.requestRender).not.toHaveBeenCalled();
 
     expect(listeners[0]?.(LIGHT_OSC11_REPORT)).toEqual({ consume: true });
-    expect(driver.state.appState.theme).toBe("auto");
+    expect(driver.state.appState.theme).toBe('auto');
     expect(driver.state.ui.requestRender).toHaveBeenCalled();
   });
 
-  it("does not track terminal theme reports for explicit themes", () => {
+  it('does not track terminal theme reports for explicit themes', () => {
     const harness = makeHarness();
     const driver = makeDriver(harness, makeStartupInput()) as unknown as ThemeTrackingDriver;
     const { write, addInputListener } = captureInputListeners(driver);
@@ -431,23 +697,23 @@ describe("KimiTUI startup", () => {
     expect(write).not.toHaveBeenCalled();
   });
 
-  it("disables terminal theme reports after leaving auto theme", () => {
+  it('disables terminal theme reports after leaving auto theme', () => {
     const harness = makeHarness();
     const driver = makeDriver(
       harness,
-      makeStartupInput({}, { theme: "auto" }),
+      makeStartupInput({}, { theme: 'auto' }),
     ) as unknown as ThemeTrackingDriver;
     const { write, removeInputListener } = captureInputListeners(driver);
 
     driver.refreshTerminalThemeTracking();
-    driver.state.appState.theme = "dark";
+    driver.state.appState.theme = 'dark';
     driver.refreshTerminalThemeTracking();
 
     expect(removeInputListener).toHaveBeenCalledOnce();
     expect(write).toHaveBeenCalledWith(DISABLE_TERMINAL_THEME_REPORTING);
   });
 
-  it("starts TUI without a session when fresh startup needs OAuth login", async () => {
+  it('starts TUI without a session when fresh startup needs OAuth login', async () => {
     const harness = makeHarness(makeSession(), {
       createSession: vi.fn(async () => {
         throw loginRequiredError();
@@ -457,11 +723,11 @@ describe("KimiTUI startup", () => {
 
     await expect(driver.init()).resolves.toBe(false);
 
-    expect(driver.state.startupState).toBe("ready");
-    expect((driver as any).startupNotice).toContain("OAuth login expired");
+    expect(driver.state.startupState).toBe('ready');
+    expect((driver as any).startupNotice).toContain('OAuth login expired');
     expect(driver.state.appState).toMatchObject({
-      sessionId: "",
-      model: "",
+      sessionId: '',
+      model: '',
       thinking: false,
       contextTokens: 0,
       maxContextTokens: 0,
@@ -470,12 +736,12 @@ describe("KimiTUI startup", () => {
     });
   });
 
-  it("preserves fresh startup yolo and plan intent after OAuth login", async () => {
+  it('preserves fresh startup yolo and plan intent after OAuth login', async () => {
     const session = makeSession({
       getStatus: vi.fn(async () => ({
-        model: "k2",
-        thinkingLevel: "off",
-        permission: "yolo",
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'yolo',
         planMode: true,
         contextTokens: 10,
         maxContextTokens: 100,
@@ -488,10 +754,10 @@ describe("KimiTUI startup", () => {
       .mockResolvedValueOnce(session);
     const harness = makeHarness(session, {
       getConfig: vi.fn(async () => ({
-        defaultModel: "k2",
+        defaultModel: 'k2',
         defaultThinking: false,
         models: {
-          k2: { model: "moonshot-v1", maxContextSize: 100 },
+          k2: { model: 'moonshot-v1', maxContextSize: 100 },
         },
       })),
       createSession,
@@ -501,9 +767,9 @@ describe("KimiTUI startup", () => {
     await expect(driver.init()).resolves.toBe(false);
 
     expect(driver.state.appState).toMatchObject({
-      sessionId: "",
-      model: "",
-      permissionMode: "yolo",
+      sessionId: '',
+      model: '',
+      permissionMode: 'yolo',
       planMode: true,
     });
 
@@ -511,31 +777,31 @@ describe("KimiTUI startup", () => {
     await handleLoginCommand(driver as any);
 
     expect(createSession).toHaveBeenNthCalledWith(1, {
-      workDir: "/tmp/proj-a",
-      permission: "yolo",
+      workDir: '/tmp/proj-a',
+      permission: 'yolo',
       planMode: true,
     });
     expect(createSession).toHaveBeenNthCalledWith(2, {
-      workDir: "/tmp/proj-a",
-      model: "k2",
-      thinking: "off",
-      permission: "yolo",
+      workDir: '/tmp/proj-a',
+      model: 'k2',
+      thinking: 'off',
+      permission: 'yolo',
       planMode: true,
     });
     expect(driver.state.appState).toMatchObject({
-      sessionId: "ses-1",
-      model: "k2",
-      permissionMode: "yolo",
+      sessionId: 'ses-1',
+      model: 'k2',
+      permissionMode: 'yolo',
       planMode: true,
     });
   });
 
-  it("does not force manual permission after OAuth login without --yolo", async () => {
+  it('does not force manual permission after OAuth login without --yolo', async () => {
     const session = makeSession({
       getStatus: vi.fn(async () => ({
-        model: "k2",
-        thinkingLevel: "off",
-        permission: "auto",
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'auto',
         planMode: false,
         contextTokens: 10,
         maxContextTokens: 100,
@@ -548,10 +814,10 @@ describe("KimiTUI startup", () => {
       .mockResolvedValueOnce(session);
     const harness = makeHarness(session, {
       getConfig: vi.fn(async () => ({
-        defaultModel: "k2",
+        defaultModel: 'k2',
         defaultThinking: false,
         models: {
-          k2: { model: "moonshot-v1", maxContextSize: 100 },
+          k2: { model: 'moonshot-v1', maxContextSize: 100 },
         },
       })),
       createSession,
@@ -563,25 +829,25 @@ describe("KimiTUI startup", () => {
     await handleLoginCommand(driver as any);
 
     expect(createSession).toHaveBeenNthCalledWith(2, {
-      workDir: "/tmp/proj-a",
-      model: "k2",
-      thinking: "off",
+      workDir: '/tmp/proj-a',
+      model: 'k2',
+      thinking: 'off',
       permission: undefined,
       planMode: undefined,
     });
     expect(driver.state.appState).toMatchObject({
-      permissionMode: "auto",
+      permissionMode: 'auto',
     });
   });
 
-  it("syncs configured thinking after OAuth login refreshes an active session", async () => {
+  it('syncs configured thinking after OAuth login refreshes an active session', async () => {
     const session = makeSession();
     const harness = makeHarness(session, {
       getConfig: vi.fn(async () => ({
-        defaultModel: "k2",
+        defaultModel: 'k2',
         defaultThinking: true,
         models: {
-          k2: { model: "moonshot-v1", maxContextSize: 100 },
+          k2: { model: 'moonshot-v1', maxContextSize: 100 },
         },
       })),
     });
@@ -593,25 +859,25 @@ describe("KimiTUI startup", () => {
     vi.mocked(promptPlatformSelection).mockResolvedValue('kimi-code');
     await handleLoginCommand(driver as any);
 
-    expect(session.setModel).toHaveBeenCalledWith("k2");
-    expect(session.setThinking).toHaveBeenCalledWith("on");
+    expect(session.setModel).toHaveBeenCalledWith('k2');
+    expect(session.setThinking).toHaveBeenCalledWith('on');
     expect(driver.state.appState).toMatchObject({
-      model: "k2",
+      model: 'k2',
       thinking: true,
       maxContextTokens: 100,
     });
-    expect(harness.track).toHaveBeenCalledWith("login", {
-      provider: "managed:kimi-code",
+    expect(harness.track).toHaveBeenCalledWith('login', {
+      provider: 'managed:kimi-code',
       already_logged_in: false,
     });
   });
 
-  it("tracks login with already_logged_in when a token already exists", async () => {
+  it('tracks login with already_logged_in when a token already exists', async () => {
     const session = makeSession();
     const harness = makeHarness(session, {
       auth: {
         status: vi.fn(async () => ({
-          providers: [{ providerName: "managed:kimi-code", hasToken: true }],
+          providers: [{ providerName: 'managed:kimi-code', hasToken: true }],
         })),
         login: vi.fn(async () => {}),
         logout: vi.fn(),
@@ -627,22 +893,22 @@ describe("KimiTUI startup", () => {
     await handleLoginCommand(driver as any);
 
     expect(harness.auth.login).toHaveBeenCalledWith(
-      "managed:kimi-code",
+      'managed:kimi-code',
       expect.objectContaining({
         signal: expect.any(AbortSignal),
         onDeviceCode: expect.any(Function),
       }),
     );
-    expect(harness.track).toHaveBeenCalledWith("login", {
-      provider: "managed:kimi-code",
+    expect(harness.track).toHaveBeenCalledWith('login', {
+      provider: 'managed:kimi-code',
       already_logged_in: true,
     });
   });
 
-  it("logs login failures with session context", async () => {
-    const warn = vi.spyOn(log, "warn").mockImplementation(() => {});
+  it('logs login failures with session context', async () => {
+    const warn = vi.spyOn(log, 'warn').mockImplementation(() => {});
     const session = makeSession();
-    const loginError = new Error("Failed to list Kimi Code models (HTTP 402).");
+    const loginError = new Error('Failed to list Kimi Code models (HTTP 402).');
     const harness = makeHarness(session, {
       auth: {
         status: vi.fn(async () => ({ providers: [] })),
@@ -662,20 +928,20 @@ describe("KimiTUI startup", () => {
       await handleLoginCommand(driver as any);
 
       expect(harness.auth.login).toHaveBeenCalledWith(
-        "managed:kimi-code",
+        'managed:kimi-code',
         expect.objectContaining({
           signal: expect.any(AbortSignal),
           onDeviceCode: expect.any(Function),
         }),
       );
       expect(warn).toHaveBeenCalledWith(
-        "login failed",
+        'login failed',
         expect.objectContaining({
-          providerName: "managed:kimi-code",
+          providerName: 'managed:kimi-code',
           alreadyLoggedIn: false,
-          sessionId: "ses-1",
+          sessionId: 'ses-1',
           error: expect.objectContaining({
-            message: "Failed to list Kimi Code models (HTTP 402).",
+            message: 'Failed to list Kimi Code models (HTTP 402).',
           }),
         }),
       );
@@ -684,18 +950,18 @@ describe("KimiTUI startup", () => {
     }
   });
 
-  it("tracks logout after managed credentials and session state are cleared", async () => {
+  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 },
+          k2: { provider: 'managed:kimi-code', model: 'moonshot-v1', maxContextSize: 100 },
         },
-        providers: { "managed:kimi-code": { type: "kimi" } },
+        providers: { 'managed:kimi-code': { type: 'kimi' } },
       })),
       auth: {
         status: vi.fn(async () => ({
-          providers: [{ providerName: "managed:kimi-code", hasToken: true }],
+          providers: [{ providerName: 'managed:kimi-code', hasToken: true }],
         })),
         login: vi.fn(async () => {}),
         logout: vi.fn(),
@@ -707,38 +973,36 @@ describe("KimiTUI startup", () => {
     await expect(driver.init()).resolves.toBe(false);
     harness.track.mockClear();
 
-    vi.mocked(promptLogoutProviderSelection).mockResolvedValue(
-      "managed:kimi-code",
-    );
+    vi.mocked(promptLogoutProviderSelection).mockResolvedValue('managed:kimi-code');
     await handleLogoutCommand(driver as any);
 
-    expect(harness.auth.logout).toHaveBeenCalledWith("managed:kimi-code");
+    expect(harness.auth.logout).toHaveBeenCalledWith('managed:kimi-code');
     expect(session.close).toHaveBeenCalledOnce();
     expect(driver.state.appState).toMatchObject({
-      sessionId: "",
-      model: "",
+      sessionId: '',
+      model: '',
       sessionTitle: null,
     });
-    expect(harness.track).toHaveBeenCalledWith("logout", { provider: "managed:kimi-code" });
+    expect(harness.track).toHaveBeenCalledWith('logout', { provider: 'managed:kimi-code' });
   });
 
-  it("keeps the active session when logging out a different provider", async () => {
+  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 },
+          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" },
+          '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 }],
+          providers: [{ providerName: 'managed:kimi-code', hasToken: true }],
         })),
         login: vi.fn(async () => {}),
         logout: vi.fn(),
@@ -750,33 +1014,33 @@ describe("KimiTUI startup", () => {
     await expect(driver.init()).resolves.toBe(false);
     harness.track.mockClear();
 
-    vi.mocked(promptLogoutProviderSelection).mockResolvedValue("openai");
+    vi.mocked(promptLogoutProviderSelection).mockResolvedValue('openai');
     await handleLogoutCommand(driver as any);
 
-    expect(removeProvider).toHaveBeenCalledWith("openai");
+    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",
+      sessionId: 'ses-1',
+      model: 'k2',
     });
-    expect(harness.track).toHaveBeenCalledWith("logout", { provider: "openai" });
+    expect(harness.track).toHaveBeenCalledWith('logout', { provider: 'openai' });
   });
 
-  it("can log out a stale managed entry even after the OAuth token is gone", async () => {
+  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 },
+          k2: { provider: 'managed:kimi-code', model: 'moonshot-v1', maxContextSize: 100 },
         },
-        providers: { "managed:kimi-code": { type: "kimi" } },
+        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 }],
+          providers: [{ providerName: 'managed:kimi-code', hasToken: false }],
         })),
         login: vi.fn(async () => {}),
         logout: vi.fn(),
@@ -787,17 +1051,15 @@ describe("KimiTUI startup", () => {
 
     await expect(driver.init()).resolves.toBe(false);
 
-    vi.mocked(promptLogoutProviderSelection).mockResolvedValue(
-      "managed:kimi-code",
-    );
+    vi.mocked(promptLogoutProviderSelection).mockResolvedValue('managed:kimi-code');
     await handleLogoutCommand(driver as any);
 
-    expect(harness.auth.logout).toHaveBeenCalledWith("managed:kimi-code");
+    expect(harness.auth.logout).toHaveBeenCalledWith('managed:kimi-code');
   });
 
-  it("starts TUI without replaying when --continue needs OAuth login", async () => {
+  it('starts TUI without replaying when --continue needs OAuth login', async () => {
     const harness = makeHarness(makeSession(), {
-      listSessions: vi.fn(async () => [{ id: "ses-latest" }]),
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
       resumeSession: vi.fn(async () => {
         throw loginRequiredError();
       }),
@@ -806,29 +1068,29 @@ describe("KimiTUI startup", () => {
 
     await expect(driver.init()).resolves.toBe(false);
 
-    expect(harness.resumeSession).toHaveBeenCalledWith({ id: "ses-latest" });
+    expect(harness.resumeSession).toHaveBeenCalledWith({ id: 'ses-latest' });
     expect(harness.createSession).not.toHaveBeenCalled();
-    expect(driver.state.startupState).toBe("ready");
-    expect(driver.state.appState.sessionId).toBe("");
+    expect(driver.state.startupState).toBe('ready');
+    expect(driver.state.appState.sessionId).toBe('');
   });
 
-  it("starts TUI without replaying when an explicit resume needs OAuth login", async () => {
+  it('starts TUI without replaying when an explicit resume needs OAuth login', async () => {
     const harness = makeHarness(makeSession(), {
-      listSessions: vi.fn(async () => [{ id: "ses-target", workDir: "/tmp/proj-a" }]),
+      listSessions: vi.fn(async () => [{ id: 'ses-target', workDir: '/tmp/proj-a' }]),
       resumeSession: vi.fn(async () => {
         throw loginRequiredError();
       }),
     });
-    const driver = makeDriver(harness, makeStartupInput({ session: "ses-target" }));
+    const driver = makeDriver(harness, makeStartupInput({ session: 'ses-target' }));
 
     await expect(driver.init()).resolves.toBe(false);
 
-    expect(harness.resumeSession).toHaveBeenCalledWith({ id: "ses-target" });
-    expect(driver.state.startupState).toBe("ready");
-    expect(driver.state.appState.sessionId).toBe("");
+    expect(harness.resumeSession).toHaveBeenCalledWith({ id: 'ses-target' });
+    expect(driver.state.startupState).toBe('ready');
+    expect(driver.state.appState.sessionId).toBe('');
   });
 
-  it("disposes terminal focus/theme tracking on the kimi migrate exit", async () => {
+  it('disposes terminal focus/theme tracking on the kimi migrate exit', async () => {
     const harness = makeHarness();
     const driver = makeDriver(harness, {
       ...makeStartupInput(),
@@ -836,11 +1098,11 @@ describe("KimiTUI startup", () => {
       migrateOnly: true,
     }) as unknown as MigrateExitDriver;
     // pi-tui start/stop and focus tracking touch the real TTY — stub the I/O.
-    vi.spyOn(driver.state.ui, "start").mockImplementation(() => {});
-    vi.spyOn(driver.state.ui, "stop").mockImplementation(() => {});
-    vi.spyOn(driver.state.terminal, "write").mockImplementation(() => {});
+    vi.spyOn(driver.state.ui, 'start').mockImplementation(() => {});
+    vi.spyOn(driver.state.ui, 'stop').mockImplementation(() => {});
+    vi.spyOn(driver.state.terminal, 'write').mockImplementation(() => {});
     // The migration screen would await user input; resolve it immediately.
-    vi.spyOn(driver, "runMigrationScreen").mockResolvedValue({ decision: "later" });
+    vi.spyOn(driver, 'runMigrationScreen').mockResolvedValue({ decision: 'later' });
     const onExit = vi.fn(async () => {});
     driver.onExit = onExit;
 
@@ -853,40 +1115,40 @@ describe("KimiTUI startup", () => {
     expect(onExit).toHaveBeenCalledWith(0);
   });
 
-  it("disposes terminal tracking when post-migration startup fails", async () => {
+  it('disposes terminal tracking when post-migration startup fails', async () => {
     const harness = makeHarness();
     const driver = makeDriver(harness, {
       ...makeStartupInput(),
       migrationPlan: MIGRATION_PLAN,
       migrateOnly: false,
     }) as unknown as MigrateExitDriver;
-    vi.spyOn(driver.state.ui, "start").mockImplementation(() => {});
-    vi.spyOn(driver.state.ui, "stop").mockImplementation(() => {});
-    vi.spyOn(driver.state.terminal, "write").mockImplementation(() => {});
+    vi.spyOn(driver.state.ui, 'start').mockImplementation(() => {});
+    vi.spyOn(driver.state.ui, 'stop').mockImplementation(() => {});
+    vi.spyOn(driver.state.terminal, 'write').mockImplementation(() => {});
     // The migration screen resolves "later"; startup then continues into
     // initMainTui(), which fails (e.g. a session-resume error).
-    vi.spyOn(driver, "runMigrationScreen").mockResolvedValue({ decision: "later" });
-    vi.spyOn(driver, "initMainTui").mockRejectedValue(new Error("resume boom"));
+    vi.spyOn(driver, 'runMigrationScreen').mockResolvedValue({ decision: 'later' });
+    vi.spyOn(driver, 'initMainTui').mockRejectedValue(new Error('resume boom'));
 
-    await expect(driver.start()).rejects.toThrow("resume boom");
+    await expect(driver.start()).rejects.toThrow('resume boom');
 
     // The focus tracking installed by startEventLoop() must be torn down
     // before the error propagates — not left active after the process exits.
     expect(driver.terminalFocusTrackingDispose).toBeUndefined();
   });
 
-  it("keeps non-login startup session errors fatal", async () => {
+  it('keeps non-login startup session errors fatal', async () => {
     const harness = makeHarness(makeSession(), {
       createSession: vi.fn(async () => {
-        throw new Error("provider config is invalid");
+        throw new Error('provider config is invalid');
       }),
     });
     const driver = makeDriver(harness, makeStartupInput());
 
-    await expect(driver.init()).rejects.toThrow("provider config is invalid");
+    await expect(driver.init()).rejects.toThrow('provider config is invalid');
   });
 
-  it("does not mount the footer when resuming a missing session fails", async () => {
+  it('does not mount the footer when resuming a missing session fails', async () => {
     // Regression: a stray pre-startEventLoop render used to paint the footer
     // (cwd/git + "context:" statusline) to the terminal before the fatal
     // error, leaving it stranded above the error message. The footer must not
@@ -896,23 +1158,21 @@ describe("KimiTUI startup", () => {
     });
     const driver = makeDriver(
       harness,
-      makeStartupInput({ session: "missing-session" }),
+      makeStartupInput({ session: 'missing-session' }),
     ) as unknown as MigrateExitDriver;
 
-    await expect(driver.initMainTui()).rejects.toThrow(
-      'Session "missing-session" not found.',
-    );
+    await expect(driver.initMainTui()).rejects.toThrow('Session "missing-session" not found.');
     expect(uiContainsFooter(driver)).toBe(false);
   });
 
-  it("mounts the footer once startup reaches the main TUI", async () => {
-    const session = makeSession({ id: "ses-target" });
+  it('mounts the footer once startup reaches the main TUI', async () => {
+    const session = makeSession({ id: 'ses-target' });
     const harness = makeHarness(session, {
-      listSessions: vi.fn(async () => [{ id: "ses-target", workDir: "/tmp/proj-a" }]),
+      listSessions: vi.fn(async () => [{ id: 'ses-target', workDir: '/tmp/proj-a' }]),
     });
     const driver = makeDriver(
       harness,
-      makeStartupInput({ session: "ses-target" }),
+      makeStartupInput({ session: 'ses-target' }),
     ) as unknown as MigrateExitDriver;
 
     // Not mounted until init() succeeds.
@@ -923,31 +1183,27 @@ describe("KimiTUI startup", () => {
     expect(uiContainsFooter(driver)).toBe(true);
   });
 
-  it("renders the banner below the welcome message after it loads", async () => {
+  it('renders the banner below the welcome message after it loads', async () => {
     const banner = {
-      tag: "New",
-      mainText: "Banner main",
+      tag: 'New',
+      mainText: 'Banner main',
       subText: null,
     };
-    const loadSpy = vi
-      .spyOn(BannerProvider.prototype, "load")
-      .mockResolvedValue(banner);
-    const session = makeSession({ id: "ses-target" });
+    const loadSpy = vi.spyOn(BannerProvider.prototype, 'load').mockResolvedValue(banner);
+    const session = makeSession({ id: 'ses-target' });
     const harness = makeHarness(session, {
-      listSessions: vi.fn(async () => [{ id: "ses-target", workDir: "/tmp/proj-a" }]),
+      listSessions: vi.fn(async () => [{ id: 'ses-target', workDir: '/tmp/proj-a' }]),
     });
     const driver = makeDriver(
       harness,
-      makeStartupInput({ session: "ses-target" }),
+      makeStartupInput({ session: 'ses-target' }),
     ) as unknown as MigrateExitDriver;
 
     await driver.initMainTui();
 
     await vi.waitFor(() => {
       expect(
-        driver.state.transcriptContainer.children.some(
-          (child) => child instanceof BannerComponent,
-        ),
+        driver.state.transcriptContainer.children.some((child) => child instanceof BannerComponent),
       ).toBe(true);
     });
 
@@ -965,29 +1221,24 @@ describe("KimiTUI startup", () => {
     loadSpy.mockRestore();
   });
 
-  it("resumes a startup session when Windows workdir uses backslashes", async () => {
-    const session = makeSession({ id: "ses-target" });
+  it('resumes a startup session when Windows workdir uses backslashes', async () => {
+    const session = makeSession({ id: 'ses-target' });
     const harness = makeHarness(session, {
-      listSessions: vi.fn(async () => [
-        { id: "ses-target", workDir: "C:/Users/kimi/project" },
-      ]),
+      listSessions: vi.fn(async () => [{ id: 'ses-target', workDir: 'C:/Users/kimi/project' }]),
+    });
+    const driver = makeDriver(harness, {
+      ...makeStartupInput({ session: 'ses-target' }),
+      workDir: String.raw`C:\Users\kimi\project`,
     });
-    const driver = makeDriver(
-      harness,
-      {
-        ...makeStartupInput({ session: "ses-target" }),
-        workDir: String.raw`C:\Users\kimi\project`,
-      },
-    );
 
     await expect(driver.init()).resolves.toBe(true);
 
     expect(harness.listSessions).toHaveBeenCalledWith({
-      sessionId: "ses-target",
+      sessionId: 'ses-target',
       workDir: String.raw`C:\Users\kimi\project`,
     });
-    expect(harness.resumeSession).toHaveBeenCalledWith({ id: "ses-target" });
-    expect(driver.state.appState.sessionId).toBe("ses-target");
+    expect(harness.resumeSession).toHaveBeenCalledWith({ id: 'ses-target' });
+    expect(driver.state.appState.sessionId).toBe('ses-target');
   });
 });
 
diff --git a/docs/en/guides/sessions.md b/docs/en/guides/sessions.md
index 6f8a05913..15c56fcca 100644
--- a/docs/en/guides/sessions.md
+++ b/docs/en/guides/sessions.md
@@ -51,7 +51,7 @@ kimi --session
 ```
 
 ::: warning
-`--continue` and `--session` are mutually exclusive. `--yolo` and `--plan` cannot be combined with them either.
+`--continue` and `--session` are mutually exclusive.
 :::
 
 ## Switching sessions inside the TUI
diff --git a/docs/en/reference/kimi-command.md b/docs/en/reference/kimi-command.md
index b8be01096..5b96a9496 100644
--- a/docs/en/reference/kimi-command.md
+++ b/docs/en/reference/kimi-command.md
@@ -37,12 +37,10 @@ The following combinations are rejected at startup:
 
 - `--continue` and `--session` are mutually exclusive — both mean "resume a previous session"
 - `--yolo` and `--auto` are mutually exclusive — the two permission modes cannot be combined
-- `--yolo` and `--auto` cannot be used together with `--continue` or `--session` — resumed sessions inherit the approval settings of the original session
-- `--plan` cannot be used with `--continue` or `--session` — Plan mode only takes effect for new sessions
 - `--prompt` cannot be used with `--yolo`, `--auto`, or `--plan` — non-interactive mode uses `auto` permission by default
 - `--output-format` can only be used together with `--prompt`
 
-To force YOLO or Plan mode when resuming a session, switch via slash commands inside the interactive session instead.
+When resuming a session, you can override its saved permission or plan mode by adding `--auto`, `--yolo`, or `--plan`. For example, `kimi --continue --auto` resumes the latest session and switches it to auto permission mode.
 
 ## Common Usage
 
diff --git a/docs/zh/guides/sessions.md b/docs/zh/guides/sessions.md
index ad042f610..444fb4489 100644
--- a/docs/zh/guides/sessions.md
+++ b/docs/zh/guides/sessions.md
@@ -51,7 +51,7 @@ kimi --session
 ```
 
 ::: warning 注意
-`--continue` 与 `--session` 互斥；`--yolo` 和 `--plan` 也不能与它们同时使用。
+`--continue` 与 `--session` 互斥。
 :::
 
 ## 在 TUI 中切换会话
diff --git a/docs/zh/reference/kimi-command.md b/docs/zh/reference/kimi-command.md
index 36fb20d4c..67d259f30 100644
--- a/docs/zh/reference/kimi-command.md
+++ b/docs/zh/reference/kimi-command.md
@@ -37,12 +37,10 @@ kimi <subcommand> [options]
 
 - `--continue` 与 `--session` 互斥——两者都表示"恢复历史会话"
 - `--yolo` 和 `--auto` 互斥——两种权限模式互斥
-- `--yolo` 与 `--auto` 不能与 `--continue` 或 `--session` 同时使用——恢复会话时沿用原会话的审批设置
-- `--plan` 不能与 `--continue` 或 `--session` 同时使用——Plan 模式只对新会话生效
 - `--prompt` 不能与 `--yolo`、`--auto` 或 `--plan` 同时使用——非交互模式固定使用 `auto` 权限
 - `--output-format` 只能与 `--prompt` 一起使用
 
-如需在恢复会话时强制使用 YOLO 或 Plan 模式，请改在交互式会话内通过斜杠命令切换。
+恢复会话时，可以通过 `--auto`、`--yolo` 或 `--plan` 覆盖原会话保存的权限或计划模式。例如，`kimi --continue --auto` 会恢复最近会话并切换到 auto 权限模式。
 
 ## 典型用法
 

From 1b55185f841b4d32883e0a188c5168fce6078346 Mon Sep 17 00:00:00 2001
From: Haozhe <yanghaozhe@moonshot.ai>
Date: Fri, 12 Jun 2026 15:02:49 +0800
Subject: [PATCH 02/17] fix(changeset): downgrade agent-core and kimi-code
 bumps from minor to patch (#687)

Update .changeset/qualify-sub-skill-names.md to use patch instead of minor for both packages.
---
 .changeset/qualify-sub-skill-names.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.changeset/qualify-sub-skill-names.md b/.changeset/qualify-sub-skill-names.md
index f6f5823aa..a7c4d4700 100644
--- a/.changeset/qualify-sub-skill-names.md
+++ b/.changeset/qualify-sub-skill-names.md
@@ -1,6 +1,6 @@
 ---
-"@moonshot-ai/agent-core": minor
-"@moonshot-ai/kimi-code": minor
+"@moonshot-ai/agent-core": patch
+"@moonshot-ai/kimi-code": patch
 ---
 
 Qualify sub-skill names with their parent prefix and expose sub-skills as dotted slash commands in the TUI.

From c1191f5794f298d42cc256d066d653913ed4665e Mon Sep 17 00:00:00 2001
From: 7Sageer <12210216@mail.sustech.edu.cn>
Date: Fri, 12 Jun 2026 15:05:26 +0800
Subject: [PATCH 03/17] test: redact internal endpoint fixtures (#688)

---
 .../test/utils/kimi-datasource-plugin.test.ts |  2 +-
 .../agent-core/test/config/configs.test.ts    | 16 +++----
 .../agent-core/test/rpc/plugins-rpc.test.ts   |  8 ++--
 packages/node-sdk/test/auth-facade.test.ts    | 34 ++++++-------
 packages/oauth/test/managed-kimi-code.test.ts | 48 +++++++++----------
 packages/oauth/test/toolkit.test.ts           |  8 ++--
 6 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/apps/kimi-code/test/utils/kimi-datasource-plugin.test.ts b/apps/kimi-code/test/utils/kimi-datasource-plugin.test.ts
index 51b6d04a2..456ee3007 100644
--- a/apps/kimi-code/test/utils/kimi-datasource-plugin.test.ts
+++ b/apps/kimi-code/test/utils/kimi-datasource-plugin.test.ts
@@ -156,7 +156,7 @@ describe('kimi-datasource MCP server', () => {
       }
 
       const baseUrl = `http://127.0.0.1:${address.port}/coding/v1`;
-      const oauthHost = 'https://auth.dev.kimi.team';
+      const oauthHost = 'https://auth.dev.example.test';
       const scopedCredential = kimiCodeEnvCredentialName({ oauthHost, baseUrl });
 
       await mkdir(join(kimiHome, 'credentials'), { recursive: true });
diff --git a/packages/agent-core/test/config/configs.test.ts b/packages/agent-core/test/config/configs.test.ts
index dd3bb2eb8..3eb85fe98 100644
--- a/packages/agent-core/test/config/configs.test.ts
+++ b/packages/agent-core/test/config/configs.test.ts
@@ -232,29 +232,29 @@ source = { kind = "apiJson", url = "https://registry.example/api.json", apiKey =
     const toml = `
 [providers."managed:kimi-code"]
 type = "kimi"
-base_url = "https://coding.deva.msh.team/coding/v1"
+base_url = "https://api.dev.example.test/coding/v1"
 api_key = ""
-oauth = { storage = "file", key = "oauth/kimi-code-env-1234", oauth_host = "https://auth.dev.kimi.team" }
+oauth = { storage = "file", key = "oauth/kimi-code-env-1234", oauth_host = "https://auth.dev.example.test" }
 
 [services.moonshot_search]
-base_url = "https://coding.deva.msh.team/coding/v1/search"
+base_url = "https://api.dev.example.test/coding/v1/search"
 api_key = ""
-oauth = { storage = "file", key = "oauth/kimi-code-env-1234", oauth_host = "https://auth.dev.kimi.team" }
+oauth = { storage = "file", key = "oauth/kimi-code-env-1234", oauth_host = "https://auth.dev.example.test" }
 `;
     const config = parseConfigString(toml, configPath);
     expect(config.providers['managed:kimi-code']?.oauth).toEqual({
       storage: 'file',
       key: 'oauth/kimi-code-env-1234',
-      oauthHost: 'https://auth.dev.kimi.team',
+      oauthHost: 'https://auth.dev.example.test',
     });
-    expect(config.services?.moonshotSearch?.oauth?.oauthHost).toBe('https://auth.dev.kimi.team');
+    expect(config.services?.moonshotSearch?.oauth?.oauthHost).toBe('https://auth.dev.example.test');
 
     await writeConfigFile(configPath, config);
     const text = await readFile(configPath, 'utf-8');
-    expect(text).toContain('oauth_host = "https://auth.dev.kimi.team"');
+    expect(text).toContain('oauth_host = "https://auth.dev.example.test"');
     const roundTripped = parseConfigString(text, configPath);
     expect(roundTripped.providers['managed:kimi-code']?.oauth?.oauthHost).toBe(
-      'https://auth.dev.kimi.team',
+      'https://auth.dev.example.test',
     );
   });
 
diff --git a/packages/agent-core/test/rpc/plugins-rpc.test.ts b/packages/agent-core/test/rpc/plugins-rpc.test.ts
index 5fa2c8538..fa7f9fd84 100644
--- a/packages/agent-core/test/rpc/plugins-rpc.test.ts
+++ b/packages/agent-core/test/rpc/plugins-rpc.test.ts
@@ -99,9 +99,9 @@ describe('KimiCore plugin RPCs', () => {
         `
 [providers."managed:kimi-code"]
 type = "kimi"
-base_url = "https://coding.deva.msh.team/coding/v1"
+base_url = "https://api.dev.example.test/coding/v1"
 api_key = ""
-oauth = { storage = "file", key = "oauth/kimi-code-env-1234", oauth_host = "https://auth.dev.kimi.team" }
+oauth = { storage = "file", key = "oauth/kimi-code-env-1234", oauth_host = "https://auth.dev.example.test" }
 `,
         'utf8',
       );
@@ -130,8 +130,8 @@ oauth = { storage = "file", key = "oauth/kimi-code-env-1234", oauth_host = "http
 
       expect(mcpConfig.servers['plugin-kimi-datasource:data']?.env).toEqual(
         expect.objectContaining({
-          KIMI_CODE_BASE_URL: 'https://coding.deva.msh.team/coding/v1',
-          KIMI_CODE_OAUTH_HOST: 'https://auth.dev.kimi.team',
+          KIMI_CODE_BASE_URL: 'https://api.dev.example.test/coding/v1',
+          KIMI_CODE_OAUTH_HOST: 'https://auth.dev.example.test',
         }),
       );
     } finally {
diff --git a/packages/node-sdk/test/auth-facade.test.ts b/packages/node-sdk/test/auth-facade.test.ts
index 09e8b71fb..0c6209090 100644
--- a/packages/node-sdk/test/auth-facade.test.ts
+++ b/packages/node-sdk/test/auth-facade.test.ts
@@ -64,8 +64,8 @@ describe('KimiHarness.auth', () => {
 
   it('resolves cached access tokens from the configured scoped OAuth ref', async () => {
     const oauthKey = resolveKimiCodeOAuthKey({
-      oauthHost: 'https://auth.dev.kimi.team',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      oauthHost: 'https://auth.dev.example.test',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
     const storageName = resolveKimiTokenStorageName({ oauthKey });
     const storage = new FileTokenStorage(join(homeDir, 'credentials'));
@@ -76,9 +76,9 @@ describe('KimiHarness.auth', () => {
       `
 [providers."managed:kimi-code"]
 type = "kimi"
-base_url = "https://coding.deva.msh.team/coding/v1"
+base_url = "https://api.dev.example.test/coding/v1"
 api_key = ""
-oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.kimi.team" }
+oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.example.test" }
 `,
     );
     const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
@@ -88,8 +88,8 @@ oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.
 
   it('reports auth status from the configured scoped OAuth ref', async () => {
     const oauthKey = resolveKimiCodeOAuthKey({
-      oauthHost: 'https://auth.dev.kimi.team',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      oauthHost: 'https://auth.dev.example.test',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
     await new FileTokenStorage(join(homeDir, 'credentials')).save(
       resolveKimiTokenStorageName({ oauthKey }),
@@ -100,9 +100,9 @@ oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.
       `
 [providers."managed:kimi-code"]
 type = "kimi"
-base_url = "https://coding.deva.msh.team/coding/v1"
+base_url = "https://api.dev.example.test/coding/v1"
 api_key = ""
-oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.kimi.team" }
+oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.example.test" }
 `,
     );
     const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
@@ -174,8 +174,8 @@ oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.
   });
 
   it('logs in against the configured scoped OAuth host and base URL when env is absent', async () => {
-    const baseUrl = 'https://coding.deva.msh.team/coding/v1';
-    const oauthHost = 'https://auth.dev.kimi.team';
+    const baseUrl = 'https://api.dev.example.test/coding/v1';
+    const oauthHost = 'https://auth.dev.example.test';
     const oauthKey = resolveKimiCodeOAuthKey({ oauthHost, baseUrl });
     const storageName = resolveKimiTokenStorageName({ oauthKey });
     const storage = new FileTokenStorage(join(homeDir, 'credentials'));
@@ -474,8 +474,8 @@ oauth = { storage = "file", key = "oauth/kimi-code" }
 
   it('removes the configured scoped OAuth token on logout without touching the production token', async () => {
     const oauthKey = resolveKimiCodeOAuthKey({
-      oauthHost: 'https://auth.dev.kimi.team',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      oauthHost: 'https://auth.dev.example.test',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
     const storageName = resolveKimiTokenStorageName({ oauthKey });
     const storage = new FileTokenStorage(join(homeDir, 'credentials'));
@@ -488,9 +488,9 @@ default_model = "kimi-code/kimi-for-coding"
 
 [providers."managed:kimi-code"]
 type = "kimi"
-base_url = "https://coding.deva.msh.team/coding/v1"
+base_url = "https://api.dev.example.test/coding/v1"
 api_key = ""
-oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.kimi.team" }
+oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.example.test" }
 
 [models."kimi-code/kimi-for-coding"]
 provider = "managed:kimi-code"
@@ -580,9 +580,9 @@ max_context_size = 262144
   });
 
   it('uses configured scoped OAuth refs and base URLs for managed usage and feedback', async () => {
-    const baseUrl = 'https://coding.deva.msh.team/coding/v1';
+    const baseUrl = 'https://api.dev.example.test/coding/v1';
     const oauthKey = resolveKimiCodeOAuthKey({
-      oauthHost: 'https://auth.dev.kimi.team',
+      oauthHost: 'https://auth.dev.example.test',
       baseUrl,
     });
     const storageName = resolveKimiTokenStorageName({ oauthKey });
@@ -597,7 +597,7 @@ max_context_size = 262144
 type = "kimi"
 base_url = "${baseUrl}"
 api_key = ""
-oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.kimi.team" }
+oauth = { storage = "file", key = "${oauthKey}", oauth_host = "https://auth.dev.example.test" }
 `,
     );
     const fetchMock = vi.fn<FetchMock>(async (input) => {
diff --git a/packages/oauth/test/managed-kimi-code.test.ts b/packages/oauth/test/managed-kimi-code.test.ts
index 6857925c6..472c6c458 100644
--- a/packages/oauth/test/managed-kimi-code.test.ts
+++ b/packages/oauth/test/managed-kimi-code.test.ts
@@ -55,16 +55,16 @@ describe('provisionManagedKimiCodeConfig', () => {
 
   it('scopes credential keys for non-default OAuth hosts and API base URLs', () => {
     const devKey = resolveKimiCodeOAuthKey({
-      oauthHost: 'https://auth.dev.kimi.team',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      oauthHost: 'https://auth.dev.example.test',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
 
     expect(devKey).not.toBe(KIMI_CODE_OAUTH_KEY);
     expect(devKey).toMatch(/^oauth\/kimi-code-env-[a-f0-9]{16}$/);
     expect(
       resolveKimiCodeOAuthKey({
-        oauthHost: 'https://auth.dev.kimi.team/',
-        baseUrl: 'https://coding.deva.msh.team/coding/v1/',
+        oauthHost: 'https://auth.dev.example.test/',
+        baseUrl: 'https://api.dev.example.test/coding/v1/',
       }),
     ).toBe(devKey);
   });
@@ -94,16 +94,16 @@ describe('provisionManagedKimiCodeConfig', () => {
     // A non-default environment yields a scoped key AND the normalized host,
     // both derived from the same input — login and runtime cannot drift apart.
     const devRef = resolveKimiCodeOAuthRef({
-      oauthHost: 'https://auth.dev.kimi.team/',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      oauthHost: 'https://auth.dev.example.test/',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
     expect(devRef).toEqual({
       storage: 'file',
       key: resolveKimiCodeOAuthKey({
-        oauthHost: 'https://auth.dev.kimi.team',
-        baseUrl: 'https://coding.deva.msh.team/coding/v1',
+        oauthHost: 'https://auth.dev.example.test',
+        baseUrl: 'https://api.dev.example.test/coding/v1',
       }),
-      oauthHost: 'https://auth.dev.kimi.team',
+      oauthHost: 'https://auth.dev.example.test',
     });
   });
 
@@ -136,14 +136,14 @@ describe('provisionManagedKimiCodeConfig', () => {
   });
 
   it('preserves a matching configured runtime OAuth ref when env is not overridden', () => {
-    const baseUrl = 'https://coding.deva.msh.team/coding/v1';
+    const baseUrl = 'https://api.dev.example.test/coding/v1';
     const configuredOAuthRef = {
       storage: 'keyring' as const,
       key: resolveKimiCodeOAuthKey({
-        oauthHost: 'https://auth.dev.kimi.team',
+        oauthHost: 'https://auth.dev.example.test',
         baseUrl,
       }),
-      oauthHost: 'https://auth.dev.kimi.team',
+      oauthHost: 'https://auth.dev.example.test',
     };
 
     expect(
@@ -277,15 +277,15 @@ describe('provisionManagedKimiCodeConfig', () => {
       providers: {},
     };
     const oauthKey = resolveKimiCodeOAuthKey({
-      oauthHost: 'https://auth.dev.kimi.team',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      oauthHost: 'https://auth.dev.example.test',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
 
     await provisionManagedKimiCodeConfig({
       accessToken: 'oauth-access-token',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
       oauthKey,
-      oauthHost: 'https://auth.dev.kimi.team',
+      oauthHost: 'https://auth.dev.example.test',
       fetchImpl: vi.fn(async () => makeModelsResponse()) as unknown as typeof fetch,
       adapter: {
         read: () => config,
@@ -295,22 +295,22 @@ describe('provisionManagedKimiCodeConfig', () => {
     });
 
     expect(config.providers[KIMI_CODE_PROVIDER_NAME]).toMatchObject({
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
       oauth: {
         storage: 'file',
         key: oauthKey,
-        oauthHost: 'https://auth.dev.kimi.team',
+        oauthHost: 'https://auth.dev.example.test',
       },
     });
     expect(config.services?.moonshotSearch?.oauth).toEqual({
       storage: 'file',
       key: oauthKey,
-      oauthHost: 'https://auth.dev.kimi.team',
+      oauthHost: 'https://auth.dev.example.test',
     });
     expect(config.services?.moonshotFetch?.oauth).toEqual({
       storage: 'file',
       key: oauthKey,
-      oauthHost: 'https://auth.dev.kimi.team',
+      oauthHost: 'https://auth.dev.example.test',
     });
   });
 
@@ -745,22 +745,22 @@ describe('provisionManagedKimiCodeConfig', () => {
 
     const promise = fetchManagedKimiCodeModels({
       accessToken: 'oauth-access-token',
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
       fetchImpl,
     });
 
     await expect(promise).rejects.toThrow(
-      "Kimi Code models endpoint https://coding.deva.msh.team/coding/v1 rejected OAuth credentials: We're unable to verify your membership benefits at this time. Please ensure your membership is active.",
+      "Kimi Code models endpoint https://api.dev.example.test/coding/v1 rejected OAuth credentials: We're unable to verify your membership benefits at this time. Please ensure your membership is active.",
     );
     await expect(
       fetchManagedKimiCodeModels({
         accessToken: 'oauth-access-token',
-        baseUrl: 'https://coding.deva.msh.team/coding/v1',
+        baseUrl: 'https://api.dev.example.test/coding/v1',
         fetchImpl,
       }),
     ).rejects.toMatchObject({
       status: 402,
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
     await expect(
       fetchManagedKimiCodeModels({
diff --git a/packages/oauth/test/toolkit.test.ts b/packages/oauth/test/toolkit.test.ts
index a50a07e0c..04abc3456 100644
--- a/packages/oauth/test/toolkit.test.ts
+++ b/packages/oauth/test/toolkit.test.ts
@@ -146,10 +146,10 @@ describe('KimiOAuthToolkit', () => {
 
   it('refreshes configured bearer token refs against their OAuth host', async () => {
     const storage = new MemoryTokenStorage();
-    const oauthHost = 'https://auth.dev.kimi.team';
+    const oauthHost = 'https://auth.dev.example.test';
     const oauthKey = resolveKimiCodeOAuthKey({
       oauthHost,
-      baseUrl: 'https://coding.deva.msh.team/coding/v1',
+      baseUrl: 'https://api.dev.example.test/coding/v1',
     });
     storage.tokens.set(resolveKimiTokenStorageName({ oauthKey }), {
       ...token('expired-dev-access'),
@@ -419,8 +419,8 @@ describe('KimiOAuthToolkit', () => {
     const storage = new MemoryTokenStorage();
     storage.tokens.set('kimi-code', token('prod-access'));
     const config: ManagedKimiConfigShape = { providers: {} };
-    const devBaseUrl = 'https://coding.deva.msh.team/coding/v1';
-    const devOauthHost = 'https://auth.dev.kimi.team';
+    const devBaseUrl = 'https://api.dev.example.test/coding/v1';
+    const devOauthHost = 'https://auth.dev.example.test';
     const devOauthKey = resolveKimiCodeOAuthKey({
       oauthHost: devOauthHost,
       baseUrl: devBaseUrl,

From 8d251f8ab44ead65f6c1bb264980ee7d075142ad Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Fri, 12 Jun 2026 15:56:13 +0800
Subject: [PATCH 04/17] feat(config): tolerate invalid config.toml sections
 instead of failing startup (#689)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(config): tolerate invalid config.toml sections instead of failing startup

Schema errors now drop only the offending sections (single entries for
providers/models) with a warning, so a typo no longer prevents startup or
drops the login state. TOML syntax errors still fail fast with the parse
location. Mid-run reloads keep the last good config when the file breaks.

Warnings surface via the new getConfigDiagnostics API: as a startup notice
in the TUI, on stderr in print mode, and in the status bar after /new.

Write paths stay strict so a broken file is never silently rewritten, and
now fail with a short actionable message instead of raw validation JSON;
the /provider TUI flow and the kimi provider CLI report these errors
instead of crashing on an unhandled rejection.

* fix(config): keep entry-keyed sections when one entry has multiple issues

A providers/models entry with several validation issues was deleted by the
first issue, and the remaining issues from the same safeParse pass then
escalated to deleting the entire section — one badly-typed custom provider
could drop every provider, including the managed OAuth login. Issues on
entry-keyed sections now only ever target the entry itself; once it is
gone, later issues are no-ops.
---
 .changeset/tolerate-invalid-config.md         |   7 +
 apps/kimi-code/src/cli/run-prompt.ts          |   3 +
 apps/kimi-code/src/cli/run-shell.ts           |   4 +
 apps/kimi-code/src/cli/sub/provider.ts        |  43 ++--
 apps/kimi-code/src/tui/commands/provider.ts   |  24 +-
 apps/kimi-code/src/tui/kimi-tui.ts            |  13 ++
 apps/kimi-code/test/cli/goal-prompt.test.ts   |   1 +
 apps/kimi-code/test/cli/provider.test.ts      |  24 ++
 apps/kimi-code/test/cli/run-prompt.test.ts    |   2 +
 apps/kimi-code/test/cli/run-shell.test.ts     |  34 +++
 packages/agent-core/src/config/toml.ts        | 181 ++++++++++++++-
 packages/agent-core/src/rpc/core-api.ts       |   6 +
 packages/agent-core/src/rpc/core-impl.ts      |  59 ++++-
 .../agent-core/test/config/configs.test.ts    | 209 ++++++++++++++++++
 .../agent-core/test/rpc/config-rpc.test.ts    | 110 +++++++++
 packages/node-sdk/src/auth.ts                 |  18 +-
 packages/node-sdk/src/kimi-harness.ts         |   6 +
 packages/node-sdk/src/rpc.ts                  |   6 +
 packages/node-sdk/src/types.ts                |   1 +
 packages/node-sdk/test/auth-facade.test.ts    |  36 ++-
 20 files changed, 749 insertions(+), 38 deletions(-)
 create mode 100644 .changeset/tolerate-invalid-config.md
 create mode 100644 packages/agent-core/test/rpc/config-rpc.test.ts

diff --git a/.changeset/tolerate-invalid-config.md b/.changeset/tolerate-invalid-config.md
new file mode 100644
index 000000000..0cae217e9
--- /dev/null
+++ b/.changeset/tolerate-invalid-config.md
@@ -0,0 +1,7 @@
+---
+"@moonshot-ai/agent-core": patch
+"@moonshot-ai/kimi-code-sdk": patch
+"@moonshot-ai/kimi-code": patch
+---
+
+Drop invalid config.toml sections with a warning instead of failing to start.
diff --git a/apps/kimi-code/src/cli/run-prompt.ts b/apps/kimi-code/src/cli/run-prompt.ts
index d5253531e..f7cef067d 100644
--- a/apps/kimi-code/src/cli/run-prompt.ts
+++ b/apps/kimi-code/src/cli/run-prompt.ts
@@ -112,6 +112,9 @@ export async function runPrompt(
   try {
     await harness.ensureConfigFile();
     const config = await harness.getConfig();
+    for (const warning of (await harness.getConfigDiagnostics()).warnings) {
+      stderr.write(`Warning: ${warning}\n`);
+    }
     const { session, resumed, restorePermission, telemetryModel, goalModel } =
       await resolvePromptSession(
         harness,
diff --git a/apps/kimi-code/src/cli/run-shell.ts b/apps/kimi-code/src/cli/run-shell.ts
index b3443ee99..e5bdfef24 100644
--- a/apps/kimi-code/src/cli/run-shell.ts
+++ b/apps/kimi-code/src/cli/run-shell.ts
@@ -23,6 +23,7 @@ import { loadTuiConfig, TuiConfigParseError } from '#/tui/config';
 import { CHROME_GUTTER } from '#/tui/constant/rendering';
 import { KimiTUI } from '#/tui/index';
 import { currentTheme, getColorPalette } from '#/tui/theme';
+import { combineStartupNotice } from '#/tui/utils/startup';
 
 import type { CLIOptions } from './options';
 import { createCliTelemetryBootstrap, initializeCliTelemetry } from './telemetry';
@@ -91,6 +92,9 @@ export async function runShell(
     return;
   }
   const config = await harness.getConfig();
+  for (const warning of (await harness.getConfigDiagnostics()).warnings) {
+    configWarning = combineStartupNotice(configWarning, warning);
+  }
   const configMs = Date.now() - configStartedAt;
   const tui = new KimiTUI(harness, {
     cliOptions: opts,
diff --git a/apps/kimi-code/src/cli/sub/provider.ts b/apps/kimi-code/src/cli/sub/provider.ts
index 38cb75521..b712891b2 100644
--- a/apps/kimi-code/src/cli/sub/provider.ts
+++ b/apps/kimi-code/src/cli/sub/provider.ts
@@ -410,13 +410,26 @@ export function registerProviderCommand(parent: Command, deps?: Partial<Provider
     .command('provider')
     .description('Manage LLM providers non-interactively.');
 
+  // Last-resort boundary: handlers report expected failures themselves, but
+  // anything that escapes (e.g. a config write rejected because config.toml
+  // is invalid) must end as a one-line error + exit 1, not an unhandled
+  // rejection dumping a stack trace.
+  const runAction = async (resolved: ProviderDeps, run: () => Promise<void>): Promise<void> => {
+    try {
+      await run();
+    } catch (error) {
+      resolved.stderr.write(`${errorMessage(error)}\n`);
+      resolved.exit(1);
+    }
+  };
+
   provider
     .command('add <url>')
     .description('Import every provider listed in a custom registry (api.json).')
     .option('--api-key <key>', 'Registry API key. Falls back to KIMI_REGISTRY_API_KEY.')
     .action(async (url: string, options: { apiKey?: string }) => {
       const resolved = resolveDeps(deps);
-      await handleProviderAdd(resolved, url, { apiKey: options.apiKey });
+      await runAction(resolved, () => handleProviderAdd(resolved, url, { apiKey: options.apiKey }));
     });
 
   provider
@@ -424,7 +437,7 @@ export function registerProviderCommand(parent: Command, deps?: Partial<Provider
     .description('Remove a provider and every model alias that referenced it.')
     .action(async (providerId: string) => {
       const resolved = resolveDeps(deps);
-      await handleProviderRemove(resolved, providerId);
+      await runAction(resolved, () => handleProviderRemove(resolved, providerId));
     });
 
   provider
@@ -433,7 +446,7 @@ export function registerProviderCommand(parent: Command, deps?: Partial<Provider
     .option('--json', 'Emit the raw providers/models config as JSON.', false)
     .action(async (options: { json?: boolean }) => {
       const resolved = resolveDeps(deps);
-      await handleProviderList(resolved, { json: options.json === true });
+      await runAction(resolved, () => handleProviderList(resolved, { json: options.json === true }));
     });
 
   const catalog = provider
@@ -452,11 +465,13 @@ export function registerProviderCommand(parent: Command, deps?: Partial<Provider
         options: { filter?: string; url?: string; json?: boolean },
       ) => {
         const resolved = resolveDeps(deps);
-        await handleCatalogList(resolved, providerId, {
-          json: options.json === true,
-          ...(options.filter === undefined ? {} : { filter: options.filter }),
-          ...(options.url === undefined ? {} : { url: options.url }),
-        });
+        await runAction(resolved, () =>
+          handleCatalogList(resolved, providerId, {
+            json: options.json === true,
+            ...(options.filter === undefined ? {} : { filter: options.filter }),
+            ...(options.url === undefined ? {} : { url: options.url }),
+          }),
+        );
       },
     );
 
@@ -472,11 +487,13 @@ export function registerProviderCommand(parent: Command, deps?: Partial<Provider
         options: { apiKey?: string; defaultModel?: string; url?: string },
       ) => {
         const resolved = resolveDeps(deps);
-        await handleCatalogAdd(resolved, providerId, {
-          ...(options.apiKey === undefined ? {} : { apiKey: options.apiKey }),
-          ...(options.defaultModel === undefined ? {} : { defaultModel: options.defaultModel }),
-          ...(options.url === undefined ? {} : { url: options.url }),
-        });
+        await runAction(resolved, () =>
+          handleCatalogAdd(resolved, providerId, {
+            ...(options.apiKey === undefined ? {} : { apiKey: options.apiKey }),
+            ...(options.defaultModel === undefined ? {} : { defaultModel: options.defaultModel }),
+            ...(options.url === undefined ? {} : { url: options.url }),
+          }),
+        );
       },
     );
 }
diff --git a/apps/kimi-code/src/tui/commands/provider.ts b/apps/kimi-code/src/tui/commands/provider.ts
index 55f9817fa..242252bfb 100644
--- a/apps/kimi-code/src/tui/commands/provider.ts
+++ b/apps/kimi-code/src/tui/commands/provider.ts
@@ -50,10 +50,14 @@ function buildProviderManagerOptions(host: SlashCommandHost): ProviderManagerOpt
     providers: host.state.appState.availableProviders,
     activeProviderId,
     onAdd: () => {
-      void handleProviderAdd(host);
+      void handleProviderAdd(host).catch((error: unknown) => {
+        host.showError(`Add provider failed: ${formatErrorMessage(error)}`);
+      });
     },
     onDeleteSource: (providerIds) => {
-      void handleProviderManagerDeleteSource(host, providerIds);
+      void handleProviderManagerDeleteSource(host, providerIds).catch((error: unknown) => {
+        host.showError(`Remove provider failed: ${formatErrorMessage(error)}`);
+      });
     },
     onClose: () => {
       host.restoreEditor();
@@ -233,7 +237,9 @@ async function handleCatalogProviderAdd(host: SlashCommandHost): Promise<void> {
     initialTabId: providerId,
     onSelect: ({ alias, thinking }) => {
       host.restoreEditor();
-      void setDefaultModel(host, alias, thinking);
+      void setDefaultModel(host, alias, thinking).catch((error: unknown) => {
+        host.showError(`Set default model failed: ${formatErrorMessage(error)}`);
+      });
     },
     onCancel: () => {
       host.restoreEditor();
@@ -269,8 +275,8 @@ async function handleCustomRegistryAddViaDialog(host: SlashCommandHost): Promise
   let entries: Awaited<ReturnType<typeof fetchCustomRegistry>>;
   try {
     entries = await fetchCustomRegistry(source);
-  } catch (err) {
-    host.showError(`Failed to import registry: ${formatErrorMessage(err)}`);
+  } catch (error) {
+    host.showError(`Failed to import registry: ${formatErrorMessage(error)}`);
     return false;
   }
 
@@ -287,8 +293,8 @@ async function handleCustomRegistryAddViaDialog(host: SlashCommandHost): Promise
       models: config.models,
     });
     await host.authFlow.refreshConfigAfterLogin();
-  } catch (err) {
-    host.showError(`Failed to apply registry: ${formatErrorMessage(err)}`);
+  } catch (error) {
+    host.showError(`Failed to apply registry: ${formatErrorMessage(error)}`);
     return false;
   }
 
@@ -321,7 +327,9 @@ async function handleCustomRegistryAddViaDialog(host: SlashCommandHost): Promise
     initialTabId: firstNewProvider,
     onSelect: ({ alias, thinking }) => {
       host.restoreEditor();
-      void setDefaultModel(host, alias, thinking);
+      void setDefaultModel(host, alias, thinking).catch((error: unknown) => {
+        host.showError(`Set default model failed: ${formatErrorMessage(error)}`);
+      });
     },
     onCancel: () => {
       host.restoreEditor();
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 759a92667..569e68070 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1312,6 +1312,19 @@ export class KimiTUI {
     this.sessionEventHandler.startSubscription();
     this.clearTranscriptAndRedraw();
     this.showStatus(`Started a new session (${session.id}).`);
+    void this.showConfigWarningsIfAny();
+  }
+
+  /** Surface config.toml load warnings (degraded or kept-previous config) in the status bar. */
+  private async showConfigWarningsIfAny(): Promise<void> {
+    try {
+      const { warnings } = await this.harness.getConfigDiagnostics();
+      for (const warning of warnings) {
+        this.showStatus(warning, 'warning');
+      }
+    } catch {
+      /* diagnostics are best-effort */
+    }
   }
 
   // =========================================================================
diff --git a/apps/kimi-code/test/cli/goal-prompt.test.ts b/apps/kimi-code/test/cli/goal-prompt.test.ts
index e8a9955d7..04780bd26 100644
--- a/apps/kimi-code/test/cli/goal-prompt.test.ts
+++ b/apps/kimi-code/test/cli/goal-prompt.test.ts
@@ -116,6 +116,7 @@ vi.mock('@moonshot-ai/kimi-code-sdk', async (importOriginal) => {
       auth: { getCachedAccessToken: vi.fn() },
       ensureConfigFile: vi.fn(),
       getConfig: vi.fn(async () => ({ providers: {}, defaultModel: 'k2', telemetry: true })),
+      getConfigDiagnostics: vi.fn(async () => ({ warnings: [] as readonly string[] })),
       getExperimentalFeatures: vi.fn(async () => mocks.experimentalFeatures),
       createSession: vi.fn(async () => mocks.session),
       resumeSession: vi.fn(async () => mocks.session),
diff --git a/apps/kimi-code/test/cli/provider.test.ts b/apps/kimi-code/test/cli/provider.test.ts
index d1f6a05e6..56768a78c 100644
--- a/apps/kimi-code/test/cli/provider.test.ts
+++ b/apps/kimi-code/test/cli/provider.test.ts
@@ -546,6 +546,30 @@ describe('registerProviderCommand', () => {
     expect(Object.keys(current().providers).toSorted()).toEqual(['kohub', 'kohub-responses']);
     expect(stdout.join('')).toContain('Imported 2 providers');
   });
+
+  it('reports write failures on stderr and exits 1 instead of crashing', async () => {
+    const { harness } = makeHarness({
+      providers: { kimi: { type: 'kimi' } },
+    } as unknown as KimiConfig);
+    // Simulate the strict write path rejecting because config.toml is invalid.
+    harness.removeProvider = async () => {
+      throw new Error(
+        'Cannot change settings while config.toml is invalid — fix it first (run `kimi doctor` for details).',
+      );
+    };
+    const { deps, stderr, exitCodes } = makeDeps(harness);
+
+    const program = new Command('kimi');
+    registerProviderCommand(program, deps);
+
+    await tryRun(() =>
+      program.parseAsync(['node', 'kimi', 'provider', 'remove', 'kimi'], { from: 'node' }),
+    );
+
+    expect(exitCodes).toEqual([1]);
+    expect(stderr.join('')).toContain('Cannot change settings');
+    expect(stderr.join('')).not.toContain('    at '); // no stack trace dump
+  });
 });
 
 describe('kimi provider catalog list', () => {
diff --git a/apps/kimi-code/test/cli/run-prompt.test.ts b/apps/kimi-code/test/cli/run-prompt.test.ts
index 9913dd926..a3620aa35 100644
--- a/apps/kimi-code/test/cli/run-prompt.test.ts
+++ b/apps/kimi-code/test/cli/run-prompt.test.ts
@@ -54,6 +54,7 @@ const mocks = vi.hoisted(() => {
         telemetry: true,
       }),
     ),
+    harnessGetConfigDiagnostics: vi.fn(async () => ({ warnings: [] as readonly string[] })),
     harnessGetExperimentalFeatures: vi.fn(async () => []),
     harnessCreateSession: vi.fn(async () => session),
     harnessResumeSession: vi.fn(async () => session),
@@ -91,6 +92,7 @@ vi.mock('@moonshot-ai/kimi-code-sdk', async (importOriginal) => {
         auth: { getCachedAccessToken: mocks.harnessGetCachedAccessToken },
         ensureConfigFile: mocks.harnessEnsureConfigFile,
         getConfig: mocks.harnessGetConfig,
+        getConfigDiagnostics: mocks.harnessGetConfigDiagnostics,
         getExperimentalFeatures: mocks.harnessGetExperimentalFeatures,
         createSession: mocks.harnessCreateSession,
         resumeSession: mocks.harnessResumeSession,
diff --git a/apps/kimi-code/test/cli/run-shell.test.ts b/apps/kimi-code/test/cli/run-shell.test.ts
index b61641dd0..bab4fb152 100644
--- a/apps/kimi-code/test/cli/run-shell.test.ts
+++ b/apps/kimi-code/test/cli/run-shell.test.ts
@@ -37,6 +37,7 @@ const mocks = vi.hoisted(() => {
       defaultModel: 'k2',
       telemetry: true,
     })),
+    harnessGetConfigDiagnostics: vi.fn(async () => ({ warnings: [] as readonly string[] })),
     harnessGetCachedAccessToken: vi.fn(),
     harnessClose: vi.fn(),
     detectPendingMigration: vi.fn<() => Promise<unknown>>(async () => null),
@@ -82,6 +83,7 @@ vi.mock('@moonshot-ai/kimi-code-sdk', async (importOriginal) => {
         },
         ensureConfigFile: mocks.harnessEnsureConfigFile,
         getConfig: mocks.harnessGetConfig,
+        getConfigDiagnostics: mocks.harnessGetConfigDiagnostics,
         close: mocks.harnessClose,
         track: mocks.harnessTrack,
       };
@@ -483,6 +485,38 @@ describe('runShell', () => {
     });
   });
 
+  it('forwards config.toml diagnostics as startup notices', async () => {
+    mocks.loadTuiConfig.mockResolvedValue({
+      theme: 'dark',
+      editorCommand: null,
+      notifications: { enabled: true, condition: 'unfocused' },
+    });
+    mocks.harnessGetConfigDiagnostics.mockResolvedValue({
+      warnings: ['Ignored invalid config in config.toml: loop_control.'],
+    });
+    mocks.tuiStart.mockResolvedValue(undefined);
+
+    await runShell(
+      {
+        session: '',
+        continue: false,
+        yolo: false,
+        auto: false,
+        plan: false,
+        model: undefined,
+        outputFormat: undefined,
+        prompt: undefined,
+        skillsDirs: [],
+      },
+      '1.2.3-test',
+    );
+
+    const [, , startupInput] = mocks.kimiTuiConstructor.mock.calls[0]!;
+    expect(startupInput).toMatchObject({
+      startupNotice: 'Ignored invalid config in config.toml: loop_control.',
+    });
+  });
+
   it('closes the harness when TUI startup fails', async () => {
     mocks.loadTuiConfig.mockResolvedValue({
       theme: 'dark',
diff --git a/packages/agent-core/src/config/toml.ts b/packages/agent-core/src/config/toml.ts
index 56452e41a..172e97cfc 100644
--- a/packages/agent-core/src/config/toml.ts
+++ b/packages/agent-core/src/config/toml.ts
@@ -23,7 +23,7 @@ import {
   validateConfig,
 } from '#/config/schema';
 import { atomicWrite } from '#/utils/fs';
-import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
+import { parse as parseToml, stringify as stringifyToml, TomlError } from 'smol-toml';
 
 /* ------------------------------------------------------------------ */
 /*  Key helpers – reuse generic snake / camel conversion instead of    */
@@ -70,6 +70,27 @@ export function readConfigFile(filePath: string): KimiConfig {
   return parseConfigString(text, filePath);
 }
 
+/**
+ * Strict read for write paths (read-merge-write must never use a salvaged
+ * config as its base, or the rewrite would drop the user's broken-but-fixable
+ * sections). Re-throws validation failures with a short actionable message —
+ * UIs surface it directly — instead of the raw validation details.
+ */
+export function readConfigFileForUpdate(filePath: string): KimiConfig {
+  try {
+    return readConfigFile(filePath);
+  } catch (error) {
+    if (error instanceof KimiError && error.code === ErrorCodes.CONFIG_INVALID) {
+      throw new KimiError(
+        ErrorCodes.CONFIG_INVALID,
+        `Cannot change settings while ${filePath} is invalid — fix it first (run \`kimi doctor\` for details).`,
+        { cause: error },
+      );
+    }
+    throw error;
+  }
+}
+
 /**
  * Load the config for runtime consumption: the on-disk config plus any model
  * synthesized from `KIMI_MODEL_*` environment variables. Use this everywhere a
@@ -83,6 +104,164 @@ export function loadRuntimeConfig(
   return applyEnvModelConfig(readConfigFile(filePath), env);
 }
 
+export interface RuntimeConfigLoadResult {
+  readonly config: KimiConfig;
+  /** Problems in config.toml itself; non-empty means parts (or all) of the file were ignored. */
+  readonly fileWarnings: readonly string[];
+  /** Problems applying KIMI_MODEL_* env overrides; the overlay was skipped. */
+  readonly envWarnings: readonly string[];
+  /**
+   * Set when the file is entirely unusable (unreadable, TOML syntax error, or
+   * nothing salvageable) and `config` is pure defaults. Startup fails fast on
+   * this — defaults-only means the user looks logged out, which is worse than
+   * an actionable parse error. Mid-run reloads ignore it and keep the last
+   * good config instead.
+   */
+  readonly fileError?: KimiError;
+}
+
+/**
+ * Lenient variant of `loadRuntimeConfig` that never throws: schema errors
+ * drop only the offending sections (whole entry for `providers`/`models`,
+ * whole top-level section otherwise) and a bad KIMI_MODEL_* env overlay is
+ * skipped, each reported as a warning. A file that cannot be used at all
+ * additionally sets `fileError` so startup can fail fast while mid-run
+ * reloads degrade. Runtime read paths use this; write paths must keep using
+ * the strict readers so a broken file is never silently rewritten.
+ */
+export function loadRuntimeConfigSafe(
+  filePath: string,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): RuntimeConfigLoadResult {
+  const fileWarnings: string[] = [];
+  let fileError: KimiError | undefined;
+  let config = getDefaultConfig();
+
+  let text: string | undefined;
+  try {
+    text = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : undefined;
+  } catch (error) {
+    fileError = new KimiError(
+      ErrorCodes.CONFIG_INVALID,
+      `Failed to read ${filePath}: ${describeUnknownError(error)}`,
+      { cause: error },
+    );
+    fileWarnings.push(`Failed to read ${filePath}: ${describeUnknownError(error)}.`);
+  }
+
+  if (text !== undefined && text.trim().length > 0) {
+    let data: Record<string, unknown> | undefined;
+    try {
+      data = parseToml(text) as Record<string, unknown>;
+    } catch (error) {
+      // Same message as the strict parser, code frame included, so failing
+      // startup points straight at the offending line.
+      fileError = new KimiError(
+        ErrorCodes.CONFIG_INVALID,
+        `Invalid TOML in ${filePath}: ${describeUnknownError(error)}`,
+        { cause: error },
+      );
+      fileWarnings.push(`Invalid TOML in ${filePath}: ${describeTomlSyntaxError(error)}.`);
+    }
+    if (data !== undefined) {
+      const raw = cloneRecord(data);
+      const transformed = transformTomlData(data);
+      transformed['raw'] = raw;
+      const salvaged = salvageConfigData(transformed);
+      if (salvaged.config === undefined) {
+        fileError = new KimiError(
+          ErrorCodes.CONFIG_INVALID,
+          `Invalid configuration in ${filePath}: ${formatConfigValidationError(salvaged.error)}`,
+          { cause: salvaged.error },
+        );
+        fileWarnings.push(
+          `Invalid configuration in ${filePath}: ${formatConfigValidationError(salvaged.error)}.`,
+        );
+      } else {
+        config = salvaged.config;
+        if (salvaged.dropped.length > 0) {
+          fileWarnings.push(
+            `Ignored invalid config in ${filePath}: ${salvaged.dropped.join(', ')}. Run \`kimi doctor\` for details.`,
+          );
+        }
+      }
+    }
+  }
+
+  const envWarnings: string[] = [];
+  try {
+    config = applyEnvModelConfig(config, env);
+  } catch (error) {
+    envWarnings.push(
+      `Ignoring KIMI_MODEL_* environment overrides: ${describeUnknownError(error)}`,
+    );
+  }
+
+  return { config, fileWarnings, envWarnings, fileError };
+}
+
+/** Sections keyed by user-chosen names where single entries can be dropped. */
+const ENTRY_KEYED_SECTIONS = new Set(['providers', 'models']);
+
+interface SalvageResult {
+  readonly config: KimiConfig | undefined;
+  readonly dropped: readonly string[];
+  readonly error?: unknown;
+}
+
+function salvageConfigData(transformed: Record<string, unknown>): SalvageResult {
+  const dropped: string[] = [];
+  for (;;) {
+    const result = KimiConfigSchema.safeParse(transformed);
+    if (result.success) {
+      return { config: result.data, dropped };
+    }
+    let deletedAny = false;
+    for (const issue of result.error.issues) {
+      const [section, entry] = issue.path;
+      if (typeof section !== 'string' || !(section in transformed)) continue;
+      const sectionValue = transformed[section];
+      if (
+        ENTRY_KEYED_SECTIONS.has(section) &&
+        typeof entry === 'string' &&
+        isPlainObject(sectionValue)
+      ) {
+        // Issues on entry-keyed sections only ever drop that entry. An entry
+        // with several issues is deleted by the first one; later issues are
+        // no-ops and must not escalate to deleting the whole section.
+        if (entry in sectionValue) {
+          delete sectionValue[entry];
+          dropped.push(`${camelToSnake(section)}.${entry}`);
+          deletedAny = true;
+        }
+        continue;
+      }
+      delete transformed[section];
+      dropped.push(camelToSnake(section));
+      deletedAny = true;
+    }
+    if (!deletedAny) {
+      return { config: undefined, dropped, error: result.error };
+    }
+  }
+}
+
+function describeUnknownError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * One-line summary of a smol-toml parse error: first message line plus the
+ * line/column location, without the multi-line code-frame block.
+ */
+function describeTomlSyntaxError(error: unknown): string {
+  const firstLine = describeUnknownError(error).split('\n', 1)[0] ?? '';
+  if (error instanceof TomlError) {
+    return `${firstLine} (line ${error.line}, column ${error.column})`;
+  }
+  return firstLine;
+}
+
 export function parseConfigString(tomlText: string, filePath = 'config.toml'): KimiConfig {
   if (tomlText.trim().length === 0) {
     return getDefaultConfig();
diff --git a/packages/agent-core/src/rpc/core-api.ts b/packages/agent-core/src/rpc/core-api.ts
index af2e00a4d..b080802ee 100644
--- a/packages/agent-core/src/rpc/core-api.ts
+++ b/packages/agent-core/src/rpc/core-api.ts
@@ -294,6 +294,11 @@ export interface GetKimiConfigPayload {
   readonly reload?: boolean;
 }
 
+export interface ConfigDiagnostics {
+  /** Warnings from the most recent config.toml load attempt; empty when the config is fully valid. */
+  readonly warnings: readonly string[];
+}
+
 export type SetKimiConfigPayload = KimiConfigPatch;
 
 export interface RemoveKimiProviderPayload {
@@ -358,6 +363,7 @@ export interface CoreAPI extends SessionAPIWithId {
   getCoreInfo: (payload: EmptyPayload) => CoreInfo;
   getExperimentalFeatures: (payload: EmptyPayload) => readonly ExperimentalFeatureState[];
   getKimiConfig: (payload: GetKimiConfigPayload) => KimiConfig;
+  getConfigDiagnostics: (payload: EmptyPayload) => ConfigDiagnostics;
   setKimiConfig: (payload: SetKimiConfigPayload) => KimiConfig;
   removeKimiProvider: (payload: RemoveKimiProviderPayload) => KimiConfig;
   createSession: (payload: CreateSessionPayload) => SessionSummary;
diff --git a/packages/agent-core/src/rpc/core-impl.ts b/packages/agent-core/src/rpc/core-impl.ts
index c8edc631d..204715da6 100644
--- a/packages/agent-core/src/rpc/core-impl.ts
+++ b/packages/agent-core/src/rpc/core-impl.ts
@@ -13,9 +13,9 @@ import { resolveThinkingLevel } from '../agent/config/thinking';
 import { Agent } from '../agent';
 import {
   ensureKimiHome,
-  loadRuntimeConfig,
+  loadRuntimeConfigSafe,
   mergeConfigPatch,
-  readConfigFile,
+  readConfigFileForUpdate,
   resolveConfigPath,
   resolveKimiHome,
   writeConfigFile,
@@ -46,6 +46,7 @@ import type {
   CancelPayload,
   CancelPlanPayload,
   CloseSessionPayload,
+  ConfigDiagnostics,
   CoreAPI,
   CoreInfo,
   CreateGoalPayload,
@@ -129,6 +130,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
   private kaos: Promise<Kaos> | undefined;
   private runtime: ToolServices | undefined;
   private config: KimiConfig;
+  private configWarnings: readonly string[] = [];
   private readonly runtimeOverride: ToolServices | undefined;
   private readonly userHomeDir: string;
   private readonly kimiRequestHeaders: Record<string, string> | undefined;
@@ -159,7 +161,19 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     this.telemetry = options.telemetry ?? noopTelemetryClient;
     this.appVersion = options.appVersion;
     ensureKimiHome(this.homeDir);
-    this.config = loadRuntimeConfig(this.configPath);
+    // Schema errors degrade (invalid sections are dropped with warnings) so a
+    // typo cannot prevent startup, but a file that cannot be used at all —
+    // TOML syntax error, unreadable — fails fast: defaults-only would start
+    // the app looking logged out, which is worse than the parse error.
+    const loaded = loadRuntimeConfigSafe(this.configPath);
+    if (loaded.fileError !== undefined) {
+      throw loaded.fileError;
+    }
+    this.config = loaded.config;
+    this.configWarnings = [...loaded.fileWarnings, ...loaded.envWarnings];
+    if (this.configWarnings.length > 0) {
+      log.warn('config load degraded', { warnings: this.configWarnings });
+    }
     this.experimentalFlags = new FlagResolver(
       process.env,
       FLAG_DEFINITIONS,
@@ -447,19 +461,23 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
 
   async getKimiConfig(input?: GetKimiConfigPayload): Promise<KimiConfig> {
     if (input?.reload) {
-      this.setRuntimeConfig(loadRuntimeConfig(this.configPath));
+      this.reloadRuntimeConfig();
     }
     return this.config;
   }
 
+  async getConfigDiagnostics(_input?: EmptyPayload): Promise<ConfigDiagnostics> {
+    return { warnings: this.configWarnings };
+  }
+
   async setKimiConfig(input: SetKimiConfigPayload): Promise<KimiConfig> {
-    const config = mergeConfigPatch(readConfigFile(this.configPath), input);
+    const config = mergeConfigPatch(this.readConfigForWrite(), input);
     await writeConfigFile(this.configPath, config);
-    return this.setRuntimeConfig(loadRuntimeConfig(this.configPath));
+    return this.reloadRuntimeConfig();
   }
 
   async removeKimiProvider(input: RemoveKimiProviderPayload): Promise<KimiConfig> {
-    const config = readConfigFile(this.configPath);
+    const config = this.readConfigForWrite();
     delete config.providers[input.providerId];
 
     let removedDefault = false;
@@ -486,7 +504,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     }
 
     await writeConfigFile(this.configPath, config);
-    return this.setRuntimeConfig(loadRuntimeConfig(this.configPath));
+    return this.reloadRuntimeConfig();
   }
 
   prompt({ sessionId, ...payload }: SessionAgentPayload<PromptPayload>) {
@@ -860,7 +878,30 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
   }
 
   private reloadProviderManager(): KimiConfig {
-    return this.setRuntimeConfig(loadRuntimeConfig(this.configPath));
+    return this.reloadRuntimeConfig();
+  }
+
+  private readConfigForWrite(): KimiConfig {
+    return readConfigFileForUpdate(this.configPath);
+  }
+
+  private reloadRuntimeConfig(): KimiConfig {
+    const loaded = loadRuntimeConfigSafe(this.configPath);
+    if (loaded.fileWarnings.length > 0) {
+      // Keep the last good config: adopting a salvaged config mid-run could
+      // silently drop providers or models a live session depends on.
+      this.configWarnings = [
+        ...loaded.fileWarnings,
+        ...loaded.envWarnings,
+        'config.toml has errors; keeping the previously loaded configuration.',
+      ];
+      log.warn('config reload degraded; keeping previous config', {
+        warnings: loaded.fileWarnings,
+      });
+      return this.config;
+    }
+    this.configWarnings = loaded.envWarnings;
+    return this.setRuntimeConfig(loaded.config);
   }
 
   private setRuntimeConfig(config: KimiConfig): KimiConfig {
diff --git a/packages/agent-core/test/config/configs.test.ts b/packages/agent-core/test/config/configs.test.ts
index 3eb85fe98..091eee384 100644
--- a/packages/agent-core/test/config/configs.test.ts
+++ b/packages/agent-core/test/config/configs.test.ts
@@ -9,10 +9,13 @@ import { ErrorCodes, KimiError } from '../../src/errors';
 import {
   KimiConfigSchema,
   ensureConfigFile,
+  loadRuntimeConfig,
+  loadRuntimeConfigSafe,
   mergeConfigPatch,
   parseConfigString,
   parseBooleanEnv,
   readConfigFile,
+  readConfigFileForUpdate,
   resolveConfigPath,
   resolveConfigValue,
   resolveKimiHome,
@@ -661,3 +664,209 @@ describe('config value env override helpers', () => {
     ).toBe(false);
   });
 });
+
+describe('loadRuntimeConfigSafe', () => {
+  const VALID_TOML = `
+default_model = "k2"
+
+[providers.kimi]
+type = "kimi"
+api_key = "sk-good"
+
+[models.k2]
+provider = "kimi"
+model = "kimi-for-coding"
+max_context_size = 128000
+`;
+
+  async function writeTempConfig(text: string): Promise<string> {
+    const configPath = join(makeTempDir(), 'config.toml');
+    await writeFile(configPath, text, 'utf-8');
+    return configPath;
+  }
+
+  it('loads a valid file with no warnings, matching the strict loader', async () => {
+    const configPath = await writeTempConfig(VALID_TOML);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.fileWarnings).toEqual([]);
+    expect(result.envWarnings).toEqual([]);
+    expect(result.config).toEqual(loadRuntimeConfig(configPath, {}));
+  });
+
+  it('returns defaults with no warnings when the file is missing', () => {
+    const configPath = join(makeTempDir(), 'config.toml');
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.fileWarnings).toEqual([]);
+    expect(result.envWarnings).toEqual([]);
+    expect(result.config.providers).toEqual({});
+  });
+
+  it('reports a fileError and defaults on invalid TOML syntax', async () => {
+    const configPath = await writeTempConfig('[[[');
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.providers).toEqual({});
+    // The whole file is unusable: callers decide to fail startup (fileError)
+    // or keep the last good config mid-run (fileWarnings).
+    expect(result.fileError).toBeInstanceOf(KimiError);
+    expect(result.fileError?.code).toBe(ErrorCodes.CONFIG_INVALID);
+    expect(result.fileError?.message).toContain('Invalid TOML');
+    expect(result.fileError?.message).toContain(configPath);
+    expect(result.fileWarnings).toHaveLength(1);
+    const warning = result.fileWarnings[0]!;
+    expect(warning).toContain('Invalid TOML');
+    // Single-line summary with the error location, not the multi-line code frame.
+    expect(warning).not.toContain('\n');
+    expect(warning).toContain('line 1');
+  });
+
+  it('does not set fileError when only sections are dropped', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[loop_control]
+max_steps_per_turn = "nope"
+`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.fileError).toBeUndefined();
+    expect(result.fileWarnings).toHaveLength(1);
+  });
+
+  it('drops only an invalid section on schema errors and keeps the rest', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[loop_control]
+max_steps_per_turn = "not-a-number"
+`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.loopControl).toBeUndefined();
+    expect(result.config.providers['kimi']).toMatchObject({ type: 'kimi', apiKey: 'sk-good' });
+    expect(result.config.models?.['k2']).toMatchObject({ maxContextSize: 128000 });
+    expect(result.config.defaultModel).toBe('k2');
+    expect(result.fileWarnings).toHaveLength(1);
+    expect(result.fileWarnings[0]).toContain('loop_control');
+    // The original file content stays visible in raw so nothing is lost.
+    expect(result.config.raw?.['loop_control']).toEqual({ max_steps_per_turn: 'not-a-number' });
+  });
+
+  it('drops only the broken provider entry, keeping other providers', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[providers.bad]
+type = "not-a-provider"
+`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.providers['bad']).toBeUndefined();
+    expect(result.config.providers['kimi']).toMatchObject({ type: 'kimi' });
+    expect(result.fileWarnings).toHaveLength(1);
+    expect(result.fileWarnings[0]).toContain('providers.bad');
+  });
+
+  it('keeps other providers when one entry has multiple validation issues', async () => {
+    // Two issues on the same entry: the second must not escalate to
+    // deleting the whole providers section after the first dropped the entry.
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[providers.bad]
+type = "not-a-provider"
+api_key = 123
+`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.providers['bad']).toBeUndefined();
+    expect(result.config.providers['kimi']).toMatchObject({ type: 'kimi' });
+    expect(result.fileWarnings).toHaveLength(1);
+    expect(result.fileWarnings[0]).toContain('providers.bad');
+    expect(result.fileWarnings[0]).not.toMatch(/providers[,.]? /);
+  });
+
+  it('drops only the broken model entry', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[models.broken]
+provider = "kimi"
+model = "x"
+max_context_size = -5
+`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.models?.['broken']).toBeUndefined();
+    expect(result.config.models?.['k2']).toBeDefined();
+    expect(result.fileWarnings[0]).toContain('models.broken');
+  });
+
+  it('drops the whole hooks list when one hook is invalid', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[[hooks]]
+event = "NotARealEvent"
+command = "echo hi"
+`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.hooks).toBeUndefined();
+    expect(result.config.providers['kimi']).toBeDefined();
+    expect(result.fileWarnings[0]).toContain('hooks');
+  });
+
+  it('reports every dropped section in the warning', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[loop_control]
+max_steps_per_turn = "nope"
+
+[background]
+max_running_tasks = 0
+`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.loopControl).toBeUndefined();
+    expect(result.config.background).toBeUndefined();
+    expect(result.fileWarnings).toHaveLength(1);
+    expect(result.fileWarnings[0]).toContain('loop_control');
+    expect(result.fileWarnings[0]).toContain('background');
+  });
+
+  it('applies KIMI_MODEL_* env overrides on top of a salvaged config', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[loop_control]
+max_steps_per_turn = "nope"
+`);
+    const result = loadRuntimeConfigSafe(configPath, {
+      KIMI_MODEL_NAME: 'env-model',
+      KIMI_MODEL_API_KEY: 'sk-env',
+      KIMI_MODEL_MAX_CONTEXT_SIZE: '262144',
+    });
+    expect(result.envWarnings).toEqual([]);
+    expect(result.config.models?.['__kimi_env_model__']).toBeDefined();
+    expect(result.config.providers['kimi']).toBeDefined();
+    expect(result.fileWarnings).toHaveLength(1);
+  });
+
+  it('skips KIMI_MODEL_* overrides with an env warning instead of throwing', async () => {
+    const configPath = await writeTempConfig(VALID_TOML);
+    const result = loadRuntimeConfigSafe(configPath, {
+      KIMI_MODEL_NAME: 'env-model',
+    });
+    expect(result.fileWarnings).toEqual([]);
+    expect(result.envWarnings).toHaveLength(1);
+    expect(result.envWarnings[0]).toContain('KIMI_MODEL');
+    expect(result.config).toEqual(readConfigFile(configPath));
+  });
+
+  it('readConfigFileForUpdate rewraps validation errors with an actionable message', async () => {
+    const configPath = await writeTempConfig(`${VALID_TOML}
+[loop_control]
+max_steps_per_turn = "nope"
+`);
+    try {
+      readConfigFileForUpdate(configPath);
+      throw new Error('expected readConfigFileForUpdate to throw');
+    } catch (error) {
+      expect(error).toBeInstanceOf(KimiError);
+      expect((error as KimiError).message).toContain('fix it first');
+      expect((error as KimiError).message).toContain('kimi doctor');
+      expect((error as KimiError).message).not.toContain('invalid_type');
+    }
+
+    const goodPath = await writeTempConfig(VALID_TOML);
+    expect(readConfigFileForUpdate(goodPath)).toEqual(readConfigFile(goodPath));
+  });
+
+  it('drops invalid top-level scalars and keeps the rest', async () => {
+    const configPath = await writeTempConfig(`default_thinking = "not-a-boolean"
+${VALID_TOML}`);
+    const result = loadRuntimeConfigSafe(configPath, {});
+    expect(result.config.defaultThinking).toBeUndefined();
+    expect(result.config.providers['kimi']).toBeDefined();
+    expect(result.fileWarnings).toHaveLength(1);
+    expect(result.fileWarnings[0]).toContain('default_thinking');
+  });
+});
diff --git a/packages/agent-core/test/rpc/config-rpc.test.ts b/packages/agent-core/test/rpc/config-rpc.test.ts
new file mode 100644
index 000000000..06ceb42a6
--- /dev/null
+++ b/packages/agent-core/test/rpc/config-rpc.test.ts
@@ -0,0 +1,110 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { KimiCore } from '../../src/rpc/core-impl';
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  for (const dir of tempDirs.splice(0)) {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+async function makeHome(configToml?: string): Promise<string> {
+  const home = await mkdtemp(path.join(tmpdir(), 'kimi-home-'));
+  tempDirs.push(home);
+  if (configToml !== undefined) {
+    await writeFile(path.join(home, 'config.toml'), configToml, 'utf-8');
+  }
+  return home;
+}
+
+function makeCore(home: string): KimiCore {
+  return new KimiCore(async () => ({}) as never, { homeDir: home });
+}
+
+const VALID_TOML = `
+default_model = "k2"
+
+[providers.kimi]
+type = "kimi"
+api_key = "sk-good"
+
+[models.k2]
+provider = "kimi"
+model = "kimi-for-coding"
+max_context_size = 128000
+`;
+
+describe('KimiCore degraded config loading', () => {
+  it('reports no diagnostics for a valid config', async () => {
+    const core = makeCore(await makeHome(VALID_TOML));
+    const config = await core.getKimiConfig({});
+    expect(config.providers['kimi']).toBeDefined();
+    await expect(core.getConfigDiagnostics({})).resolves.toEqual({ warnings: [] });
+  });
+
+  it('refuses to start when the TOML cannot be parsed at all', async () => {
+    const home = await makeHome('[[[');
+    // A fully unusable file means defaults-only (looks logged out), which is
+    // worse than failing fast with the parse location.
+    expect(() => makeCore(home)).toThrow(/Invalid TOML/);
+  });
+
+  it('starts with a partially invalid config, keeping the valid sections', async () => {
+    const core = makeCore(
+      await makeHome(`${VALID_TOML}
+[loop_control]
+max_steps_per_turn = "nope"
+`),
+    );
+    const config = await core.getKimiConfig({});
+    expect(config.providers['kimi']).toBeDefined();
+    expect(config.loopControl).toBeUndefined();
+    const diagnostics = await core.getConfigDiagnostics({});
+    expect(diagnostics.warnings).toHaveLength(1);
+    expect(diagnostics.warnings[0]).toContain('loop_control');
+  });
+
+  it('rejects config writes with an actionable error while the file is invalid', async () => {
+    const home = await makeHome(`${VALID_TOML}
+[loop_control]
+max_steps_per_turn = "nope"
+`);
+    const core = makeCore(home);
+    const before = await readFile(path.join(home, 'config.toml'), 'utf-8');
+
+    // Write paths stay strict: changing settings on top of a broken file
+    // must fail with a short, actionable message — not raw validation JSON —
+    // and must leave the file untouched.
+    const write = core.setKimiConfig({ defaultThinking: true });
+    await expect(write).rejects.toThrow(/fix it first/i);
+    await expect(write).rejects.toThrow(/kimi doctor/);
+    await expect(write).rejects.not.toThrow(/invalid_type/);
+
+    const after = await readFile(path.join(home, 'config.toml'), 'utf-8');
+    expect(after).toBe(before);
+  });
+
+  it('keeps the last good config when the file breaks mid-run', async () => {
+    const home = await makeHome(VALID_TOML);
+    const core = makeCore(home);
+    const configPath = path.join(home, 'config.toml');
+
+    await writeFile(configPath, '[[[', 'utf-8');
+    const kept = await core.getKimiConfig({ reload: true });
+    expect(kept.providers['kimi']).toBeDefined();
+    const degraded = await core.getConfigDiagnostics({});
+    expect(degraded.warnings.some((w) => w.includes('Invalid TOML'))).toBe(true);
+    expect(degraded.warnings.some((w) => w.includes('previous'))).toBe(true);
+
+    await writeFile(configPath, `default_thinking = true\n${VALID_TOML}`, 'utf-8');
+    const adopted = await core.getKimiConfig({ reload: true });
+    expect(adopted.defaultThinking).toBe(true);
+    await expect(core.getConfigDiagnostics({})).resolves.toEqual({ warnings: [] });
+  });
+});
diff --git a/packages/node-sdk/src/auth.ts b/packages/node-sdk/src/auth.ts
index 5443464a2..28d13ed3c 100644
--- a/packages/node-sdk/src/auth.ts
+++ b/packages/node-sdk/src/auth.ts
@@ -1,4 +1,11 @@
-import { readConfigFile, writeConfigFile, type KimiConfig, type OAuthRef } from '@moonshot-ai/agent-core';
+import {
+  loadRuntimeConfigSafe,
+  readConfigFile,
+  readConfigFileForUpdate,
+  writeConfigFile,
+  type KimiConfig,
+  type OAuthRef,
+} from '@moonshot-ai/agent-core';
 import {
   applyManagedKimiCodeConfig,
   applyManagedKimiCodeLogoutConfig,
@@ -59,7 +66,9 @@ export class KimiAuthFacade {
       onRefresh: options.onRefresh,
       configAdapter: {
         configPath: options.configPath,
-        read: () => readConfigFile(options.configPath) as SDKManagedConfig,
+        // Write-path base read: strict (a salvaged base would drop the user's
+        // broken-but-fixable sections on rewrite) with an actionable message.
+        read: () => readConfigFileForUpdate(options.configPath) as SDKManagedConfig,
         write: async (config) => {
           await writeConfigFile(options.configPath, config);
         },
@@ -169,7 +178,10 @@ export class KimiAuthFacade {
     readonly baseUrl?: string | undefined;
   } {
     const name = providerName ?? KIMI_CODE_PROVIDER_NAME;
-    const config = readConfigFile(this.options.configPath);
+    // Read path: token/status resolution must work off a degraded config
+    // instead of failing the session when an unrelated section is broken.
+    // Write paths (the toolkit's configAdapter.read) stay strict.
+    const config = loadRuntimeConfigSafe(this.options.configPath).config;
     const provider = config.providers[name];
     return {
       oauthRef: provider?.oauth,
diff --git a/packages/node-sdk/src/kimi-harness.ts b/packages/node-sdk/src/kimi-harness.ts
index d54d989d0..1dbd1bdf8 100644
--- a/packages/node-sdk/src/kimi-harness.ts
+++ b/packages/node-sdk/src/kimi-harness.ts
@@ -10,6 +10,7 @@ import { Session } from '#/session';
 import type { KimiAuthFacade } from '#/auth';
 import type { SDKRpcClientBase } from '#/rpc';
 import type {
+  ConfigDiagnostics,
   CreateSessionOptions,
   ExportSessionInput,
   ExportSessionResult,
@@ -215,6 +216,11 @@ export class KimiHarness {
     return this.rpc.getConfig(options);
   }
 
+  /** Warnings from the most recent config.toml load; empty when the config is fully valid. */
+  async getConfigDiagnostics(): Promise<ConfigDiagnostics> {
+    return this.rpc.getConfigDiagnostics();
+  }
+
   async getExperimentalFeatures(): Promise<readonly ExperimentalFeatureState[]> {
     return this.rpc.getExperimentalFeatures();
   }
diff --git a/packages/node-sdk/src/rpc.ts b/packages/node-sdk/src/rpc.ts
index ebebf9d90..10ab9cec5 100644
--- a/packages/node-sdk/src/rpc.ts
+++ b/packages/node-sdk/src/rpc.ts
@@ -22,6 +22,7 @@ import type { Kaos } from '@moonshot-ai/kaos';
 import type { ApprovalHandler, QuestionHandler } from '#/events';
 import type {
   BackgroundTaskInfo,
+  ConfigDiagnostics,
   CreateSessionOptions,
   ExportSessionInput,
   ExportSessionResult,
@@ -197,6 +198,11 @@ export abstract class SDKRpcClientBase {
     return rpc.getKimiConfig(input ?? {});
   }
 
+  async getConfigDiagnostics(): Promise<ConfigDiagnostics> {
+    const rpc = await this.getRpc();
+    return rpc.getConfigDiagnostics({});
+  }
+
   async getExperimentalFeatures(): Promise<readonly ExperimentalFeatureState[]> {
     const rpc = await this.getRpc();
     return rpc.getExperimentalFeatures({});
diff --git a/packages/node-sdk/src/types.ts b/packages/node-sdk/src/types.ts
index 3d4896257..041d78495 100644
--- a/packages/node-sdk/src/types.ts
+++ b/packages/node-sdk/src/types.ts
@@ -22,6 +22,7 @@ export type {
   BackgroundConfig,
   BackgroundTaskInfo,
   BackgroundTaskStatus,
+  ConfigDiagnostics,
   ContextMessage,
   ExperimentalFeatureState,
   ExperimentalFlagMap,
diff --git a/packages/node-sdk/test/auth-facade.test.ts b/packages/node-sdk/test/auth-facade.test.ts
index 0c6209090..59d267b0b 100644
--- a/packages/node-sdk/test/auth-facade.test.ts
+++ b/packages/node-sdk/test/auth-facade.test.ts
@@ -62,6 +62,29 @@ describe('KimiHarness.auth', () => {
     await expect(harness.auth.getCachedAccessToken()).resolves.toBe('oauth-access-token');
   });
 
+  it('resolves managed auth from a partially invalid config without throwing', async () => {
+    await new FileTokenStorage(join(homeDir, 'credentials')).save('kimi-code', freshToken());
+    await writeFile(
+      join(homeDir, 'config.toml'),
+      `
+[providers."managed:kimi-code"]
+type = "kimi"
+api_key = ""
+
+[loop_control]
+max_steps_per_turn = "abc"
+`,
+    );
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    // Token resolution is a read path: a broken section elsewhere in
+    // config.toml must degrade, not break OAuth-backed sessions.
+    await expect(harness.auth.getCachedAccessToken()).resolves.toBe('oauth-access-token');
+    await expect(harness.auth.status()).resolves.toMatchObject({
+      providers: [{ providerName: KIMI_CODE_PROVIDER_NAME, hasToken: true }],
+    });
+  });
+
   it('resolves cached access tokens from the configured scoped OAuth ref', async () => {
     const oauthKey = resolveKimiCodeOAuthKey({
       oauthHost: 'https://auth.dev.example.test',
@@ -367,7 +390,7 @@ oauth = { storage = "file", key = "${configuredOauthKey}", oauth_host = "https:/
     });
   });
 
-  it('fails clearly when a configured model alias does not have max_context_size', async () => {
+  it('starts degraded when a configured model alias does not have max_context_size', async () => {
     await new FileTokenStorage(join(homeDir, 'credentials')).save('kimi-code', freshToken());
     await writeFile(
       join(homeDir, 'config.toml'),
@@ -404,9 +427,14 @@ model = "kimi-for-coding"
       ),
     );
 
-    expect(() => createKimiHarness({ homeDir, identity: TEST_IDENTITY })).toThrow(
-      /Model "kimi-code\/kimi-for-coding" must define a positive max_context_size/,
-    );
+    // A broken config must not prevent startup: the invalid model alias is
+    // dropped, the rest of the config survives, and a warning is reported.
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+    const config = await harness.getConfig();
+    expect(config.models?.['kimi-code/kimi-for-coding']).toBeUndefined();
+    expect(config.providers[KIMI_CODE_PROVIDER_NAME]).toBeDefined();
+    const { warnings } = await harness.getConfigDiagnostics();
+    expect(warnings.some((w) => w.includes('models.kimi-code/kimi-for-coding'))).toBe(true);
   });
 
   it('removes managed Kimi config on logout', async () => {

From 7f0dde2ece3f9a004e934d69258dfd47c954043c Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Fri, 12 Jun 2026 16:49:00 +0800
Subject: [PATCH 05/17] fix(tui): gate terminal progress sequences behind OSC
 9;4 support (#690)

iTerm2 interprets any OSC 9 payload as a desktop notification, so the
ConEmu-style 9;4 progress sequence (re-sent every second by the progress
keepalive) flooded users with notifications. Only emit progress on
terminals known to implement OSC 9;4: Windows Terminal, ConEmu, Ghostty,
and WezTerm.
---
 .changeset/iterm2-progress-notifications.md   |  5 ++++
 apps/kimi-code/src/tui/kimi-tui.ts            |  1 +
 .../src/tui/utils/terminal-notification.ts    | 19 +++++++++++++
 .../kimi-code/src/tui/utils/terminal-state.ts |  8 +++++-
 apps/kimi-code/test/tui/activity-pane.test.ts | 19 +++++++++++++
 .../test/tui/terminal-notification.test.ts    | 27 +++++++++++++++++++
 6 files changed, 78 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/iterm2-progress-notifications.md

diff --git a/.changeset/iterm2-progress-notifications.md b/.changeset/iterm2-progress-notifications.md
new file mode 100644
index 000000000..473a415db
--- /dev/null
+++ b/.changeset/iterm2-progress-notifications.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix endless desktop notifications in iTerm2 by only sending terminal progress sequences to terminals that support them.
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 569e68070..0551b2a64 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1722,6 +1722,7 @@ export class KimiTUI {
   }
 
   private syncTerminalProgress(active: boolean): void {
+    if (!this.state.terminalState.supportsProgress) return;
     if (this.state.terminalState.progressActive === active) return;
     this.state.terminal.setProgress(active);
     this.state.terminalState.progressActive = active;
diff --git a/apps/kimi-code/src/tui/utils/terminal-notification.ts b/apps/kimi-code/src/tui/utils/terminal-notification.ts
index 2a0247cc7..ab6f1bff7 100644
--- a/apps/kimi-code/src/tui/utils/terminal-notification.ts
+++ b/apps/kimi-code/src/tui/utils/terminal-notification.ts
@@ -110,6 +110,25 @@ export function supportsOsc9Notification(env: NodeJS.ProcessEnv = process.env):
   return false;
 }
 
+/**
+ * Best-effort detection of ConEmu-style OSC 9;4 progress support, driven
+ * off well-known environment variables like `supportsOsc9Notification`.
+ * The two allow-lists must stay separate: iTerm2 posts a desktop
+ * notification for ANY `OSC 9;<payload>` it receives, so sending the 9;4
+ * progress sequence there pops a "4;3" notification every keepalive tick.
+ * Terminals outside this list simply get no progress reporting, which is
+ * always safe.
+ */
+export function supportsTerminalProgress(env: NodeJS.ProcessEnv = process.env): boolean {
+  if ((env['WT_SESSION'] ?? '').length > 0) return true;
+  if (env['ConEmuANSI'] === 'ON') return true;
+  const termProgram = env['TERM_PROGRAM'] ?? '';
+  if (termProgram === 'ghostty' || termProgram === 'WezTerm') return true;
+  const term = env['TERM'] ?? '';
+  if (term === 'xterm-ghostty') return true;
+  return false;
+}
+
 export function isInsideTmux(env: NodeJS.ProcessEnv = process.env): boolean {
   const tmux = env['TMUX'] ?? '';
   return tmux.length > 0;
diff --git a/apps/kimi-code/src/tui/utils/terminal-state.ts b/apps/kimi-code/src/tui/utils/terminal-state.ts
index 86d2bab9f..29127ea02 100644
--- a/apps/kimi-code/src/tui/utils/terminal-state.ts
+++ b/apps/kimi-code/src/tui/utils/terminal-state.ts
@@ -1,9 +1,14 @@
-import { isInsideTmux, supportsOsc9Notification } from './terminal-notification';
+import {
+  isInsideTmux,
+  supportsOsc9Notification,
+  supportsTerminalProgress,
+} from './terminal-notification';
 
 export interface TerminalState {
   notificationKeys: Set<string>;
   focused: boolean;
   supportsOsc9: boolean;
+  supportsProgress: boolean;
   insideTmux: boolean;
   progressActive: boolean;
 }
@@ -13,6 +18,7 @@ export function createTerminalState(): TerminalState {
     notificationKeys: new Set<string>(),
     focused: true,
     supportsOsc9: supportsOsc9Notification(),
+    supportsProgress: supportsTerminalProgress(),
     insideTmux: isInsideTmux(),
     progressActive: false,
   };
diff --git a/apps/kimi-code/test/tui/activity-pane.test.ts b/apps/kimi-code/test/tui/activity-pane.test.ts
index 2b12a76ee..b719da163 100644
--- a/apps/kimi-code/test/tui/activity-pane.test.ts
+++ b/apps/kimi-code/test/tui/activity-pane.test.ts
@@ -47,6 +47,7 @@ function makeDriverWithTerminalProgress(): {
   const driver = new KimiTUI({} as never, makeStartupInput()) as unknown as ActivityDriver;
   vi.spyOn(driver.state.ui, 'requestRender').mockImplementation(() => {});
   driver.state.terminal = { columns: 80, setProgress } as unknown as TUIState['terminal'];
+  driver.state.terminalState.supportsProgress = true;
   return { driver, state: driver.state, setProgress };
 }
 
@@ -100,6 +101,24 @@ describe('updateActivityPane terminal progress', () => {
     }
   });
 
+  it('never emits terminal progress when the terminal does not support OSC 9;4', () => {
+    vi.useFakeTimers();
+    try {
+      const { driver, state, setProgress } = makeDriverWithTerminalProgress();
+      state.terminalState.supportsProgress = false;
+
+      state.livePane = { ...state.livePane, mode: 'waiting' };
+      driver.updateActivityPane();
+      state.livePane = { ...state.livePane, mode: 'idle' };
+      driver.updateActivityPane();
+
+      expect(setProgress).not.toHaveBeenCalled();
+      expect(state.terminalState.progressActive).toBe(false);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it('keeps compaction visible as terminal progress even though the pane is hidden', () => {
     const { driver, state, setProgress } = makeDriverWithTerminalProgress();
     state.appState.isCompacting = true;
diff --git a/apps/kimi-code/test/tui/terminal-notification.test.ts b/apps/kimi-code/test/tui/terminal-notification.test.ts
index 2d5d904ee..cef7b8086 100644
--- a/apps/kimi-code/test/tui/terminal-notification.test.ts
+++ b/apps/kimi-code/test/tui/terminal-notification.test.ts
@@ -8,6 +8,7 @@ import {
   isInsideTmux,
   notifyTerminalOnce,
   supportsOsc9Notification,
+  supportsTerminalProgress,
 } from '#/tui/utils/terminal-notification';
 
 function makeNotificationState(args: {
@@ -215,6 +216,32 @@ describe('supportsOsc9Notification', () => {
   });
 });
 
+describe('supportsTerminalProgress', () => {
+  it('detects Windows Terminal / ConEmu via env flags', () => {
+    expect(supportsTerminalProgress({ WT_SESSION: 'abc-123' })).toBe(true);
+    expect(supportsTerminalProgress({ ConEmuANSI: 'ON' })).toBe(true);
+  });
+
+  it('detects Ghostty / WezTerm via TERM_PROGRAM and TERM', () => {
+    expect(supportsTerminalProgress({ TERM_PROGRAM: 'ghostty' })).toBe(true);
+    expect(supportsTerminalProgress({ TERM: 'xterm-ghostty' })).toBe(true);
+    expect(supportsTerminalProgress({ TERM_PROGRAM: 'WezTerm' })).toBe(true);
+  });
+
+  it('rejects terminals that show every OSC 9 payload as a notification', () => {
+    // iTerm2 treats any OSC 9 payload as a desktop notification, so the
+    // ConEmu-style 9;4 progress sequence must never be sent there.
+    expect(supportsTerminalProgress({ TERM_PROGRAM: 'iTerm.app' })).toBe(false);
+    expect(supportsTerminalProgress({ TERM_PROGRAM: 'Apple_Terminal' })).toBe(false);
+    expect(supportsTerminalProgress({ TERM_PROGRAM: 'WarpTerminal' })).toBe(false);
+    expect(supportsTerminalProgress({ TERM: 'xterm-kitty' })).toBe(false);
+    expect(supportsTerminalProgress({ TERM: 'xterm-256color' })).toBe(false);
+    expect(supportsTerminalProgress({ ConEmuANSI: 'OFF' })).toBe(false);
+    expect(supportsTerminalProgress({ WT_SESSION: '' })).toBe(false);
+    expect(supportsTerminalProgress({})).toBe(false);
+  });
+});
+
 describe('isInsideTmux', () => {
   it('detects tmux via the TMUX env var', () => {
     expect(isInsideTmux({ TMUX: '/private/tmp/tmux-501/default,1234,0' })).toBe(true);

From d1ba14562bafdb6b93c3eec1b5c453186507ed56 Mon Sep 17 00:00:00 2001
From: Haozhe <yanghaozhe@moonshot.ai>
Date: Fri, 12 Jun 2026 17:08:40 +0800
Subject: [PATCH 06/17] feat(providers): sync custom registry providers on
 startup refresh (#675)

* feat(providers): sync custom registry providers on startup refresh

- group registry providers by URL and retry available API keys\n- automatically add new providers and remove disappeared ones\n- coalesce duplicate source URLs to avoid false config-change reports\n- clear defaultThinking when default model is removed\n- update docs and add tests for registry sync scenarios

* fix(tui): only show provider refresh status for added models

 Skip removed / metadata-only provider updates when reporting model list changes.\n\n add: test to enforce the behavior.
---
 .changeset/sync-registry-providers.md         |   5 +
 apps/kimi-code/src/cli/sub/provider.ts        |   5 +-
 apps/kimi-code/src/tui/kimi-tui.ts            |   8 +-
 .../src/tui/utils/refresh-providers.ts        | 133 +++++++-
 .../test/tui/utils/refresh-providers.test.ts  | 283 ++++++++++++++++++
 docs/en/configuration/providers.md            |   2 +-
 docs/en/reference/kimi-command.md             |   2 +-
 docs/zh/configuration/providers.md            |   2 +-
 docs/zh/reference/kimi-command.md             |   2 +-
 packages/oauth/src/custom-registry.ts         |   7 +-
 10 files changed, 421 insertions(+), 28 deletions(-)
 create mode 100644 .changeset/sync-registry-providers.md

diff --git a/.changeset/sync-registry-providers.md b/.changeset/sync-registry-providers.md
new file mode 100644
index 000000000..b0908a7ca
--- /dev/null
+++ b/.changeset/sync-registry-providers.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Sync custom registry provider additions, removals, and rotated registry keys during startup refresh.
diff --git a/apps/kimi-code/src/cli/sub/provider.ts b/apps/kimi-code/src/cli/sub/provider.ts
index b712891b2..cd30c1957 100644
--- a/apps/kimi-code/src/cli/sub/provider.ts
+++ b/apps/kimi-code/src/cli/sub/provider.ts
@@ -7,8 +7,9 @@
  *
  * `add` writes the same `source = { kind: 'apiJson', url, apiKey }` blob the
  * TUI does; the next launch's `refreshAllProviderModels`
- * (apps/kimi-code/src/tui/utils/refresh-providers.ts) groups by `{url, apiKey}`
- * and re-fetches the model list, so periodic refresh is automatic.
+ * (apps/kimi-code/src/tui/utils/refresh-providers.ts) groups by URL, retries
+ * available API-key candidates, and re-fetches the model list, so periodic
+ * refresh is automatic.
  */
 
 import {
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 0551b2a64..87c0b4cb2 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -475,10 +475,10 @@ export class KimiTUI {
     try {
       const result = await this.authFlow.refreshProviderModels();
       for (const c of result.changed) {
-        const parts: string[] = [c.providerName];
-        if (c.added > 0) parts.push(`+${String(c.added)} model${c.added > 1 ? 's' : ''}`);
-        if (c.removed > 0) parts.push(`-${String(c.removed)} model${c.removed > 1 ? 's' : ''}`);
-        this.showStatus(parts.join(' · ') + '.');
+        if (c.added <= 0) continue;
+        this.showStatus(
+          `${c.providerName} · +${String(c.added)} model${c.added > 1 ? 's' : ''}.`,
+        );
       }
       for (const f of result.failed) {
         this.showStatus(`Skipped refreshing ${f.provider}: ${f.reason}`, 'warning');
diff --git a/apps/kimi-code/src/tui/utils/refresh-providers.ts b/apps/kimi-code/src/tui/utils/refresh-providers.ts
index aa8cd7577..bdda7aa40 100644
--- a/apps/kimi-code/src/tui/utils/refresh-providers.ts
+++ b/apps/kimi-code/src/tui/utils/refresh-providers.ts
@@ -10,6 +10,7 @@ import {
   filterModelsByPrefix,
   getOpenPlatformById,
   isOpenPlatformId,
+  removeCustomRegistryProvider,
   resolveKimiCodeRuntimeAuth,
   type CustomRegistrySource,
   type ManagedKimiConfigShape,
@@ -42,7 +43,7 @@ export interface RefreshResult {
 function readCustomRegistrySource(provider: ProviderConfig): CustomRegistrySource | undefined {
   const source = provider.source;
   if (typeof source !== 'object' || source === null) return undefined;
-  const candidate = source as Record<string, unknown>;
+  const candidate = source;
   if (candidate['kind'] !== 'apiJson') return undefined;
   const url = candidate['url'];
   const apiKey = candidate['apiKey'];
@@ -51,6 +52,36 @@ function readCustomRegistrySource(provider: ProviderConfig): CustomRegistrySourc
   return { kind: 'apiJson', url, apiKey };
 }
 
+function customRegistrySourceKey(source: CustomRegistrySource): string {
+  return JSON.stringify([source.url]);
+}
+
+function customRegistrySourceCredentialKey(source: CustomRegistrySource): string {
+  return JSON.stringify([source.url, source.apiKey]);
+}
+
+async function fetchCustomRegistryFromSources(
+  sources: readonly CustomRegistrySource[],
+): Promise<{
+  readonly entries: Awaited<ReturnType<typeof fetchCustomRegistry>>;
+  readonly source: CustomRegistrySource;
+}> {
+  let lastError: unknown;
+  for (const source of sources) {
+    try {
+      return {
+        entries: await fetchCustomRegistry(source),
+        source,
+      };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  if (lastError instanceof Error) throw lastError;
+  if (typeof lastError === 'string') throw new Error(lastError);
+  throw new Error('No custom registry sources configured.');
+}
+
 function asManaged(config: KimiConfig): ManagedKimiConfigShape {
   return config as unknown as ManagedKimiConfigShape;
 }
@@ -143,6 +174,14 @@ function providerModelsEqual(
   );
 }
 
+function providerConfigSnapshot(config: KimiConfig, providerId: string): string {
+  return JSON.stringify(config.providers[providerId] ?? null);
+}
+
+function providerConfigEqual(config: KimiConfig, nextConfig: KimiConfig, providerId: string): boolean {
+  return providerConfigSnapshot(config, providerId) === providerConfigSnapshot(nextConfig, providerId);
+}
+
 function providerRefreshAliasKeys(
   config: KimiConfig,
   nextConfig: KimiConfig,
@@ -199,6 +238,15 @@ function clampDanglingDefault(config: KimiConfig): void {
   }
 }
 
+function clearDefaultThinkingWhenDefaultRemoved(
+  config: KimiConfig,
+  previousDefaultModel: string | undefined,
+): void {
+  if (previousDefaultModel !== undefined && config.defaultModel === undefined) {
+    config.defaultThinking = undefined;
+  }
+}
+
 function pickDefaultModel(config: KimiConfig, providerId: string, models: Array<{ id: string }>): string {
   const firstModel = models[0];
   if (firstModel === undefined) return '';
@@ -263,6 +311,7 @@ export async function refreshAllProviderModels(host: RefreshProviderHost): Promi
         );
         restoreDefaultSelection(next, config.defaultModel, config.defaultThinking);
         clampDanglingDefault(next);
+        clearDefaultThinkingWhenDefaultRemoved(next, config.defaultModel);
 
         if (providerModelsEqual(config, next, KIMI_CODE_PROVIDER_NAME, refreshedAliasKeys)) {
           unchanged.push(KIMI_CODE_PROVIDER_NAME);
@@ -332,6 +381,7 @@ export async function refreshAllProviderModels(host: RefreshProviderHost): Promi
       restoreProviderAliases(next, preserveUserProviderAliases(config, providerId, refreshedAliasKeys));
       restoreDefaultSelection(next, config.defaultModel, config.defaultThinking);
       clampDanglingDefault(next);
+      clearDefaultThinkingWhenDefaultRemoved(next, config.defaultModel);
 
       if (providerModelsEqual(config, next, providerId, refreshedAliasKeys)) {
         unchanged.push(providerId);
@@ -363,26 +413,42 @@ export async function refreshAllProviderModels(host: RefreshProviderHost): Promi
   }
 
   // -------------------------------------------------------------------------
-  // 3. Custom Registry providers (grouped by {url, apiKey})
+  // 3. Custom Registry providers (grouped by URL, with API-key candidates)
   // -------------------------------------------------------------------------
-  const customSources = new Map<string, { source: CustomRegistrySource; providerIds: string[] }>();
+  const customSources = new Map<
+    string,
+    {
+      readonly sources: CustomRegistrySource[];
+      readonly sourceKeys: Set<string>;
+      readonly providerIds: string[];
+    }
+  >();
   for (const [providerId, providerConfig] of Object.entries(config.providers)) {
     if (providerId === KIMI_CODE_PROVIDER_NAME) continue;
     if (isOpenPlatformId(providerId)) continue;
     const source = readCustomRegistrySource(providerConfig);
     if (source === undefined) continue;
-    const key = `${source.url}${source.apiKey}`;
+    const key = customRegistrySourceKey(source);
+    const sourceKey = customRegistrySourceCredentialKey(source);
     const entry = customSources.get(key);
     if (entry !== undefined) {
+      if (!entry.sourceKeys.has(sourceKey)) {
+        entry.sources.push(source);
+        entry.sourceKeys.add(sourceKey);
+      }
       entry.providerIds.push(providerId);
     } else {
-      customSources.set(key, { source, providerIds: [providerId] });
+      customSources.set(key, {
+        sources: [source],
+        sourceKeys: new Set([sourceKey]),
+        providerIds: [providerId],
+      });
     }
   }
 
-  for (const { source, providerIds } of customSources.values()) {
+  for (const { sources, providerIds } of customSources.values()) {
     try {
-      const entries = await fetchCustomRegistry(source);
+      const { entries, source } = await fetchCustomRegistryFromSources(sources);
       // Build the whole batch on one clone so that several changed providers
       // from the same source do not overwrite each other's aliases, and so the
       // config we compare is exactly the config we persist.
@@ -393,17 +459,47 @@ export async function refreshAllProviderModels(host: RefreshProviderHost): Promi
         readonly added: number;
         readonly removed: number;
       }> = [];
+      const providersToRemoveBeforeSet = new Set<string>();
+      let hasUnreportedConfigChange = false;
+      const remoteEntries = Object.values(entries);
+      const remoteEntriesByProviderId = new Map(
+        remoteEntries.map((entry) => [entry.id, entry]),
+      );
+      const providerIdsToSync = new Set(providerIds);
+      for (const entry of remoteEntries) providerIdsToSync.add(entry.id);
 
-      for (const providerId of providerIds) {
-        const entry = entries[providerId];
-        if (entry === undefined) continue;
+      for (const providerId of providerIdsToSync) {
+        const entry = remoteEntriesByProviderId.get(providerId);
+        if (entry === undefined) {
+          const oldIds = collectModelIdsForAliases(config, providerAliasKeys(config, providerId));
+          removeCustomRegistryProvider(asManaged(next), providerId);
+          changedProviders.push({
+            providerId,
+            providerName: providerId,
+            added: 0,
+            removed: oldIds.size,
+          });
+          providersToRemoveBeforeSet.add(providerId);
+          continue;
+        }
 
+        const existed = config.providers[providerId] !== undefined;
         applyCustomRegistryProvider(asManaged(next), entry, source);
         const refreshedAliasKeys = providerRefreshAliasKeys(config, next, providerId, `${providerId}/`);
-        restoreProviderAliases(next, preserveUserProviderAliases(config, providerId, refreshedAliasKeys));
+        if (existed) {
+          restoreProviderAliases(next, preserveUserProviderAliases(config, providerId, refreshedAliasKeys));
+        }
 
-        if (providerModelsEqual(config, next, providerId, refreshedAliasKeys)) {
+        if (
+          existed &&
+          providerModelsEqual(config, next, providerId, refreshedAliasKeys) &&
+          providerConfigEqual(config, next, providerId)
+        ) {
           unchanged.push(providerId);
+        } else if (existed && providerModelsEqual(config, next, providerId, refreshedAliasKeys)) {
+          unchanged.push(providerId);
+          providersToRemoveBeforeSet.add(providerId);
+          hasUnreportedConfigChange = true;
         } else {
           const { added, removed } = computeChanges(
             collectModelIdsForAliases(config, refreshedAliasKeys),
@@ -415,13 +511,15 @@ export async function refreshAllProviderModels(host: RefreshProviderHost): Promi
             added,
             removed,
           });
+          if (existed) providersToRemoveBeforeSet.add(providerId);
         }
       }
 
-      if (changedProviders.length > 0) {
+      if (changedProviders.length > 0 || hasUnreportedConfigChange) {
         restoreDefaultSelection(next, config.defaultModel, config.defaultThinking);
         clampDanglingDefault(next);
-        for (const { providerId } of changedProviders) {
+        clearDefaultThinkingWhenDefaultRemoved(next, config.defaultModel);
+        for (const providerId of providersToRemoveBeforeSet) {
           await host.removeProvider(providerId);
         }
         config = await host.setConfig({
@@ -431,7 +529,12 @@ export async function refreshAllProviderModels(host: RefreshProviderHost): Promi
           defaultThinking: next.defaultThinking,
         });
         for (const change of changedProviders) {
-          changed.push(change);
+          changed.push({
+            providerId: change.providerId,
+            providerName: change.providerName,
+            added: change.added,
+            removed: change.removed,
+          });
         }
       }
     } catch (error) {
diff --git a/apps/kimi-code/test/tui/utils/refresh-providers.test.ts b/apps/kimi-code/test/tui/utils/refresh-providers.test.ts
index d2b0d778b..17749a61a 100644
--- a/apps/kimi-code/test/tui/utils/refresh-providers.test.ts
+++ b/apps/kimi-code/test/tui/utils/refresh-providers.test.ts
@@ -261,6 +261,289 @@ describe('refreshAllProviderModels', () => {
     expect(host.current().models?.[userAlias]).toEqual(userAliasModel);
   });
 
+  it('adds custom-registry providers that appear under an existing source URL', async () => {
+    const registryUrl = 'https://registry.example.test/v1/models/api.json';
+    const apiKey = 'sk-test-token';
+    const source = { kind: 'apiJson', url: registryUrl, apiKey };
+    const host = makeRefreshHost({
+      providers: {
+        a: {
+          type: 'openai',
+          baseUrl: 'https://a.example.test/v1',
+          apiKey,
+          source,
+        },
+      },
+      models: {
+        'a/m1': {
+          provider: 'a',
+          model: 'm1',
+          maxContextSize: 131072,
+          capabilities: ['tool_use'],
+          displayName: 'm1',
+        },
+      },
+      telemetry: true,
+    } as unknown as KimiConfig);
+
+    const fetchMock = vi.fn<FetchMock>(async (input, init) => {
+      expect(fetchInputUrl(input)).toBe(registryUrl);
+      expect(new Headers(init?.headers).get('authorization')).toBe('Bearer sk-test-token');
+      return new Response(
+        JSON.stringify({
+          a: {
+            id: 'a',
+            name: 'Provider A',
+            api: 'https://a.example.test/v1',
+            type: 'openai',
+            models: { m1: { id: 'm1' } },
+          },
+          b: {
+            id: 'b',
+            name: 'Provider B',
+            api: 'https://b.example.test/v1',
+            type: 'openai',
+            models: { m1: { id: 'm1' } },
+          },
+        }),
+        { status: 200, headers: { 'Content-Type': 'application/json' } },
+      );
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await refreshAllProviderModels({
+      getConfig: async () => host.current(),
+      removeProvider: host.removeProvider,
+      setConfig: host.setConfig,
+      resolveOAuthToken: vi.fn(),
+    });
+
+    expect(result.failed).toEqual([]);
+    expect(result.unchanged).toEqual(['a']);
+    expect(result.changed).toEqual([
+      {
+        providerId: 'b',
+        providerName: 'Provider B',
+        added: 1,
+        removed: 0,
+      },
+    ]);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(host.removeProvider).not.toHaveBeenCalled();
+    expect(host.setConfig).toHaveBeenCalledTimes(1);
+    expect(Object.keys(host.current().providers).toSorted()).toEqual(['a', 'b']);
+    expect(host.current().providers['b']).toMatchObject({
+      type: 'openai',
+      baseUrl: 'https://b.example.test/v1',
+      apiKey,
+      source,
+    });
+    expect(host.current().models?.['b/m1']).toEqual({
+      provider: 'b',
+      model: 'm1',
+      maxContextSize: 131072,
+      capabilities: ['tool_use'],
+      displayName: 'm1',
+    });
+  });
+
+  it('removes custom-registry providers that disappear from an existing source URL', async () => {
+    const registryUrl = 'https://registry.example.test/v1/models/api.json';
+    const apiKey = 'sk-test-token';
+    const source = { kind: 'apiJson', url: registryUrl, apiKey };
+    const host = makeRefreshHost({
+      providers: {
+        a: {
+          type: 'openai',
+          baseUrl: 'https://a.example.test/v1',
+          apiKey,
+          source,
+        },
+        b: {
+          type: 'openai',
+          baseUrl: 'https://b.example.test/v1',
+          apiKey,
+          source,
+        },
+      },
+      models: {
+        'a/m1': {
+          provider: 'a',
+          model: 'm1',
+          maxContextSize: 131072,
+          capabilities: ['tool_use'],
+          displayName: 'm1',
+        },
+        'b/m1': {
+          provider: 'b',
+          model: 'm1',
+          maxContextSize: 131072,
+          capabilities: ['tool_use'],
+          displayName: 'm1',
+        },
+        'my-b': {
+          provider: 'b',
+          model: 'm1',
+          maxContextSize: 131072,
+          capabilities: ['tool_use'],
+          displayName: 'My B',
+        },
+      },
+      defaultModel: 'my-b',
+      defaultThinking: true,
+      telemetry: true,
+    } as unknown as KimiConfig);
+
+    const fetchMock = vi.fn<FetchMock>(async (input, init) => {
+      expect(fetchInputUrl(input)).toBe(registryUrl);
+      expect(new Headers(init?.headers).get('authorization')).toBe('Bearer sk-test-token');
+      return new Response(
+        JSON.stringify({
+          a: {
+            id: 'a',
+            name: 'Provider A',
+            api: 'https://a.example.test/v1',
+            type: 'openai',
+            models: { m1: { id: 'm1' } },
+          },
+        }),
+        { status: 200, headers: { 'Content-Type': 'application/json' } },
+      );
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await refreshAllProviderModels({
+      getConfig: async () => host.current(),
+      removeProvider: host.removeProvider,
+      setConfig: host.setConfig,
+      resolveOAuthToken: vi.fn(),
+    });
+
+    expect(result.failed).toEqual([]);
+    expect(result.unchanged).toEqual(['a']);
+    expect(result.changed).toEqual([
+      {
+        providerId: 'b',
+        providerName: 'b',
+        added: 0,
+        removed: 1,
+      },
+    ]);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(host.removeProvider).toHaveBeenCalledWith('b');
+    expect(host.setConfig).toHaveBeenCalledTimes(1);
+    expect(Object.keys(host.current().providers)).toEqual(['a']);
+    expect(host.current().models?.['a/m1']).toBeDefined();
+    expect(host.current().models?.['b/m1']).toBeUndefined();
+    expect(host.current().models?.['my-b']).toBeUndefined();
+    expect(host.current().defaultModel).toBeUndefined();
+    expect(host.current().defaultThinking).toBeUndefined();
+  });
+
+  it('coalesces duplicate custom-registry source URLs without reporting config-only changes', async () => {
+    const registryUrl = 'https://registry.example.test/v1/models/api.json';
+    const oldSource = { kind: 'apiJson', url: registryUrl, apiKey: 'sk-old-token' };
+    const newSource = { kind: 'apiJson', url: registryUrl, apiKey: 'sk-new-token' };
+    const host = makeRefreshHost({
+      providers: {
+        a: {
+          type: 'openai',
+          baseUrl: 'https://a.example.test/v1',
+          apiKey: 'sk-old-token',
+          source: oldSource,
+        },
+        b: {
+          type: 'openai',
+          baseUrl: 'https://b.example.test/v1',
+          apiKey: 'sk-new-token',
+          source: newSource,
+        },
+      },
+      models: {
+        'a/m1': {
+          provider: 'a',
+          model: 'm1',
+          maxContextSize: 131072,
+          capabilities: ['tool_use'],
+          displayName: 'm1',
+        },
+        'b/m1': {
+          provider: 'b',
+          model: 'm1',
+          maxContextSize: 131072,
+          capabilities: ['tool_use'],
+          displayName: 'm1',
+        },
+      },
+      telemetry: true,
+    } as unknown as KimiConfig);
+
+    const fetchMock = vi.fn<FetchMock>(async (input, init) => {
+      expect(fetchInputUrl(input)).toBe(registryUrl);
+      const authorization = new Headers(init?.headers).get('authorization');
+      if (authorization === 'Bearer sk-old-token') {
+        return new Response(JSON.stringify({ message: 'expired token' }), {
+          status: 401,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      expect(authorization).toBe('Bearer sk-new-token');
+      return new Response(
+        JSON.stringify({
+          a: {
+            id: 'a',
+            name: 'Provider A',
+            api: 'https://a.example.test/v1',
+            type: 'openai',
+            models: { m1: { id: 'm1' } },
+          },
+          b: {
+            id: 'b',
+            name: 'Provider B',
+            api: 'https://b.example.test/v1',
+            type: 'openai',
+            models: { m1: { id: 'm1' }, m2: { id: 'm2' } },
+          },
+        }),
+        { status: 200, headers: { 'Content-Type': 'application/json' } },
+      );
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await refreshAllProviderModels({
+      getConfig: async () => host.current(),
+      removeProvider: host.removeProvider,
+      setConfig: host.setConfig,
+      resolveOAuthToken: vi.fn(),
+    });
+
+    expect(result.failed).toEqual([]);
+    expect(result.unchanged).toEqual(['a']);
+    expect(result.changed).toEqual([
+      {
+        providerId: 'b',
+        providerName: 'Provider B',
+        added: 1,
+        removed: 0,
+      },
+    ]);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(host.removeProvider).toHaveBeenCalledWith('a');
+    expect(host.removeProvider).toHaveBeenCalledWith('b');
+    expect(host.setConfig).toHaveBeenCalledTimes(1);
+    expect(host.current().providers['a']?.source).toEqual(newSource);
+    expect(host.current().providers['b']?.source).toEqual(newSource);
+    expect(host.current().providers['a']?.apiKey).toBe('sk-new-token');
+    expect(host.current().providers['b']?.apiKey).toBe('sk-new-token');
+    expect(host.current().models?.['b/m2']).toEqual({
+      provider: 'b',
+      model: 'm2',
+      maxContextSize: 131072,
+      capabilities: ['tool_use'],
+      displayName: 'm2',
+    });
+  });
+
   it('ignores user-defined aliases when custom-registry metadata is unchanged', async () => {
     const registryUrl = 'https://registry.example.test/v1/models/api.json';
     const providerId = 'example_chat-completions';
diff --git a/docs/en/configuration/providers.md b/docs/en/configuration/providers.md
index f57c7730e..8fed5c4e1 100644
--- a/docs/en/configuration/providers.md
+++ b/docs/en/configuration/providers.md
@@ -32,7 +32,7 @@ The manager displays providers as a list of entries grouped by source. Navigatio
 Two paths when adding:
 
 - **Known third-party provider**: fetches the model catalog from [models.dev](https://models.dev/), select a provider → enter an API key → select a default model
-- **Custom registry (api.json)**: paste a custom registry URL and Bearer token; the CLI automatically creates the `providers` / `models` entries
+- **Custom registry (api.json)**: paste a custom registry URL and Bearer token; the CLI automatically creates the `providers` / `models` entries. On later startup, providers from the same registry URL are refreshed together, so upstream provider additions, removals, and model metadata changes are synced.
 
 ::: warning
 Kimi Code OAuth managed accounts logged in via `/login` do not appear in `/provider`. Use `/login` and `/logout` to manage them.
diff --git a/docs/en/reference/kimi-command.md b/docs/en/reference/kimi-command.md
index 5b96a9496..a0623445b 100644
--- a/docs/en/reference/kimi-command.md
+++ b/docs/en/reference/kimi-command.md
@@ -226,7 +226,7 @@ Five actions are available:
 
 #### `kimi provider add <url>`
 
-Bulk-import all providers from a custom registry (`api.json`). The command fetches the registry, creates a `[providers.<id>]` and `[models.<alias>]` entry for each item, and writes `source` metadata so the TUI refreshes the model list automatically on next startup.
+Bulk-import all providers from a custom registry (`api.json`). The command fetches the registry, creates a `[providers.<id>]` and `[models.<alias>]` entry for each item, and writes `source` metadata so the TUI refreshes providers and models from the same registry URL automatically on next startup.
 
 | Parameter / Option | Description |
 | --- | --- |
diff --git a/docs/zh/configuration/providers.md b/docs/zh/configuration/providers.md
index 939b56181..41aae2736 100644
--- a/docs/zh/configuration/providers.md
+++ b/docs/zh/configuration/providers.md
@@ -32,7 +32,7 @@ Kimi Code CLI 支持同时接入多家 LLM 平台——用 Kimi Code 托管服
 添加时有两条路径：
 
 - **Known third-party provider**：从 [models.dev](https://models.dev/) 拉取模型目录，选供应商 → 输入 API 密钥 → 选默认模型
-- **Custom registry (api.json)**：粘贴自定义 registry 地址和 Bearer token，CLI 自动创建 `providers` / `models` 条目
+- **Custom registry (api.json)**：粘贴自定义 registry 地址和 Bearer token，CLI 自动创建 `providers` / `models` 条目。后续启动时，同一个 registry 地址下的供应商会一起刷新，因此上游新增、删除供应商以及模型元数据变化都会同步。
 
 ::: warning
 通过 `/login` 登录的 Kimi Code OAuth 托管账号不会在 `/provider` 里显示，请用 `/login` 和 `/logout` 管理。
diff --git a/docs/zh/reference/kimi-command.md b/docs/zh/reference/kimi-command.md
index 67d259f30..9e8c9180b 100644
--- a/docs/zh/reference/kimi-command.md
+++ b/docs/zh/reference/kimi-command.md
@@ -226,7 +226,7 @@ kimi provider <action> [options]
 
 #### `kimi provider add <url>`
 
-从自定义 registry（`api.json`）批量导入所有供应商。命令会拉取 registry，为每个条目创建 `[providers.<id>]` 和 `[models.<alias>]`，并写入 `source` 元数据，使 TUI 下次启动时自动刷新模型列表。
+从自定义 registry（`api.json`）批量导入所有供应商。命令会拉取 registry，为每个条目创建 `[providers.<id>]` 和 `[models.<alias>]`，并写入 `source` 元数据，使 TUI 下次启动时自动刷新同一 registry 地址下的供应商和模型。
 
 | 参数 / 选项 | 说明 |
 | --- | --- |
diff --git a/packages/oauth/src/custom-registry.ts b/packages/oauth/src/custom-registry.ts
index cad5fd9f2..0c5d720f7 100644
--- a/packages/oauth/src/custom-registry.ts
+++ b/packages/oauth/src/custom-registry.ts
@@ -6,9 +6,10 @@ export type { ManagedKimiConfigShape };
 
 /**
  * Identifies where a custom-registry-managed provider came from. The same
- * `{url, apiKey}` pair may produce multiple providers (one per top-level entry
- * in the api.json document) — the refresh dispatcher groups by these fields to
- * issue a single HTTP GET per source.
+ * URL may produce multiple providers (one per top-level entry in the api.json
+ * document). Refresh treats the URL as the stable registry identity and may try
+ * more than one API key when existing provider records drift during key
+ * rotation.
  */
 export interface CustomRegistrySource {
   readonly kind: 'apiJson';

From 7ca9bdfed516d148b063229a9686a28f9e29aaef Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Fri, 12 Jun 2026 17:41:25 +0800
Subject: [PATCH 07/17] fix(tui): skip re-entering plan mode on resume and
 scope startup flags to startup (#692)

Resuming a session that was already in plan mode with --plan crashed with
"Already in plan mode": the resume path called setPlanMode(true)
unconditionally while session replay had already restored the active plan
state. Check the session status first and only enable plan mode when it is
not active yet, in both the resume startup path and the startup session
picker.

The /sessions picker shared the same onSelect callback, so startup flags
were also re-applied on every mid-session switch, overriding the picked
session's own persisted modes. Gate the flag application behind an
applyStartupModes option that only the startup picker enables, and surface
post-switch setup errors instead of leaving them as unhandled rejections.
---
 ...eplan-on-resume-and-scope-startup-flags.md |   5 +
 apps/kimi-code/src/tui/kimi-tui.ts            | 102 ++++++++++--------
 .../test/tui/kimi-tui-startup.test.ts         | 102 ++++++++++++++++++
 3 files changed, 166 insertions(+), 43 deletions(-)
 create mode 100644 .changeset/skip-replan-on-resume-and-scope-startup-flags.md

diff --git a/.changeset/skip-replan-on-resume-and-scope-startup-flags.md b/.changeset/skip-replan-on-resume-and-scope-startup-flags.md
new file mode 100644
index 000000000..ec7e549e7
--- /dev/null
+++ b/.changeset/skip-replan-on-resume-and-scope-startup-flags.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Skip re-entering plan mode when resuming a session that is already in plan mode (previously failed with "Already in plan mode"), and stop re-applying `--auto`/`--yolo`/`--plan` startup flags when switching sessions through the `/sessions` picker.
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 87c0b4cb2..0337785f0 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -588,14 +588,7 @@ export class KimiTUI {
         session = await this.harness.createSession(createSessionOptions);
       }
       if (session !== undefined && shouldReplayHistory) {
-        if (startup.auto) {
-          await session.setPermission('auto');
-        } else if (startup.yolo) {
-          await session.setPermission('yolo');
-        }
-        if (startup.plan) {
-          await session.setPlanMode(true);
-        }
+        await this.applyStartupModesToResumedSession(session);
         if (startup.model !== undefined) {
           await session.setModel(startup.model);
         }
@@ -1097,6 +1090,25 @@ export class KimiTUI {
     });
   }
 
+  // Apply --auto/--yolo/--plan startup flags to a resumed session. The resumed
+  // session may already be in plan mode from its persisted records, and
+  // re-entering plan mode throws, so only enable it when it is not active yet.
+  // setPermission is idempotent and needs no such guard.
+  private async applyStartupModesToResumedSession(session: Session): Promise<void> {
+    const { startup } = this.options;
+    if (startup.auto) {
+      await session.setPermission('auto');
+    } else if (startup.yolo) {
+      await session.setPermission('yolo');
+    }
+    if (startup.plan) {
+      const status = await session.getStatus();
+      if (!status.planMode) {
+        await session.setPlanMode(true);
+      }
+    }
+  }
+
   // Re-apply startup flags that the user explicitly passed on the command line.
   // syncRuntimeState and session-replay hydration can both read stale persisted
   // values, so this guarantees the footer reflects the CLI intent.
@@ -1830,27 +1842,28 @@ export class KimiTUI {
 
   async showSessionPicker(): Promise<void> {
     await this.fetchSessions();
-    this.mountSessionPicker(() => {
-      this.hideSessionPicker();
+    this.mountSessionPicker({
+      onCancel: () => {
+        this.hideSessionPicker();
+      },
     });
   }
 
   private async bootstrapFromPicker(): Promise<void> {
     await this.fetchSessions();
-    this.mountSessionPicker(
-      () => {
+    this.mountSessionPicker({
+      applyStartupModes: true,
+      onCancel: () => {
         this.hideSessionPicker();
         void this.stop();
       },
-      {
-        onCtrlC: () => {
-          this.state.editor.onCtrlC?.();
-        },
-        onCtrlD: () => {
-          this.state.editor.onCtrlD?.();
-        },
+      onCtrlC: () => {
+        this.state.editor.onCtrlC?.();
       },
-    );
+      onCtrlD: () => {
+        this.state.editor.onCtrlD?.();
+      },
+    });
   }
 
   hideSessionPicker(): void {
@@ -1859,10 +1872,15 @@ export class KimiTUI {
     this.restoreEditor();
   }
 
-  private mountSessionPicker(
-    onCancel: () => void,
-    shortcuts: { readonly onCtrlC?: () => void; readonly onCtrlD?: () => void } = {},
-  ): void {
+  private mountSessionPicker(options: {
+    readonly onCancel: () => void;
+    readonly onCtrlC?: () => void;
+    readonly onCtrlD?: () => void;
+    // CLI mode flags (--auto/--yolo/--plan) target the session picked at
+    // startup (bare --session); later /sessions switches keep the picked
+    // session's own persisted modes.
+    readonly applyStartupModes?: boolean;
+  }): void {
     this.state.activeDialog = 'session-picker';
     this.mountEditorReplacement(
       new SessionPickerComponent({
@@ -1870,26 +1888,24 @@ export class KimiTUI {
         loading: this.state.loadingSessions,
         currentSessionId: this.state.appState.sessionId,
         onSelect: (sessionId: string) => {
-          void this.resumeSession(sessionId).then(async (switched) => {
-            if (!switched) {
-              return;
-            }
-            const session = this.requireSession();
-            if (this.options.startup.auto) {
-              await session.setPermission('auto');
-            } else if (this.options.startup.yolo) {
-              await session.setPermission('yolo');
-            }
-            if (this.options.startup.plan) {
-              await session.setPlanMode(true);
-            }
-            this.applyStartupPermissionAndPlanToAppState();
-            this.hideSessionPicker();
-          });
+          void this.resumeSession(sessionId)
+            .then(async (switched) => {
+              if (!switched) {
+                return;
+              }
+              if (options.applyStartupModes === true) {
+                await this.applyStartupModesToResumedSession(this.requireSession());
+                this.applyStartupPermissionAndPlanToAppState();
+              }
+              this.hideSessionPicker();
+            })
+            .catch((error) => {
+              this.showError(`Failed to apply startup flags: ${formatErrorMessage(error)}`);
+            });
         },
-        onCancel,
-        onCtrlC: shortcuts.onCtrlC,
-        onCtrlD: shortcuts.onCtrlD,
+        onCancel: options.onCancel,
+        onCtrlC: options.onCtrlC,
+        onCtrlD: options.onCtrlD,
       }),
     );
   }
diff --git a/apps/kimi-code/test/tui/kimi-tui-startup.test.ts b/apps/kimi-code/test/tui/kimi-tui-startup.test.ts
index a46d67466..bed844af8 100644
--- a/apps/kimi-code/test/tui/kimi-tui-startup.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-startup.test.ts
@@ -363,6 +363,33 @@ describe('KimiTUI startup', () => {
     expect(driver.state.appState.planMode).toBe(true);
   });
 
+  it('skips setPlanMode when the resumed session is already in plan mode', async () => {
+    const session = makeSession({
+      id: 'ses-latest',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'manual',
+        planMode: true,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPlanMode: vi.fn(async () => {
+        throw new Error('Already in plan mode');
+      }),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [{ id: 'ses-latest' }]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ continue: true, plan: true }));
+
+    await expect(driver.init()).resolves.toBe(true);
+
+    expect(session.setPlanMode).not.toHaveBeenCalled();
+    expect(driver.state.appState.planMode).toBe(true);
+  });
+
   it('forces footer state to reflect --auto even if getStatus lags behind', async () => {
     const session = makeSession({
       id: 'ses-latest',
@@ -627,6 +654,81 @@ describe('KimiTUI startup', () => {
     expect(driver.state.appState.permissionMode).toBe('auto');
   });
 
+  it('skips setPlanMode after picking a session already in plan mode', async () => {
+    const session = makeSession({
+      id: 'ses-picked',
+      getStatus: vi.fn(async () => ({
+        model: 'k2',
+        thinkingLevel: 'off',
+        permission: 'manual',
+        planMode: true,
+        contextTokens: 10,
+        maxContextTokens: 100,
+        contextUsage: 0.1,
+      })),
+      setPlanMode: vi.fn(async () => {
+        throw new Error('Already in plan mode');
+      }),
+    });
+    const harness = makeHarness(session, {
+      listSessions: vi.fn(async () => [
+        {
+          id: 'ses-picked',
+          title: 'Picked session',
+          workDir: '/tmp/proj-a',
+          updatedAt: Date.now(),
+        },
+      ]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ session: '', plan: true }));
+
+    await (driver as unknown as { initMainTui(): Promise<boolean> }).initMainTui();
+    expect(driver.state.startupState).toBe('picker');
+    await (driver as unknown as { bootstrapFromPicker(): Promise<void> }).bootstrapFromPicker();
+
+    const picker = driver.state.editorContainer.children[0] as { handleInput(data: string): void };
+    picker.handleInput('\r');
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(session.setPlanMode).not.toHaveBeenCalled();
+    expect(driver.state.appState.planMode).toBe(true);
+  });
+
+  it('does not apply startup flags when switching sessions via the /sessions picker', async () => {
+    const initial = makeSession({ id: 'ses-1' });
+    const picked = makeSession({
+      id: 'ses-2',
+      setPermission: vi.fn(async () => {}),
+      setPlanMode: vi.fn(async () => {
+        throw new Error('Already in plan mode');
+      }),
+    });
+    const harness = makeHarness(initial, {
+      resumeSession: vi.fn(async () => picked),
+      listSessions: vi.fn(async () => [
+        {
+          id: 'ses-2',
+          title: 'Other session',
+          workDir: '/tmp/proj-a',
+          updatedAt: Date.now(),
+        },
+      ]),
+    });
+    const driver = makeDriver(harness, makeStartupInput({ auto: true, plan: true }));
+    await expect(driver.init()).resolves.toBe(false);
+
+    await (driver as unknown as { showSessionPicker(): Promise<void> }).showSessionPicker();
+    const picker = driver.state.editorContainer.children[0] as { handleInput(data: string): void };
+    picker.handleInput('\r');
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(driver.state.appState.sessionId).toBe('ses-2');
+    expect(picked.setPermission).not.toHaveBeenCalled();
+    expect(picked.setPlanMode).not.toHaveBeenCalled();
+    expect(driver.state.appState.permissionMode).toBe('manual');
+    expect(driver.state.appState.planMode).toBe(false);
+  });
+
   it('clears startup picker exit confirmation before resuming a selected session', async () => {
     const session = makeSession({ id: 'ses-picked' });
     const harness = makeHarness(session, {

From 1cb49dba5bbc7d015a791ec9699d45df931ead92 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 12 Jun 2026 17:43:06 +0800
Subject: [PATCH 08/17] ci: release packages (#678)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
---
 ...llow-auto-yolo-plan-with-session-resume.md |  5 -----
 .changeset/iterm2-progress-notifications.md   |  5 -----
 .changeset/qualify-sub-skill-names.md         |  6 ------
 .changeset/replay-compaction-records.md       |  6 ------
 .changeset/shell-streaming-output.md          |  6 ------
 ...eplan-on-resume-and-scope-startup-flags.md |  5 -----
 .changeset/sync-registry-providers.md         |  5 -----
 .changeset/tolerate-invalid-config.md         |  7 -------
 apps/kimi-code/CHANGELOG.md                   | 20 +++++++++++++++++++
 apps/kimi-code/package.json                   |  2 +-
 packages/agent-core/CHANGELOG.md              | 12 +++++++++++
 packages/agent-core/package.json              |  2 +-
 packages/node-sdk/CHANGELOG.md                |  6 ++++++
 packages/node-sdk/package.json                |  2 +-
 14 files changed, 41 insertions(+), 48 deletions(-)
 delete mode 100644 .changeset/allow-auto-yolo-plan-with-session-resume.md
 delete mode 100644 .changeset/iterm2-progress-notifications.md
 delete mode 100644 .changeset/qualify-sub-skill-names.md
 delete mode 100644 .changeset/replay-compaction-records.md
 delete mode 100644 .changeset/shell-streaming-output.md
 delete mode 100644 .changeset/skip-replan-on-resume-and-scope-startup-flags.md
 delete mode 100644 .changeset/sync-registry-providers.md
 delete mode 100644 .changeset/tolerate-invalid-config.md

diff --git a/.changeset/allow-auto-yolo-plan-with-session-resume.md b/.changeset/allow-auto-yolo-plan-with-session-resume.md
deleted file mode 100644
index 17ef5eeb0..000000000
--- a/.changeset/allow-auto-yolo-plan-with-session-resume.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@moonshot-ai/kimi-code": patch
----
-
-Allow `--auto`, `--yolo`, and `--plan` to be combined with `--session` or `--continue` by applying the requested mode to the resumed session.
diff --git a/.changeset/iterm2-progress-notifications.md b/.changeset/iterm2-progress-notifications.md
deleted file mode 100644
index 473a415db..000000000
--- a/.changeset/iterm2-progress-notifications.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@moonshot-ai/kimi-code": patch
----
-
-Fix endless desktop notifications in iTerm2 by only sending terminal progress sequences to terminals that support them.
diff --git a/.changeset/qualify-sub-skill-names.md b/.changeset/qualify-sub-skill-names.md
deleted file mode 100644
index a7c4d4700..000000000
--- a/.changeset/qualify-sub-skill-names.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"@moonshot-ai/agent-core": patch
-"@moonshot-ai/kimi-code": patch
----
-
-Qualify sub-skill names with their parent prefix and expose sub-skills as dotted slash commands in the TUI.
diff --git a/.changeset/replay-compaction-records.md b/.changeset/replay-compaction-records.md
deleted file mode 100644
index 3bc6c9de3..000000000
--- a/.changeset/replay-compaction-records.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"@moonshot-ai/agent-core": patch
-"@moonshot-ai/kimi-code": patch
----
-
-Show completed and cancelled compaction records correctly when resuming a session.
diff --git a/.changeset/shell-streaming-output.md b/.changeset/shell-streaming-output.md
deleted file mode 100644
index 5d4fb7ada..000000000
--- a/.changeset/shell-streaming-output.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"@moonshot-ai/agent-core": patch
-"@moonshot-ai/kimi-code": patch
----
-
-Stream foreground Bash stdout and stderr while commands are still running.
diff --git a/.changeset/skip-replan-on-resume-and-scope-startup-flags.md b/.changeset/skip-replan-on-resume-and-scope-startup-flags.md
deleted file mode 100644
index ec7e549e7..000000000
--- a/.changeset/skip-replan-on-resume-and-scope-startup-flags.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@moonshot-ai/kimi-code": patch
----
-
-Skip re-entering plan mode when resuming a session that is already in plan mode (previously failed with "Already in plan mode"), and stop re-applying `--auto`/`--yolo`/`--plan` startup flags when switching sessions through the `/sessions` picker.
diff --git a/.changeset/sync-registry-providers.md b/.changeset/sync-registry-providers.md
deleted file mode 100644
index b0908a7ca..000000000
--- a/.changeset/sync-registry-providers.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@moonshot-ai/kimi-code": patch
----
-
-Sync custom registry provider additions, removals, and rotated registry keys during startup refresh.
diff --git a/.changeset/tolerate-invalid-config.md b/.changeset/tolerate-invalid-config.md
deleted file mode 100644
index 0cae217e9..000000000
--- a/.changeset/tolerate-invalid-config.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@moonshot-ai/agent-core": patch
-"@moonshot-ai/kimi-code-sdk": patch
-"@moonshot-ai/kimi-code": patch
----
-
-Drop invalid config.toml sections with a warning instead of failing to start.
diff --git a/apps/kimi-code/CHANGELOG.md b/apps/kimi-code/CHANGELOG.md
index 29e6a229d..b38fac3a3 100644
--- a/apps/kimi-code/CHANGELOG.md
+++ b/apps/kimi-code/CHANGELOG.md
@@ -1,5 +1,25 @@
 # @moonshot-ai/kimi-code
 
+## 0.14.2
+
+### Patch Changes
+
+- [#683](https://github.com/MoonshotAI/kimi-code/pull/683) [`ad239cb`](https://github.com/MoonshotAI/kimi-code/commit/ad239cb1c08266a442c9ca0382fefed87bcb1fd4) - Allow `--auto`, `--yolo`, and `--plan` to be combined with `--session` or `--continue` by applying the requested mode to the resumed session.
+
+- [#690](https://github.com/MoonshotAI/kimi-code/pull/690) [`7f0dde2`](https://github.com/MoonshotAI/kimi-code/commit/7f0dde2ece3f9a004e934d69258dfd47c954043c) - Fix endless desktop notifications in iTerm2 by only sending terminal progress sequences to terminals that support them.
+
+- [#651](https://github.com/MoonshotAI/kimi-code/pull/651) [`c39c625`](https://github.com/MoonshotAI/kimi-code/commit/c39c62590db708fc81bd8627ea661c38f3fff9af) - Qualify sub-skill names with their parent prefix and expose sub-skills as dotted slash commands in the TUI.
+
+- [#617](https://github.com/MoonshotAI/kimi-code/pull/617) [`911e7c3`](https://github.com/MoonshotAI/kimi-code/commit/911e7c3fcfc8a005b1b8d90388260d1a4032f76f) - Show completed and cancelled compaction records correctly when resuming a session.
+
+- [#676](https://github.com/MoonshotAI/kimi-code/pull/676) [`dcf3075`](https://github.com/MoonshotAI/kimi-code/commit/dcf30754d09c7560101bc410387792194c3fe2b4) - Stream foreground Bash stdout and stderr while commands are still running.
+
+- [#692](https://github.com/MoonshotAI/kimi-code/pull/692) [`7ca9bdf`](https://github.com/MoonshotAI/kimi-code/commit/7ca9bdfed516d148b063229a9686a28f9e29aaef) - Skip re-entering plan mode when resuming a session that is already in plan mode (previously failed with "Already in plan mode"), and stop re-applying `--auto`/`--yolo`/`--plan` startup flags when switching sessions through the `/sessions` picker.
+
+- [#675](https://github.com/MoonshotAI/kimi-code/pull/675) [`d1ba145`](https://github.com/MoonshotAI/kimi-code/commit/d1ba14562bafdb6b93c3eec1b5c453186507ed56) - Sync custom registry provider additions, removals, and rotated registry keys during startup refresh.
+
+- [#689](https://github.com/MoonshotAI/kimi-code/pull/689) [`8d251f8`](https://github.com/MoonshotAI/kimi-code/commit/8d251f8ab44ead65f6c1bb264980ee7d075142ad) - Drop invalid config.toml sections with a warning instead of failing to start.
+
 ## 0.14.1
 
 ### Patch Changes
diff --git a/apps/kimi-code/package.json b/apps/kimi-code/package.json
index ff223543a..2c7289645 100644
--- a/apps/kimi-code/package.json
+++ b/apps/kimi-code/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/kimi-code",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "The Starting Point for Next-Gen Agents",
   "license": "MIT",
   "author": "Moonshot AI",
diff --git a/packages/agent-core/CHANGELOG.md b/packages/agent-core/CHANGELOG.md
index 062eee985..94b25f66a 100644
--- a/packages/agent-core/CHANGELOG.md
+++ b/packages/agent-core/CHANGELOG.md
@@ -1,5 +1,17 @@
 # @moonshot-ai/agent-core
 
+## 0.12.3
+
+### Patch Changes
+
+- [#651](https://github.com/MoonshotAI/kimi-code/pull/651) [`c39c625`](https://github.com/MoonshotAI/kimi-code/commit/c39c62590db708fc81bd8627ea661c38f3fff9af) - Qualify sub-skill names with their parent prefix and expose sub-skills as dotted slash commands in the TUI.
+
+- [#617](https://github.com/MoonshotAI/kimi-code/pull/617) [`911e7c3`](https://github.com/MoonshotAI/kimi-code/commit/911e7c3fcfc8a005b1b8d90388260d1a4032f76f) - Show completed and cancelled compaction records correctly when resuming a session.
+
+- [#676](https://github.com/MoonshotAI/kimi-code/pull/676) [`dcf3075`](https://github.com/MoonshotAI/kimi-code/commit/dcf30754d09c7560101bc410387792194c3fe2b4) - Stream foreground Bash stdout and stderr while commands are still running.
+
+- [#689](https://github.com/MoonshotAI/kimi-code/pull/689) [`8d251f8`](https://github.com/MoonshotAI/kimi-code/commit/8d251f8ab44ead65f6c1bb264980ee7d075142ad) - Drop invalid config.toml sections with a warning instead of failing to start.
+
 ## 0.12.2
 
 ### Patch Changes
diff --git a/packages/agent-core/package.json b/packages/agent-core/package.json
index c88a79bc4..54e0b12f3 100644
--- a/packages/agent-core/package.json
+++ b/packages/agent-core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/agent-core",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "private": true,
   "description": "The unified agent engine for Kimi",
   "license": "MIT",
diff --git a/packages/node-sdk/CHANGELOG.md b/packages/node-sdk/CHANGELOG.md
index 3bee845bb..32a65d0f3 100644
--- a/packages/node-sdk/CHANGELOG.md
+++ b/packages/node-sdk/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @moonshot-ai/kimi-code-sdk
 
+## 0.9.3
+
+### Patch Changes
+
+- [#689](https://github.com/MoonshotAI/kimi-code/pull/689) [`8d251f8`](https://github.com/MoonshotAI/kimi-code/commit/8d251f8ab44ead65f6c1bb264980ee7d075142ad) - Drop invalid config.toml sections with a warning instead of failing to start.
+
 ## 0.9.2
 
 ### Patch Changes
diff --git a/packages/node-sdk/package.json b/packages/node-sdk/package.json
index 81ff4ab87..1d83cf528 100644
--- a/packages/node-sdk/package.json
+++ b/packages/node-sdk/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/kimi-code-sdk",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "private": true,
   "description": "TypeScript SDK for the Kimi Code Agent",
   "license": "MIT",

From 1c65cbf6c3589bac07c12da546cae3669a28bfb0 Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Fri, 12 Jun 2026 21:42:51 +0800
Subject: [PATCH 09/17] docs(changelog): sync 0.14.2 from
 apps/kimi-code/CHANGELOG.md (#698)

---
 docs/en/release-notes/changelog.md | 15 +++++++++++++++
 docs/zh/release-notes/changelog.md | 15 +++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/docs/en/release-notes/changelog.md b/docs/en/release-notes/changelog.md
index 30c358284..e18a2ee08 100644
--- a/docs/en/release-notes/changelog.md
+++ b/docs/en/release-notes/changelog.md
@@ -6,6 +6,21 @@ outline: 2
 
 This page documents the changes in each Kimi Code CLI release.
 
+## 0.14.2 (2026-06-12)
+
+### Bug Fixes
+
+- Fix endless desktop notifications in iTerm2 by only sending terminal progress sequences to terminals that support them.
+- Show completed and cancelled compaction records correctly when resuming a session.
+- Drop invalid config.toml sections with a warning instead of failing to start.
+
+### Polish
+
+- Stream foreground Bash stdout and stderr while commands are still running.
+- Allow `--auto`, `--yolo`, and `--plan` to be combined with `--session` or `--continue` by applying the requested mode to the resumed session.
+- Qualify sub-skill names with their parent prefix and expose sub-skills as dotted slash commands in the TUI.
+- Sync custom registry provider additions, removals, and rotated registry keys during startup refresh.
+
 ## 0.14.1 (2026-06-12)
 
 ### Bug Fixes
diff --git a/docs/zh/release-notes/changelog.md b/docs/zh/release-notes/changelog.md
index 01b4826ce..a1e8029b7 100644
--- a/docs/zh/release-notes/changelog.md
+++ b/docs/zh/release-notes/changelog.md
@@ -6,6 +6,21 @@ outline: 2
 
 本页记录 Kimi Code CLI 每个版本的变更内容。
 
+## 0.14.2（2026-06-12）
+
+### 修复
+
+- 修复 iTerm2 中无休止的桌面通知问题，仅向支持进度序列的终端发送终端进度序列。
+- 在恢复会话时正确显示已完成和已取消的压缩记录。
+- 丢弃无效的 `config.toml` 配置节并发出警告，而不是启动失败。
+
+### 优化
+
+- 在命令仍在运行时流式输出前台 Bash 的 stdout 和 stderr。
+- 允许 `--auto`、`--yolo` 和 `--plan` 与 `--session` 或 `--continue` 组合使用，将请求的模式应用到恢复的会话。
+- 为子 Skill 名称添加父前缀，并在 TUI 中将子 Skill 暴露为点状斜杠命令。
+- 在启动刷新期间同步自定义 registry provider 的新增、移除和轮换的 registry key。
+
 ## 0.14.1（2026-06-12）
 
 ### 修复

From f874251288927243a9b9d4bfd546e8c17754d566 Mon Sep 17 00:00:00 2001
From: Haozhe <yanghaozhe@moonshot.ai>
Date: Sat, 13 Jun 2026 20:55:35 +0800
Subject: [PATCH 10/17] feat(kimi-code): refresh OAuth provider models before
 opening model picker (#713)

- call refreshOAuthProviderModels before /model picker opens
- add scoped refreshAllProviderModels with 'oauth' and 'all' scopes
- update tests for async picker rendering and OAuth-only refresh
---
 .changeset/refresh-model-picker-oauth.md      |   5 +
 apps/kimi-code/src/tui/commands/config.ts     |  36 +++++-
 apps/kimi-code/src/tui/commands/dispatch.ts   |   2 +-
 .../src/tui/controllers/auth-flow.ts          |  44 ++++----
 .../src/tui/utils/refresh-providers.ts        |  16 ++-
 .../test/tui/kimi-tui-message-flow.test.ts    | 103 +++++++++++++++++-
 .../test/tui/utils/refresh-providers.test.ts  |  86 +++++++++++++++
 7 files changed, 268 insertions(+), 24 deletions(-)
 create mode 100644 .changeset/refresh-model-picker-oauth.md

diff --git a/.changeset/refresh-model-picker-oauth.md b/.changeset/refresh-model-picker-oauth.md
new file mode 100644
index 000000000..fd8034a3d
--- /dev/null
+++ b/.changeset/refresh-model-picker-oauth.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Refresh provider model metadata before opening the model picker.
diff --git a/apps/kimi-code/src/tui/commands/config.ts b/apps/kimi-code/src/tui/commands/config.ts
index d95c02e35..9b91d4ba0 100644
--- a/apps/kimi-code/src/tui/commands/config.ts
+++ b/apps/kimi-code/src/tui/commands/config.ts
@@ -28,6 +28,8 @@ import type { SlashCommandHost } from './dispatch';
 // Plan / Config commands
 // ---------------------------------------------------------------------------
 
+const MODEL_PICKER_REFRESH_TIMEOUT_MS = 2_000;
+
 export async function handlePlanCommand(host: SlashCommandHost, args: string): Promise<void> {
   const session = host.session;
   if (session === undefined) {
@@ -196,8 +198,9 @@ export async function handleThemeCommand(host: SlashCommandHost, args: string):
   await applyThemeChoice(host, theme);
 }
 
-export function handleModelCommand(host: SlashCommandHost, args: string): void {
+export async function handleModelCommand(host: SlashCommandHost, args: string): Promise<void> {
   const alias = args.trim();
+  await refreshModelsForPicker(host);
   if (alias.length === 0) {
     showModelPicker(host);
     return;
@@ -229,6 +232,37 @@ function showEditorPicker(host: SlashCommandHost): void {
   );
 }
 
+async function refreshModelsForPicker(host: SlashCommandHost): Promise<void> {
+  try {
+    const result = await withTimeout(
+      host.authFlow.refreshOAuthProviderModels(),
+      MODEL_PICKER_REFRESH_TIMEOUT_MS,
+    );
+    if (result === undefined) return;
+    for (const f of result.failed) {
+      host.showStatus(`Skipped refreshing ${f.provider}: ${f.reason}`, 'warning');
+    }
+  } catch (error) {
+    host.showStatus(`Skipped refreshing models: ${formatErrorMessage(error)}`, 'warning');
+  }
+}
+
+async function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | undefined> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<undefined>((resolve) => {
+        timeout = setTimeout(() => {
+          resolve(undefined);
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
+  }
+}
+
 async function applyEditorChoice(host: SlashCommandHost, value: string): Promise<void> {
   const previous = host.state.appState.editorCommand ?? '';
   if (value === previous && value.length > 0) {
diff --git a/apps/kimi-code/src/tui/commands/dispatch.ts b/apps/kimi-code/src/tui/commands/dispatch.ts
index 397404e0f..ed67da39c 100644
--- a/apps/kimi-code/src/tui/commands/dispatch.ts
+++ b/apps/kimi-code/src/tui/commands/dispatch.ts
@@ -273,7 +273,7 @@ async function handleBuiltInSlashCommand(
       await handleThemeCommand(host, args);
       return;
     case 'model':
-      handleModelCommand(host, args);
+      await handleModelCommand(host, args);
       return;
     case 'provider':
       await handleProviderCommand(host);
diff --git a/apps/kimi-code/src/tui/controllers/auth-flow.ts b/apps/kimi-code/src/tui/controllers/auth-flow.ts
index 39af925fb..b0d1cc22d 100644
--- a/apps/kimi-code/src/tui/controllers/auth-flow.ts
+++ b/apps/kimi-code/src/tui/controllers/auth-flow.ts
@@ -2,7 +2,11 @@ import type { KimiHarness, Session } from '@moonshot-ai/kimi-code-sdk';
 import type { SkillListSession } from '../commands';
 
 import { OAUTH_LOGIN_REQUIRED_STARTUP_NOTICE } from '../constant/kimi-tui';
-import { refreshAllProviderModels } from '../utils/refresh-providers';
+import {
+  refreshAllProviderModels,
+  type RefreshProviderScope,
+  type RefreshResult,
+} from '../utils/refresh-providers';
 import type { SessionEventHandler } from './session-event-handler';
 import type { AppState, KimiTUIOptions } from '../types';
 import type { TUIState } from '../tui-state';
@@ -142,26 +146,28 @@ export class AuthFlowController {
    * config.  Runs best-effort: individual provider failures are collected
    * and returned instead of thrown.
    */
-  async refreshProviderModels(): Promise<{
-    readonly changed: ReadonlyArray<{
-      readonly providerId: string;
-      readonly providerName: string;
-      readonly added: number;
-      readonly removed: number;
-    }>;
-    readonly unchanged: readonly string[];
-    readonly failed: ReadonlyArray<{ readonly provider: string; readonly reason: string }>;
-  }> {
+  async refreshProviderModels(): Promise<RefreshResult> {
+    return this.refreshProviderModelsWithScope('all');
+  }
+
+  async refreshOAuthProviderModels(): Promise<RefreshResult> {
+    return this.refreshProviderModelsWithScope('oauth');
+  }
+
+  private async refreshProviderModelsWithScope(scope: RefreshProviderScope): Promise<RefreshResult> {
     const { host } = this;
-    const result = await refreshAllProviderModels({
-      getConfig: () => host.harness.getConfig({ reload: true }),
-      removeProvider: (id) => host.harness.removeProvider(id),
-      setConfig: (patch) => host.harness.setConfig(patch),
-      resolveOAuthToken: async (providerName, oauthRef) => {
-        const tokenProvider = host.harness.auth.resolveOAuthTokenProvider(providerName, oauthRef);
-        return tokenProvider.getAccessToken();
+    const result = await refreshAllProviderModels(
+      {
+        getConfig: () => host.harness.getConfig({ reload: true }),
+        removeProvider: (id) => host.harness.removeProvider(id),
+        setConfig: (patch) => host.harness.setConfig(patch),
+        resolveOAuthToken: async (providerName, oauthRef) => {
+          const tokenProvider = host.harness.auth.resolveOAuthTokenProvider(providerName, oauthRef);
+          return tokenProvider.getAccessToken();
+        },
       },
-    });
+      { scope },
+    );
     if (result.changed.length > 0) {
       await this.refreshAvailableModels();
     }
diff --git a/apps/kimi-code/src/tui/utils/refresh-providers.ts b/apps/kimi-code/src/tui/utils/refresh-providers.ts
index bdda7aa40..a25c4b7cf 100644
--- a/apps/kimi-code/src/tui/utils/refresh-providers.ts
+++ b/apps/kimi-code/src/tui/utils/refresh-providers.ts
@@ -40,6 +40,12 @@ export interface RefreshResult {
   readonly failed: ReadonlyArray<{ readonly provider: string; readonly reason: string }>;
 }
 
+export type RefreshProviderScope = 'all' | 'oauth';
+
+export interface RefreshProviderOptions {
+  readonly scope?: RefreshProviderScope;
+}
+
 function readCustomRegistrySource(provider: ProviderConfig): CustomRegistrySource | undefined {
   const source = provider.source;
   if (typeof source !== 'object' || source === null) return undefined;
@@ -264,10 +270,14 @@ function pickDefaultModel(config: KimiConfig, providerId: string, models: Array<
   return firstModel.id;
 }
 
-export async function refreshAllProviderModels(host: RefreshProviderHost): Promise<RefreshResult> {
+export async function refreshAllProviderModels(
+  host: RefreshProviderHost,
+  options: RefreshProviderOptions = {},
+): Promise<RefreshResult> {
   const changed: ProviderChange[] = [];
   const unchanged: string[] = [];
   const failed: Array<{ provider: string; reason: string }> = [];
+  const scope = options.scope ?? 'all';
 
   let config = await host.getConfig();
 
@@ -343,6 +353,10 @@ export async function refreshAllProviderModels(host: RefreshProviderHost): Promi
     }
   }
 
+  if (scope === 'oauth') {
+    return { changed, unchanged, failed };
+  }
+
   // -------------------------------------------------------------------------
   // 2. Open Platforms (moonshot-cn, moonshot-ai, …)
   // -------------------------------------------------------------------------
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index d069dd112..3868f8fd2 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -3362,8 +3362,10 @@ command = "vim"
 
     driver.handleUserInput('/model turbo');
 
+    await vi.waitFor(() => {
+      expect(driver.state.editorContainer.children[0]).toBeInstanceOf(TabbedModelSelectorComponent);
+    });
     const picker = driver.state.editorContainer.children[0];
-    expect(picker).toBeInstanceOf(TabbedModelSelectorComponent);
     const pickerOutput = stripSgr((picker as TabbedModelSelectorComponent).render(120).join('\n'));
     expect(pickerOutput).toMatch(/Kimi K2\s+Kimi Code ← current/);
     expect(pickerOutput).toMatch(/❯ Kimi Turbo\s+Kimi Code/);
@@ -3411,8 +3413,10 @@ command = "vim"
 
     driver.handleUserInput('/model k2');
 
+    await vi.waitFor(() => {
+      expect(driver.state.editorContainer.children[0]).toBeInstanceOf(TabbedModelSelectorComponent);
+    });
     const picker = driver.state.editorContainer.children[0];
-    expect(picker).toBeInstanceOf(TabbedModelSelectorComponent);
     (picker as TabbedModelSelectorComponent).handleInput('\r');
 
     await vi.waitFor(() => {
@@ -3425,6 +3429,101 @@ command = "vim"
     expect(session.setThinking).not.toHaveBeenCalled();
   });
 
+  it('refreshes only OAuth provider models before opening /model picker', async () => {
+    const { driver } = await makeDriver(makeSession(), {
+      getConfig: vi.fn(async () => ({
+        models: {
+          k2: {
+            provider: 'managed:kimi-code',
+            model: 'kimi-k2',
+            maxContextSize: 100,
+            displayName: 'Old Kimi K2',
+            capabilities: ['thinking'],
+          },
+        },
+      })),
+    });
+    const tui = driver as unknown as KimiTUI;
+    const refreshProviderModels = vi
+      .spyOn(tui.authFlow, 'refreshProviderModels')
+      .mockRejectedValue(new Error('full provider refresh should not run'));
+    const refreshOAuthProviderModels = vi.fn(async () => {
+      await Promise.resolve();
+      tui.setAppState({
+        availableModels: {
+          k2: {
+            provider: 'managed:kimi-code',
+            model: 'kimi-k2',
+            maxContextSize: 100,
+            displayName: 'Fresh Kimi K2',
+            capabilities: ['thinking'],
+          },
+        },
+      });
+      return { changed: [], unchanged: ['managed:kimi-code'], failed: [] };
+    });
+    (
+      tui.authFlow as unknown as {
+        refreshOAuthProviderModels: typeof refreshOAuthProviderModels;
+      }
+    ).refreshOAuthProviderModels = refreshOAuthProviderModels;
+
+    driver.handleUserInput('/model');
+
+    await vi.waitFor(() => {
+      const picker = driver.state.editorContainer.children[0];
+      expect(picker).toBeInstanceOf(TabbedModelSelectorComponent);
+      const output = stripSgr((picker as TabbedModelSelectorComponent).render(120).join('\n'));
+      expect(output).toContain('Fresh Kimi K2');
+      expect(output).not.toContain('Old Kimi K2');
+    });
+    expect(refreshOAuthProviderModels).toHaveBeenCalledOnce();
+    expect(refreshProviderModels).not.toHaveBeenCalled();
+  });
+
+  it('opens /model picker after 2s when OAuth refresh is still pending', async () => {
+    const { driver } = await makeDriver(makeSession(), {
+      getConfig: vi.fn(async () => ({
+        models: {
+          k2: {
+            provider: 'managed:kimi-code',
+            model: 'kimi-k2',
+            maxContextSize: 100,
+            displayName: 'Kimi K2',
+            capabilities: ['thinking'],
+          },
+        },
+      })),
+    });
+    const tui = driver as unknown as KimiTUI;
+    const refreshOAuthProviderModels = vi.fn(() => new Promise<never>(() => {}));
+    (
+      tui.authFlow as unknown as {
+        refreshOAuthProviderModels: typeof refreshOAuthProviderModels;
+      }
+    ).refreshOAuthProviderModels = refreshOAuthProviderModels;
+
+    vi.useFakeTimers();
+    try {
+      driver.handleUserInput('/model');
+      await Promise.resolve();
+
+      expect(refreshOAuthProviderModels).toHaveBeenCalledOnce();
+      expect(driver.state.editorContainer.children[0]).not.toBeInstanceOf(TabbedModelSelectorComponent);
+
+      await vi.advanceTimersByTimeAsync(1_999);
+      expect(driver.state.editorContainer.children[0]).not.toBeInstanceOf(TabbedModelSelectorComponent);
+
+      await vi.advanceTimersByTimeAsync(1);
+      const picker = driver.state.editorContainer.children[0];
+      expect(picker).toBeInstanceOf(TabbedModelSelectorComponent);
+      const output = stripSgr((picker as TabbedModelSelectorComponent).render(120).join('\n'));
+      expect(output).toContain('Kimi K2');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it('enables search in the shared model selector helper', async () => {
     const { driver } = await makeDriver();
     const selection = runModelSelector(driver as any, {
diff --git a/apps/kimi-code/test/tui/utils/refresh-providers.test.ts b/apps/kimi-code/test/tui/utils/refresh-providers.test.ts
index 17749a61a..aadb8e764 100644
--- a/apps/kimi-code/test/tui/utils/refresh-providers.test.ts
+++ b/apps/kimi-code/test/tui/utils/refresh-providers.test.ts
@@ -126,6 +126,92 @@ describe('refreshAllProviderModels', () => {
     expect(resolveOAuthToken).toHaveBeenCalledWith(KIMI_CODE_PROVIDER_NAME, envOauthRef);
   });
 
+  it('can refresh only the managed OAuth provider without fetching third-party registries', async () => {
+    const baseUrl = 'https://api.example.test/coding/v1';
+    const registryUrl = 'https://registry.example.test/v1/models/api.json';
+    const config: KimiConfig = {
+      providers: {
+        [KIMI_CODE_PROVIDER_NAME]: {
+          type: 'kimi',
+          baseUrl,
+          apiKey: '',
+          oauth: {
+            storage: 'file',
+            key: resolveKimiCodeOAuthKey({ baseUrl }),
+          },
+        },
+        custom: {
+          type: 'openai',
+          baseUrl: 'https://custom.example.test/v1',
+          apiKey: 'sk-test-token',
+          source: { kind: 'apiJson', url: registryUrl, apiKey: 'sk-test-token' },
+        },
+      },
+      models: {
+        'kimi-code/kimi-for-coding': {
+          provider: KIMI_CODE_PROVIDER_NAME,
+          model: 'kimi-for-coding',
+          maxContextSize: 262144,
+          capabilities: ['thinking', 'tool_use'],
+          displayName: 'Old Kimi',
+        },
+        'custom/m1': {
+          provider: 'custom',
+          model: 'm1',
+          maxContextSize: 131072,
+          capabilities: ['tool_use'],
+          displayName: 'Custom M1',
+        },
+      },
+      defaultModel: 'kimi-code/kimi-for-coding',
+      telemetry: true,
+    };
+    const host = makeRefreshHost(config);
+    const resolveOAuthToken = vi.fn(async () => 'oauth-access-token');
+    const fetchMock = vi.fn<FetchMock>(async (input, init) => {
+      expect(fetchInputUrl(input)).toBe(`${baseUrl}/models`);
+      expect(new Headers(init?.headers).get('authorization')).toBe('Bearer oauth-access-token');
+      return new Response(
+        JSON.stringify({
+          data: [
+            {
+              id: 'kimi-for-coding',
+              context_length: 262144,
+              supports_reasoning: true,
+              display_name: 'Fresh Kimi',
+            },
+          ],
+        }),
+        { status: 200, headers: { 'Content-Type': 'application/json' } },
+      );
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await refreshAllProviderModels(
+      {
+        getConfig: async () => host.current(),
+        removeProvider: host.removeProvider,
+        setConfig: host.setConfig,
+        resolveOAuthToken,
+      },
+      { scope: 'oauth' },
+    );
+
+    expect(result.failed).toEqual([]);
+    expect(result.changed).toEqual([
+      {
+        providerId: KIMI_CODE_PROVIDER_NAME,
+        providerName: 'Kimi Code',
+        added: 0,
+        removed: 0,
+      },
+    ]);
+    expect(result.unchanged).toEqual([]);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(host.current().models?.['kimi-code/kimi-for-coding']?.displayName).toBe('Fresh Kimi');
+    expect(host.current().models?.['custom/m1']?.displayName).toBe('Custom M1');
+  });
+
   it('refreshes custom-registry model capabilities even when model ids are unchanged', async () => {
     const registryUrl = 'https://registry.example.test/v1/models/api.json';
     const providerId = 'example_chat-completions';

From 93928066dc308052de8c4a48e9c10b2f3dba361b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 14 Jun 2026 09:12:54 +0800
Subject: [PATCH 11/17] ci: release packages (#717)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
---
 .changeset/refresh-model-picker-oauth.md | 5 -----
 apps/kimi-code/CHANGELOG.md              | 6 ++++++
 apps/kimi-code/package.json              | 2 +-
 3 files changed, 7 insertions(+), 6 deletions(-)
 delete mode 100644 .changeset/refresh-model-picker-oauth.md

diff --git a/.changeset/refresh-model-picker-oauth.md b/.changeset/refresh-model-picker-oauth.md
deleted file mode 100644
index fd8034a3d..000000000
--- a/.changeset/refresh-model-picker-oauth.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@moonshot-ai/kimi-code": patch
----
-
-Refresh provider model metadata before opening the model picker.
diff --git a/apps/kimi-code/CHANGELOG.md b/apps/kimi-code/CHANGELOG.md
index b38fac3a3..b292b7096 100644
--- a/apps/kimi-code/CHANGELOG.md
+++ b/apps/kimi-code/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @moonshot-ai/kimi-code
 
+## 0.14.3
+
+### Patch Changes
+
+- [#713](https://github.com/MoonshotAI/kimi-code/pull/713) [`f874251`](https://github.com/MoonshotAI/kimi-code/commit/f874251288927243a9b9d4bfd546e8c17754d566) - Refresh provider model metadata before opening the model picker.
+
 ## 0.14.2
 
 ### Patch Changes
diff --git a/apps/kimi-code/package.json b/apps/kimi-code/package.json
index 2c7289645..4941f1c31 100644
--- a/apps/kimi-code/package.json
+++ b/apps/kimi-code/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/kimi-code",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "The Starting Point for Next-Gen Agents",
   "license": "MIT",
   "author": "Moonshot AI",

From 18f299fd0b266545a1f7cebae9f58b83b9d9776e Mon Sep 17 00:00:00 2001
From: oocz <37055139+oocz@users.noreply.github.com>
Date: Sun, 14 Jun 2026 18:04:26 +0800
Subject: [PATCH 12/17] mcp suport sse (#744)

Co-authored-by: yuchengzhen <yuchengzhen@moonshot.cn>
---
 .changeset/sse-mcp-servers.md                 |   8 +
 .../components/dialogs/plugins-selector.ts    |   4 +-
 .../test/tui/kimi-tui-message-flow.test.ts    |   2 +-
 docs/en/customization/mcp.md                  |  24 ++-
 docs/en/guides/ides.md                        |   2 +-
 docs/en/reference/kimi-acp.md                 |   5 +-
 docs/zh/customization/mcp.md                  |  24 ++-
 docs/zh/guides/ides.md                        |   2 +-
 docs/zh/reference/kimi-acp.md                 |   5 +-
 packages/acp-adapter/src/mcp.ts               |  14 +-
 packages/acp-adapter/src/server.ts            |   4 +-
 .../acp-adapter/test/e2e-happy-path.test.ts   |   4 +-
 packages/acp-adapter/test/mcp-forward.test.ts |  25 ++-
 packages/acp-adapter/test/server.test.ts      |   2 +-
 packages/agent-core/src/agent/tool/index.ts   |   4 +-
 packages/agent-core/src/config/schema.ts      |  15 ++
 packages/agent-core/src/mcp/auth-tool.ts      |   2 +-
 packages/agent-core/src/mcp/client-http.ts    |  20 +--
 packages/agent-core/src/mcp/client-remote.ts  |  32 ++++
 packages/agent-core/src/mcp/client-sse.ts     | 169 ++++++++++++++++++
 .../agent-core/src/mcp/connection-manager.ts  |  35 +++-
 packages/agent-core/src/plugin/manager.ts     |   6 +-
 packages/agent-core/src/plugin/manifest.ts    |   2 +-
 packages/agent-core/src/plugin/types.ts       |   2 +-
 packages/agent-core/src/rpc/core-api.ts       |   2 +-
 .../agent-core/test/mcp/client-sse.test.ts    | 142 +++++++++++++++
 .../agent-core/test/mcp/config-loader.test.ts |  24 ++-
 .../test/mcp/connection-manager.test.ts       |  60 +++++++
 .../agent-core/test/plugin/manager.test.ts    |  21 ++-
 .../agent-core/test/plugin/manifest.test.ts   |  10 ++
 packages/protocol/src/events.ts               |   2 +-
 31 files changed, 587 insertions(+), 86 deletions(-)
 create mode 100644 .changeset/sse-mcp-servers.md
 create mode 100644 packages/agent-core/src/mcp/client-remote.ts
 create mode 100644 packages/agent-core/src/mcp/client-sse.ts
 create mode 100644 packages/agent-core/test/mcp/client-sse.test.ts

diff --git a/.changeset/sse-mcp-servers.md b/.changeset/sse-mcp-servers.md
new file mode 100644
index 000000000..b5dce2f66
--- /dev/null
+++ b/.changeset/sse-mcp-servers.md
@@ -0,0 +1,8 @@
+---
+"@moonshot-ai/agent-core": minor
+"@moonshot-ai/acp-adapter": minor
+"@moonshot-ai/protocol": minor
+"@moonshot-ai/kimi-code": minor
+---
+
+Add support for legacy SSE MCP servers alongside stdio and streamable HTTP transports.
diff --git a/apps/kimi-code/src/tui/components/dialogs/plugins-selector.ts b/apps/kimi-code/src/tui/components/dialogs/plugins-selector.ts
index 3a4cce8d1..d2bcc8620 100644
--- a/apps/kimi-code/src/tui/components/dialogs/plugins-selector.ts
+++ b/apps/kimi-code/src/tui/components/dialogs/plugins-selector.ts
@@ -539,8 +539,8 @@ function buildMcpItems(info: PluginInfo): PluginsOverviewItem[] {
 
 function mcpServerDescription(server: PluginMcpServerInfo): string {
   const action = server.enabled ? 'Enter/Space disable' : 'Enter/Space enable';
-  if (server.transport === 'http') {
-    return `${action} · HTTP · ${server.url ?? server.runtimeName}`;
+  if (server.transport === 'http' || server.transport === 'sse') {
+    return `${action} · ${server.transport.toUpperCase()} · ${server.url ?? server.runtimeName}`;
   }
   const args = server.args !== undefined && server.args.length > 0 ? ` ${server.args.join(' ')}` : '';
   const command = `${server.command ?? ''}${args}`.trim();
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 3868f8fd2..2906e2f2f 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -742,7 +742,7 @@ command = "vim"
     let resolveSnapshot: (
       servers: Array<{
         name: string;
-        transport: 'stdio' | 'http';
+        transport: 'stdio' | 'http' | 'sse';
         status: 'pending' | 'connected' | 'failed' | 'disabled';
         toolCount: number;
         error?: string;
diff --git a/docs/en/customization/mcp.md b/docs/en/customization/mcp.md
index 9df67d746..dfad6acd6 100644
--- a/docs/en/customization/mcp.md
+++ b/docs/en/customization/mcp.md
@@ -4,10 +4,11 @@
 
 ## Connection Methods
 
-Kimi Code CLI supports two MCP server connection methods:
+Kimi Code CLI supports three MCP server connection methods:
 
 - **stdio**: The CLI starts the local MCP server as a child process and communicates via standard input/output. Suitable for local command-line tools.
 - **HTTP**: The CLI connects to an already-running HTTP endpoint. Suitable for remote services or processes that need to run persistently.
+- **SSE**: The CLI connects to a legacy HTTP+SSE endpoint (Server-Sent Events, a streaming HTTP mechanism). Prefer HTTP for new MCP servers, but use `transport: "sse"` when a service still exposes only the older SSE transport.
 
 ## Configuration
 
@@ -31,12 +32,16 @@ Structure of `mcp.json`:
     },
     "linear": {
       "url": "https://mcp.linear.app/mcp"
+    },
+    "legacy-events": {
+      "transport": "sse",
+      "url": "https://mcp.example.com/sse"
     }
   }
 }
 ```
 
-Entries with a `command` field are stdio servers; entries with a `url` field are HTTP servers. The `transport` field generally does not need to be written manually.
+Entries with a `command` field are stdio servers; entries with a `url` field and no `transport` are HTTP servers. For legacy SSE servers, set `transport` to `"sse"` explicitly.
 
 Optional fields:
 
@@ -44,14 +49,15 @@ Optional fields:
 | --- | --- | --- | --- |
 | `env` | `Record<string, string>` | stdio | Environment variables injected into the child process |
 | `cwd` | `string` | stdio | Working directory for the child process |
-| `headers` | `Record<string, string>` | HTTP | Static request headers appended to every request |
-| `enabled` | `boolean` | Both | Set to `false` to disable this server |
-| `startupTimeoutMs` | `number` | Both | Connection timeout; default `30000` milliseconds |
-| `toolTimeoutMs` | `number` | Both | Timeout for a single tool call |
-| `enabledTools` | `string[]` | Both | Tool allowlist |
-| `disabledTools` | `string[]` | Both | Tool blocklist |
+| `headers` | `Record<string, string>` | HTTP, SSE | Static request headers appended to every request |
+| `bearerTokenEnvVar` | `string` | HTTP, SSE | Name of an environment variable that contains a bearer token |
+| `enabled` | `boolean` | All | Set to `false` to disable this server |
+| `startupTimeoutMs` | `number` | All | Connection timeout; default `30000` milliseconds |
+| `toolTimeoutMs` | `number` | All | Timeout for a single tool call |
+| `enabledTools` | `string[]` | All | Tool allowlist |
+| `disabledTools` | `string[]` | All | Tool blocklist |
 
-HTTP servers support providing static credentials via `headers` or `bearerTokenEnvVar`. When OAuth is needed, run `/mcp-config login <server-name>` to complete browser-based authorization.
+HTTP and SSE servers support providing static credentials via `headers` or `bearerTokenEnvVar`. When OAuth is needed, run `/mcp-config login <server-name>` to complete browser-based authorization.
 
 Plugins can also declare MCP servers in their manifest. Servers declared by a plugin are enabled by default and can be disabled or re-enabled in `/plugins`, then a new session must be started. See [Plugins](./plugins.md) for details.
 
diff --git a/docs/en/guides/ides.md b/docs/en/guides/ides.md
index 9899745c1..f275af8ac 100644
--- a/docs/en/guides/ides.md
+++ b/docs/en/guides/ides.md
@@ -88,7 +88,7 @@ Paseo's generic ACP adapter does not drive the login flow, so complete the termi
 
 - **Session disconnects immediately / IDE shows "agent exited"**: usually a wrong `command` path or a missing login. Run `kimi acp` in a terminal first to verify — if it blocks waiting for stdin, the CLI itself is fine and the problem is in the IDE configuration; if it exits immediately with an error, follow the error message (most commonly you need to run `/login`).
 - **IDE shows "auth required"**: the CLI has no usable authentication token. Exit the IDE, run `kimi` in a terminal to complete login, then restart the IDE.
-- **MCP tools not visible**: check the [`kimi acp` reference](../reference/kimi-acp.md) capability table to confirm that the MCP transport type configured in your IDE is supported. The Kimi Code CLI ACP adapter currently supports `http` and `stdio` transports; `sse` and `acp` types are silently dropped and a warning is written to the log.
+- **MCP tools not visible**: check the [`kimi acp` reference](../reference/kimi-acp.md) capability table to confirm that the MCP transport type configured in your IDE is supported. The Kimi Code CLI ACP adapter currently supports `http`, `stdio`, and `sse` transports; `acp` transport MCP servers are silently dropped and a warning is written to the log.
 
 ## Next steps
 
diff --git a/docs/en/reference/kimi-acp.md b/docs/en/reference/kimi-acp.md
index 950ce39b2..30f078765 100644
--- a/docs/en/reference/kimi-acp.md
+++ b/docs/en/reference/kimi-acp.md
@@ -22,7 +22,7 @@ The table below lists the capabilities declared by the current ACP adapter layer
 | `promptCapabilities.audio` | `false` | Audio prompts not yet supported |
 | `promptCapabilities.embeddedContext` | `true` | Client may send `resource`/`resource_link` embedded resource blocks; text content is injected into the prompt as `<resource uri="...">...</resource>`; blob resources are dropped with a warn |
 | `mcpCapabilities.http` | `true` | Forwards HTTP MCP services configured by the IDE |
-| `mcpCapabilities.sse` | `false` | SSE MCP services not supported; matching entries are discarded and a warn is logged |
+| `mcpCapabilities.sse` | `true` | Forwards legacy SSE MCP services configured by the IDE |
 | `loadSession` | `true` | Supports `session/load` to resume an existing session, replaying history on load |
 | `sessionCapabilities.list` | `{}` | Supports `session/list` to enumerate the current user's sessions |
 
@@ -74,7 +74,8 @@ When an ACP client provides `mcpServers` in `session/new` or `session/load`, the
 
 - `http` → kimi's `transport: 'http'` configuration
 - `stdio` → kimi's `transport: 'stdio'` configuration
-- `sse` / `acp` → discarded with a warn log entry
+- `sse` → kimi's `transport: 'sse'` configuration
+- `acp` → discarded with a warn log entry
 
 ## Next steps
 
diff --git a/docs/zh/customization/mcp.md b/docs/zh/customization/mcp.md
index a51f16cc3..96a4e66dd 100644
--- a/docs/zh/customization/mcp.md
+++ b/docs/zh/customization/mcp.md
@@ -4,10 +4,11 @@
 
 ## 接入方式
 
-Kimi Code CLI 支持两种 MCP server 接入方式：
+Kimi Code CLI 支持三种 MCP server 接入方式：
 
 - **stdio**：CLI 以子进程方式启动本地 MCP server，通过标准输入输出通信。适合本地命令行工具。
 - **HTTP**：CLI 连接一个已在运行的 HTTP 端点。适合远程服务或需要持久运行的进程。
+- **SSE**：CLI 连接旧式 HTTP+SSE 端点（Server-Sent Events，一种流式 HTTP 机制）。新 MCP server 优先使用 HTTP；只有服务仍仅暴露旧式 SSE 传输时，才设置 `transport: "sse"`。
 
 ## 配置
 
@@ -31,12 +32,16 @@ MCP server 配置写在 `mcp.json` 中，分两层：
     },
     "linear": {
       "url": "https://mcp.linear.app/mcp"
+    },
+    "legacy-events": {
+      "transport": "sse",
+      "url": "https://mcp.example.com/sse"
     }
   }
 }
 ```
 
-含 `command` 字段的条目为 stdio server，含 `url` 字段的条目为 HTTP server，通常不需要手写 `transport` 字段。
+含 `command` 字段的条目为 stdio server；含 `url` 字段且未写 `transport` 的条目为 HTTP server。旧式 SSE server 需要显式把 `transport` 设为 `"sse"`。
 
 可选字段：
 
@@ -44,14 +49,15 @@ MCP server 配置写在 `mcp.json` 中，分两层：
 | --- | --- | --- | --- |
 | `env` | `Record<string, string>` | stdio | 注入子进程的环境变量 |
 | `cwd` | `string` | stdio | 子进程工作目录 |
-| `headers` | `Record<string, string>` | HTTP | 附加到每次请求的静态请求头 |
-| `enabled` | `boolean` | 两者 | 设为 `false` 可禁用该 server |
-| `startupTimeoutMs` | `number` | 两者 | 连接超时，默认 `30000` 毫秒 |
-| `toolTimeoutMs` | `number` | 两者 | 单次工具调用超时 |
-| `enabledTools` | `string[]` | 两者 | 工具白名单 |
-| `disabledTools` | `string[]` | 两者 | 工具黑名单 |
+| `headers` | `Record<string, string>` | HTTP、SSE | 附加到每次请求的静态请求头 |
+| `bearerTokenEnvVar` | `string` | HTTP、SSE | 存放 bearer token 的环境变量名 |
+| `enabled` | `boolean` | 全部 | 设为 `false` 可禁用该 server |
+| `startupTimeoutMs` | `number` | 全部 | 连接超时，默认 `30000` 毫秒 |
+| `toolTimeoutMs` | `number` | 全部 | 单次工具调用超时 |
+| `enabledTools` | `string[]` | 全部 | 工具白名单 |
+| `disabledTools` | `string[]` | 全部 | 工具黑名单 |
 
-HTTP server 支持通过 `headers` 或 `bearerTokenEnvVar` 提供静态凭证。需要 OAuth 时，运行 `/mcp-config login <server-name>` 完成浏览器授权。
+HTTP 与 SSE server 支持通过 `headers` 或 `bearerTokenEnvVar` 提供静态凭证。需要 OAuth 时，运行 `/mcp-config login <server-name>` 完成浏览器授权。
 
 Plugins 也可以在 manifest 中声明 MCP servers。Plugin 声明的 servers 默认启用，可以在 `/plugins` 中禁用或重新启用，然后开启新会话。详见 [Plugins](./plugins.md)。
 
diff --git a/docs/zh/guides/ides.md b/docs/zh/guides/ides.md
index 713a5233b..a8193ed4e 100644
--- a/docs/zh/guides/ides.md
+++ b/docs/zh/guides/ides.md
@@ -88,7 +88,7 @@ Paseo 的通用 ACP 适配层不会帮你走登录流程，所以请先完成终
 
 - **会话立刻被中断 / IDE 提示 "agent exited"**：通常是 `command` 路径不对或 kimi 没登录。先在终端跑一次 `kimi acp` 验证：如果阻塞等待标准输入则说明 CLI 本身没问题，问题在 IDE 配置；如果立刻报错则按报错提示处理（多数是没 `/login`）。
 - **IDE 显示 "auth required"**：表示 CLI 没有可用的鉴权令牌。退出 IDE，在终端执行 `kimi` 完成登录后再启动 IDE 即可。
-- **MCP 工具看不到**：参考 [`kimi acp`](../reference/kimi-acp.md) 中的能力表确认 IDE 配的 MCP 传输类型是否被支持。当前 Kimi Code CLI 的 ACP 适配层支持 `http`、`stdio` 两种传输方式，`sse` 与 `acp` 类型会被静默丢弃并在日志中给出 warn。
+- **MCP 工具看不到**：参考 [`kimi acp`](../reference/kimi-acp.md) 中的能力表确认 IDE 配的 MCP 传输类型是否被支持。当前 Kimi Code CLI 的 ACP 适配层支持 `http`、`stdio` 与 `sse` 三种传输方式；`acp` 传输的 MCP server 会被静默丢弃并在日志中给出 warn。
 
 ## 下一步
 
diff --git a/docs/zh/reference/kimi-acp.md b/docs/zh/reference/kimi-acp.md
index d114a2724..d58c4460a 100644
--- a/docs/zh/reference/kimi-acp.md
+++ b/docs/zh/reference/kimi-acp.md
@@ -22,7 +22,7 @@ kimi acp
 | `promptCapabilities.audio` | `false` | 暂不支持音频 prompt |
 | `promptCapabilities.embeddedContext` | `true` | 客户端可发送 `resource`/`resource_link` 嵌入式资源块，文本内容会以 `<resource uri="...">...</resource>` 形式注入 prompt；blob 资源被丢弃并写 warn |
 | `mcpCapabilities.http` | `true` | 转发 IDE 配置的 HTTP MCP 服务 |
-| `mcpCapabilities.sse` | `false` | 不支持 SSE MCP 服务，相关条目会被丢弃并写 warn 日志 |
+| `mcpCapabilities.sse` | `true` | 转发 IDE 配置的旧式 SSE MCP 服务 |
 | `loadSession` | `true` | 支持 `session/load` 续接已有会话，加载时会同步回放历史 |
 | `sessionCapabilities.list` | `{}` | 支持 `session/list` 枚举当前用户的会话 |
 
@@ -74,7 +74,8 @@ ACP 客户端在 `session/new` 或 `session/load` 中提供 `mcpServers` 时，
 
 - `http` → kimi 的 `transport: 'http'` 配置
 - `stdio` → kimi 的 `transport: 'stdio'` 配置
-- `sse` / `acp` → 丢弃并写一条 warn 日志
+- `sse` → kimi 的 `transport: 'sse'` 配置
+- `acp` → 丢弃并写一条 warn 日志
 
 ## 下一步
 
diff --git a/packages/acp-adapter/src/mcp.ts b/packages/acp-adapter/src/mcp.ts
index f2e8f7b99..44d419fa0 100644
--- a/packages/acp-adapter/src/mcp.ts
+++ b/packages/acp-adapter/src/mcp.ts
@@ -10,9 +10,8 @@
  *
  *  - `http`  → kimi `transport: 'http'` with headers projected from
  *              `Array<{name, value}>` to `Record<string, string>`.
+ *  - `sse`   → kimi `transport: 'sse'` with headers projected the same way.
  *  - `stdio` → kimi `transport: 'stdio'` with env projected similarly.
- *  - `sse`   → dropped with a `log.warn` (PLAN D3 declares
- *              `mcp_capabilities: sse=false`).
  *  - `acp`   → dropped with a `log.warn` (experimental ACP-transport MCP
  *              is not yet supported).
  *
@@ -33,7 +32,7 @@ import { log } from '@moonshot-ai/kimi-code-sdk';
 /**
  * Convert an ACP `McpServer[]` into the kernel-native
  * `Record<string, McpServerConfig>` keyed by server name. Unsupported
- * transports (`sse`, `acp`) are warn-dropped — the caller never has to
+ * transports (`acp`) are warn-dropped — the caller never has to
  * filter them out.
  *
  * Caveat (ACP schema 0.23): the `McpServer` union types stdio as a
@@ -79,7 +78,14 @@ function acpMcpServerToConfig(
       };
       return { name: server.name, config };
     }
-    case 'sse':
+    case 'sse': {
+      const config: McpServerConfig = {
+        transport: 'sse',
+        url: server.url,
+        headers: headersArrayToRecord(server.headers),
+      };
+      return { name: server.name, config };
+    }
     case 'acp':
     default: {
       // Defensive: future ACP transports land here too. The cast is the
diff --git a/packages/acp-adapter/src/server.ts b/packages/acp-adapter/src/server.ts
index e1f114ee4..f4d343d29 100644
--- a/packages/acp-adapter/src/server.ts
+++ b/packages/acp-adapter/src/server.ts
@@ -224,7 +224,7 @@ export class AcpServer implements Agent {
       },
       mcpCapabilities: {
         http: true,
-        sse: false,
+        sse: true,
       },
       sessionCapabilities: {
         list: {},
@@ -255,7 +255,7 @@ export class AcpServer implements Agent {
     // similar fields are wired in Phase 8 (per PLAN D3) — Phase 3.2 keeps
     // the surface minimal. Phase 10.1 adds `mcpServers` forwarding so
     // ACP-supplied servers (Zed config, JetBrains config) are passed
-    // alongside the on-disk config; unsupported transports (sse/acp)
+    // alongside the on-disk config; unsupported ACP-transport servers
     // are warn-dropped inside the conversion. `mcpServers` is NOT a
     // declared field on `CreateSessionOptions` — the SDK is a
     // transparent passthrough for unknown fields (see
diff --git a/packages/acp-adapter/test/e2e-happy-path.test.ts b/packages/acp-adapter/test/e2e-happy-path.test.ts
index 60ff443c8..8ee7c56da 100644
--- a/packages/acp-adapter/test/e2e-happy-path.test.ts
+++ b/packages/acp-adapter/test/e2e-happy-path.test.ts
@@ -10,7 +10,7 @@
  *
  *  1. `initialize` returns the documented capability matrix
  *     (PLAN D4: image=true, audio=false, embeddedContext=true,
- *      mcp.http=true, mcp.sse=false, loadSession=true,
+ *      mcp.http=true, mcp.sse=true, loadSession=true,
  *      sessionCapabilities.list={}).
  *  2. `session/new` returns a non-empty sessionId.
  *  3. `session/prompt` streams at least one `agent_message_chunk`
@@ -171,7 +171,7 @@ describe('AcpServer end-to-end happy path', () => {
       },
       mcpCapabilities: {
         http: true,
-        sse: false,
+        sse: true,
       },
       sessionCapabilities: {
         list: {},
diff --git a/packages/acp-adapter/test/mcp-forward.test.ts b/packages/acp-adapter/test/mcp-forward.test.ts
index 89ab039d8..862301b0e 100644
--- a/packages/acp-adapter/test/mcp-forward.test.ts
+++ b/packages/acp-adapter/test/mcp-forward.test.ts
@@ -192,16 +192,18 @@ describe('acpMcpServersToConfigs', () => {
     expect(warnSpy).not.toHaveBeenCalled();
   });
 
-  it('warn-drops sse servers (PLAN D3 — sse capability is false)', () => {
+  it('converts an SSE server with headers to a Record keyed by name', () => {
     const out = acpMcpServersToConfigs([
       sseServer('events', 'https://stream.example.com', [{ name: 'X-K', value: 'V' }]),
     ]);
-    expect(out).toEqual({});
-    expect(warnSpy).toHaveBeenCalledTimes(1);
-    expect(warnSpy).toHaveBeenCalledWith(
-      'acp: dropping unsupported MCP server transport',
-      expect.objectContaining({ name: 'events', type: 'sse' }),
-    );
+    expect(out).toEqual({
+      events: {
+        transport: 'sse',
+        url: 'https://stream.example.com',
+        headers: { 'X-K': 'V' },
+      },
+    });
+    expect(warnSpy).not.toHaveBeenCalled();
   });
 
   it('warn-drops acp servers (experimental, not supported)', () => {
@@ -218,10 +220,12 @@ describe('acpMcpServersToConfigs', () => {
     const out = acpMcpServersToConfigs([
       httpServer('docs', 'https://h', [{ name: 'X', value: 'v' }]),
       sseServer('events', 'https://s', [{ name: 'X', value: 'v' }]),
+      acpServer('inner', 'opaque-id'),
       stdioServer('fs', '/bin/fs', [], []),
     ]);
-    expect(Object.keys(out)).toEqual(['docs', 'fs']);
+    expect(Object.keys(out)).toEqual(['docs', 'events', 'fs']);
     expect(out['docs']).toMatchObject({ transport: 'http' });
+    expect(out['events']).toMatchObject({ transport: 'sse' });
     expect(out['fs']).toMatchObject({ transport: 'stdio' });
     expect(warnSpy).toHaveBeenCalledTimes(1);
   });
@@ -261,6 +265,11 @@ describe('AcpServer session/new MCP forwarding', () => {
         url: 'https://mcp.example.com',
         headers: { Auth: 'tok' },
       },
+      events: {
+        transport: 'sse',
+        url: 'https://s',
+        headers: { X: 'v' },
+      },
     });
     void _agentConn;
   });
diff --git a/packages/acp-adapter/test/server.test.ts b/packages/acp-adapter/test/server.test.ts
index 0f9a967f4..883fae3d3 100644
--- a/packages/acp-adapter/test/server.test.ts
+++ b/packages/acp-adapter/test/server.test.ts
@@ -78,7 +78,7 @@ describe('AcpServer + AgentSideConnection', () => {
     expect(response.agentCapabilities?.promptCapabilities?.audio).toBe(false);
     expect(response.agentCapabilities?.promptCapabilities?.embeddedContext).toBe(true);
     expect(response.agentCapabilities?.mcpCapabilities?.http).toBe(true);
-    expect(response.agentCapabilities?.mcpCapabilities?.sse).toBe(false);
+    expect(response.agentCapabilities?.mcpCapabilities?.sse).toBe(true);
     expect(response.agentCapabilities?.sessionCapabilities?.list).toEqual({});
     expect(response.agentCapabilities?.sessionCapabilities?.resume).toEqual({});
   });
diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 33679f88c..76a49f2ac 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -238,10 +238,10 @@ export class ToolManager {
     // server flipping to needs-auth means previous tokens were invalidated.
     this.unregisterMcpServer(entry.name);
     const oauthService = mcp.oauthService;
-    const serverUrl = mcp.getHttpServerUrl(entry.name);
+    const serverUrl = mcp.getRemoteServerUrl(entry.name);
     if (oauthService === undefined || serverUrl === undefined) {
       // Misconfiguration: a server reached needs-auth without the manager
-      // owning an OAuth service or being HTTP. Treat it as a no-op so the
+      // owning an OAuth service or being remote. Treat it as a no-op so the
       // existing failure error message keeps the user informed.
       return;
     }
diff --git a/packages/agent-core/src/config/schema.ts b/packages/agent-core/src/config/schema.ts
index 094239b73..9b3d11cf0 100644
--- a/packages/agent-core/src/config/schema.ts
+++ b/packages/agent-core/src/config/schema.ts
@@ -169,9 +169,24 @@ export const McpServerHttpConfigSchema = z.object({
 
 export type McpServerHttpConfig = z.infer<typeof McpServerHttpConfigSchema>;
 
+export const McpServerSseConfigSchema = z.object({
+  transport: z.literal('sse'),
+  url: z.string().url(),
+  headers: StringRecordSchema.optional(),
+  // Indirect secret reference: the bearer token is looked up from
+  // `process.env[bearerTokenEnvVar]` at connection time, never committed.
+  bearerTokenEnvVar: z.string().min(1).optional(),
+  ...McpServerCommonFields,
+});
+
+export type McpServerSseConfig = z.infer<typeof McpServerSseConfigSchema>;
+
+export type McpRemoteServerConfig = McpServerHttpConfig | McpServerSseConfig;
+
 const McpServerConfigDiscriminatedSchema = z.discriminatedUnion('transport', [
   McpServerStdioConfigSchema,
   McpServerHttpConfigSchema,
+  McpServerSseConfigSchema,
 ]);
 
 export const McpServerConfigSchema = z.preprocess((raw) => {
diff --git a/packages/agent-core/src/mcp/auth-tool.ts b/packages/agent-core/src/mcp/auth-tool.ts
index 3dd64c10f..414bd0b40 100644
--- a/packages/agent-core/src/mcp/auth-tool.ts
+++ b/packages/agent-core/src/mcp/auth-tool.ts
@@ -1,7 +1,7 @@
 /**
  * Synthetic `mcp__<server>__authenticate` tool.
  *
- * When an MCP HTTP server lands in the `needs-auth` state — i.e. its
+ * When a remote MCP server lands in the `needs-auth` state — i.e. its
  * initial connection failed with a 401 / `UnauthorizedError` and no static
  * bearer token is configured — the {@link ToolManager} swaps the real MCP
  * tool list for this single tool. Calling it:
diff --git a/packages/agent-core/src/mcp/client-http.ts b/packages/agent-core/src/mcp/client-http.ts
index 626c5d2bd..214217e26 100644
--- a/packages/agent-core/src/mcp/client-http.ts
+++ b/packages/agent-core/src/mcp/client-http.ts
@@ -1,4 +1,3 @@
-import { ErrorCodes, KimiError } from '#/errors';
 import type { McpServerHttpConfig } from '#/config/schema';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
@@ -13,6 +12,7 @@ import {
   type UnexpectedCloseListener,
   type UnexpectedCloseReason,
 } from './client-shared';
+import { buildMcpRemoteHeaders } from './client-remote';
 import type { MCPClient, MCPToolDefinition, MCPToolResult } from './types';
 
 export interface HttpMcpClientOptions {
@@ -211,21 +211,5 @@ export function buildMcpHttpHeaders(
   config: McpServerHttpConfig,
   envLookup: (name: string) => string | undefined,
 ): Record<string, string> | undefined {
-  const headers: Record<string, string> = { ...config.headers };
-  if (config.bearerTokenEnvVar !== undefined) {
-    const token = envLookup(config.bearerTokenEnvVar);
-    if (token === undefined || token.length === 0) {
-      throw new KimiError(ErrorCodes.CONFIG_INVALID, `MCP HTTP bearer token env var "${config.bearerTokenEnvVar}" is not set or is empty`);
-    }
-    // Strip any case-variant 'authorization' static header before injecting the
-    // bearer; Fetch Headers folds duplicate keys into a comma-joined value,
-    // which produces an invalid auth header rather than letting the bearer win.
-    for (const key of Object.keys(headers)) {
-      if (key.toLowerCase() === 'authorization') {
-        delete headers[key];
-      }
-    }
-    headers['Authorization'] = `Bearer ${token}`;
-  }
-  return Object.keys(headers).length > 0 ? headers : undefined;
+  return buildMcpRemoteHeaders(config, envLookup);
 }
diff --git a/packages/agent-core/src/mcp/client-remote.ts b/packages/agent-core/src/mcp/client-remote.ts
new file mode 100644
index 000000000..20572e0e5
--- /dev/null
+++ b/packages/agent-core/src/mcp/client-remote.ts
@@ -0,0 +1,32 @@
+import type { McpRemoteServerConfig, McpServerConfig } from '#/config/schema';
+import { ErrorCodes, KimiError } from '#/errors';
+
+export function buildMcpRemoteHeaders(
+  config: McpRemoteServerConfig,
+  envLookup: (name: string) => string | undefined,
+): Record<string, string> | undefined {
+  const headers: Record<string, string> = { ...config.headers };
+  if (config.bearerTokenEnvVar !== undefined) {
+    const token = envLookup(config.bearerTokenEnvVar);
+    if (token === undefined || token.length === 0) {
+      throw new KimiError(
+        ErrorCodes.CONFIG_INVALID,
+        `MCP ${config.transport.toUpperCase()} bearer token env var "${config.bearerTokenEnvVar}" is not set or is empty`,
+      );
+    }
+    // Strip any case-variant 'authorization' static header before injecting the
+    // bearer; Fetch Headers folds duplicate keys into a comma-joined value,
+    // which produces an invalid auth header rather than letting the bearer win.
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === 'authorization') {
+        delete headers[key];
+      }
+    }
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+  return Object.keys(headers).length > 0 ? headers : undefined;
+}
+
+export function isRemoteMcpConfig(config: McpServerConfig): config is McpRemoteServerConfig {
+  return config.transport === 'http' || config.transport === 'sse';
+}
diff --git a/packages/agent-core/src/mcp/client-sse.ts b/packages/agent-core/src/mcp/client-sse.ts
new file mode 100644
index 000000000..4ac2e3dc0
--- /dev/null
+++ b/packages/agent-core/src/mcp/client-sse.ts
@@ -0,0 +1,169 @@
+import type { McpServerSseConfig } from '#/config/schema';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import { SSEClientTransport, SseError } from '@modelcontextprotocol/sdk/client/sse.js';
+
+import {
+  buildRequestOptions,
+  KIMI_MCP_CLIENT_NAME,
+  KIMI_MCP_CLIENT_VERSION,
+  toMcpToolDefinition,
+  toMcpToolResult,
+  type UnexpectedCloseListener,
+  type UnexpectedCloseReason,
+} from './client-shared';
+import { buildMcpRemoteHeaders } from './client-remote';
+import type { MCPClient, MCPToolDefinition, MCPToolResult } from './types';
+
+export interface SseMcpClientOptions {
+  readonly clientName?: string;
+  readonly clientVersion?: string;
+  readonly toolCallTimeoutMs?: number;
+  /**
+   * Reads `process.env[name]` by default. Tests can inject a deterministic
+   * lookup function so they do not have to mutate global env.
+   */
+  readonly envLookup?: (name: string) => string | undefined;
+  /**
+   * Lets tests inject a fake `fetch` for the underlying transport.
+   */
+  readonly fetch?: typeof fetch;
+  /**
+   * OAuth client provider attached to the transport. Set only when the server
+   * has no static token configuration; the connection manager wires this in
+   * and surfaces `UnauthorizedError` as a `needs-auth` status.
+   */
+  readonly oauthProvider?: OAuthClientProvider;
+}
+
+/**
+ * Wraps the SDK's deprecated HTTP+SSE transport as a kosong
+ * {@link MCPClient}. This exists for compatibility with older MCP servers;
+ * new remote servers should prefer streamable HTTP.
+ */
+export class SseMcpClient implements MCPClient {
+  private readonly client: Client;
+  private readonly transport: SSEClientTransport;
+  private readonly toolCallTimeoutMs?: number;
+  private started = false;
+  private closed = false;
+  // Mirrors HttpMcpClient: handshake failures surface through connect(), while
+  // post-ready terminal transport errors become unexpected closes.
+  private ready = false;
+  private hooksInstalled = false;
+  private unexpectedCloseListener: UnexpectedCloseListener | undefined;
+  private lastTransportError: Error | undefined;
+  private pendingUnexpectedClose: UnexpectedCloseReason | undefined;
+  private unexpectedCloseFired = false;
+
+  constructor(config: McpServerSseConfig, options: SseMcpClientOptions = {}) {
+    const envLookup = options.envLookup ?? ((name) => process.env[name]);
+    const headers = buildMcpRemoteHeaders(config, envLookup);
+
+    this.transport = new SSEClientTransport(new URL(config.url), {
+      requestInit: headers !== undefined ? { headers } : undefined,
+      fetch: options.fetch,
+      authProvider: options.oauthProvider,
+    });
+    this.client = new Client({
+      name: options.clientName ?? KIMI_MCP_CLIENT_NAME,
+      version: options.clientVersion ?? KIMI_MCP_CLIENT_VERSION,
+    });
+    this.toolCallTimeoutMs = options.toolCallTimeoutMs;
+  }
+
+  async connect(): Promise<void> {
+    if (this.closed) {
+      throw new Error('MCP SSE client is closed');
+    }
+    if (this.started) return;
+    this.started = true;
+    this.installTransportHooks();
+    try {
+      await this.client.connect(this.transport);
+    } catch (error) {
+      await this.closeStartedClient();
+      throw error;
+    }
+    if (this.closed) {
+      await this.closeStartedClient();
+      throw new Error('MCP SSE client was closed during startup');
+    }
+    this.ready = true;
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    await this.closeStartedClient();
+  }
+
+  /**
+   * Register a listener for unsolicited terminal transport drops. Brief SSE
+   * stream flaps are left to EventSource's retry loop; terminal HTTP status
+   * errors after startup remove the tools from the agent.
+   */
+  onUnexpectedClose(listener: UnexpectedCloseListener): void {
+    this.unexpectedCloseListener = listener;
+    const pending = this.pendingUnexpectedClose;
+    if (pending !== undefined) {
+      this.pendingUnexpectedClose = undefined;
+      listener(pending);
+    }
+  }
+
+  async listTools(): Promise<MCPToolDefinition[]> {
+    const result = await this.client.listTools();
+    return result.tools.map(toMcpToolDefinition);
+  }
+
+  async callTool(
+    name: string,
+    args: Record<string, unknown>,
+    signal?: AbortSignal,
+  ): Promise<MCPToolResult> {
+    const requestOptions = buildRequestOptions(this.toolCallTimeoutMs, signal);
+    const result = await this.client.callTool({ name, arguments: args }, undefined, requestOptions);
+    return toMcpToolResult(result);
+  }
+
+  private async closeStartedClient(): Promise<void> {
+    if (!this.started) return;
+    this.started = false;
+    await this.client.close();
+  }
+
+  private installTransportHooks(): void {
+    if (this.hooksInstalled) return;
+    this.hooksInstalled = true;
+    this.client.onclose = () => {
+      if (this.closed) return;
+      if (!this.ready) return;
+      this.fireUnexpectedClose({ error: this.lastTransportError });
+    };
+    this.client.onerror = (error) => {
+      this.lastTransportError = error;
+      if (this.closed) return;
+      if (!this.ready) return;
+      if (isTerminalSseTransportError(error)) {
+        this.fireUnexpectedClose({ error });
+      }
+    };
+  }
+
+  private fireUnexpectedClose(reason: UnexpectedCloseReason): void {
+    if (this.unexpectedCloseFired) return;
+    this.unexpectedCloseFired = true;
+    const listener = this.unexpectedCloseListener;
+    if (listener !== undefined) {
+      listener(reason);
+    } else {
+      this.pendingUnexpectedClose = reason;
+    }
+  }
+}
+
+export function isTerminalSseTransportError(error: Error): boolean {
+  if (error.name === 'UnauthorizedError') return true;
+  return error instanceof SseError && error.code !== undefined;
+}
diff --git a/packages/agent-core/src/mcp/connection-manager.ts b/packages/agent-core/src/mcp/connection-manager.ts
index 30f269e1c..7d3c9c1f3 100644
--- a/packages/agent-core/src/mcp/connection-manager.ts
+++ b/packages/agent-core/src/mcp/connection-manager.ts
@@ -6,6 +6,8 @@ import type { Tool } from '@moonshot-ai/kosong';
 
 import { abortable } from '../utils/abort';
 import { HttpMcpClient } from './client-http';
+import { isRemoteMcpConfig } from './client-remote';
+import { SseMcpClient } from './client-sse';
 import type { UnexpectedCloseReason } from './client-shared';
 import { StdioMcpClient } from './client-stdio';
 import type { McpOAuthService } from './oauth';
@@ -15,7 +17,7 @@ export type McpServerStatus = 'pending' | 'connected' | 'failed' | 'disabled' |
 
 export interface McpServerEntry {
   readonly name: string;
-  readonly transport: 'stdio' | 'http';
+  readonly transport: McpServerConfig['transport'];
   readonly status: McpServerStatus;
   readonly toolCount: number;
   readonly error?: string;
@@ -36,12 +38,12 @@ export type McpStatusListener = (entry: McpServerEntry) => void;
 
 const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
 
-type RuntimeMcpClient = StdioMcpClient | HttpMcpClient;
+type RuntimeMcpClient = StdioMcpClient | HttpMcpClient | SseMcpClient;
 
 export interface McpConnectionManagerOptions {
   readonly envLookup?: (name: string) => string | undefined;
   /**
-   * Optional OAuth orchestrator. When provided, HTTP servers without a
+   * Optional OAuth orchestrator. When provided, remote servers without a
    * static bearer token participate in the OAuth-via-synthetic-tool flow:
    *  - If `oauthService.hasTokens(name, url)` is true, the provider is
    *    attached to the transport so the SDK can refresh tokens on 401.
@@ -88,17 +90,25 @@ export class McpConnectionManager {
   }
 
   /**
-   * Returns the URL of an HTTP MCP server by name, or `undefined` for
-   * unknown / non-HTTP / disabled entries. Used by the synthetic auth tool
+   * Returns the URL of a remote MCP server by name, or `undefined` for
+   * unknown / non-remote / disabled entries. Used by the synthetic auth tool
    * to drive OAuth discovery against the right base URL.
    */
-  getHttpServerUrl(name: string): string | undefined {
+  getRemoteServerUrl(name: string): string | undefined {
     const entry = this.entries.get(name);
     if (entry === undefined) return undefined;
-    if (entry.config.transport !== 'http') return undefined;
+    if (!isRemoteMcpConfig(entry.config)) return undefined;
     return entry.config.url;
   }
 
+  /**
+   * @deprecated Use {@link getRemoteServerUrl}. Kept for in-repo callers that
+   * were written before legacy SSE support shared the same OAuth path.
+   */
+  getHttpServerUrl(name: string): string | undefined {
+    return this.getRemoteServerUrl(name);
+  }
+
   onStatusChange(listener: McpStatusListener): () => void {
     this.listeners.add(listener);
     return () => {
@@ -323,6 +333,13 @@ export class McpConnectionManager {
     if (config.transport === 'stdio') {
       return new StdioMcpClient(config, { toolCallTimeoutMs });
     }
+    if (config.transport === 'sse') {
+      return new SseMcpClient(config, {
+        toolCallTimeoutMs,
+        envLookup: this.options.envLookup,
+        oauthProvider: this.resolveOAuthProvider(config, name),
+      });
+    }
     return new HttpMcpClient(config, {
       toolCallTimeoutMs,
       envLookup: this.options.envLookup,
@@ -336,7 +353,7 @@ export class McpConnectionManager {
   ): ReturnType<McpOAuthService['getProvider']> | undefined {
     const oauthService = this.oauthService;
     if (oauthService === undefined) return undefined;
-    if (config.transport !== 'http') return undefined;
+    if (!isRemoteMcpConfig(config)) return undefined;
     if (config.bearerTokenEnvVar !== undefined) return undefined;
     // Only attach the provider once tokens have been minted; before that,
     // the transport should propagate a clean 401 so we can flip the entry
@@ -348,7 +365,7 @@ export class McpConnectionManager {
 
   private shouldMarkNeedsAuth(entry: InternalEntry, error: unknown): boolean {
     if (this.oauthService === undefined) return false;
-    if (entry.config.transport !== 'http') return false;
+    if (!isRemoteMcpConfig(entry.config)) return false;
     if (entry.config.bearerTokenEnvVar !== undefined) return false;
     // If the user pinned a static `headers` block, treat 401s as a bad header
     // rather than hijacking them into the OAuth flow — the real error is more
diff --git a/packages/agent-core/src/plugin/manager.ts b/packages/agent-core/src/plugin/manager.ts
index a1badcc31..2d3c1a700 100644
--- a/packages/agent-core/src/plugin/manager.ts
+++ b/packages/agent-core/src/plugin/manager.ts
@@ -417,12 +417,12 @@ function pluginMcpServerInfo(
   name: string,
   config: McpServerConfig,
 ): PluginMcpServerInfo {
-  if (config.transport === 'http') {
+  if (config.transport === 'http' || config.transport === 'sse') {
     return {
       name,
       runtimeName: pluginMcpRuntimeName(record.id, name),
       enabled: isMcpServerEnabled(record, name, config),
-      transport: 'http',
+      transport: config.transport,
       url: config.url,
       headerKeys: config.headers === undefined ? undefined : Object.keys(config.headers).toSorted(),
     };
@@ -454,7 +454,7 @@ function withPluginMcpRuntime(
   pluginRoot: string,
   kimiHomeDir: string,
 ): McpServerConfig {
-  if (config.transport === 'http') return config;
+  if (config.transport === 'http' || config.transport === 'sse') return config;
 
   const env = {
     ...config.env,
diff --git a/packages/agent-core/src/plugin/manifest.ts b/packages/agent-core/src/plugin/manifest.ts
index 529f440c7..93355f5ea 100644
--- a/packages/agent-core/src/plugin/manifest.ts
+++ b/packages/agent-core/src/plugin/manifest.ts
@@ -291,7 +291,7 @@ async function normalizePluginMcpServer(input: {
   readonly diagnostics: PluginDiagnostic[];
 }): Promise<McpServerConfig | undefined> {
   const { config } = input;
-  if (config.transport === 'http') return config;
+  if (config.transport === 'http' || config.transport === 'sse') return config;
 
   let command = config.command;
   if (command.startsWith('./')) {
diff --git a/packages/agent-core/src/plugin/types.ts b/packages/agent-core/src/plugin/types.ts
index ad4fc3086..82ae27bb2 100644
--- a/packages/agent-core/src/plugin/types.ts
+++ b/packages/agent-core/src/plugin/types.ts
@@ -51,7 +51,7 @@ export interface PluginMcpServerInfo {
   readonly name: string;
   readonly runtimeName: string;
   readonly enabled: boolean;
-  readonly transport: 'stdio' | 'http';
+  readonly transport: 'stdio' | 'http' | 'sse';
   readonly command?: string;
   readonly args?: readonly string[];
   readonly cwd?: string;
diff --git a/packages/agent-core/src/rpc/core-api.ts b/packages/agent-core/src/rpc/core-api.ts
index b080802ee..c3ba9f6a5 100644
--- a/packages/agent-core/src/rpc/core-api.ts
+++ b/packages/agent-core/src/rpc/core-api.ts
@@ -223,7 +223,7 @@ export interface ActivateSkillPayload {
 
 export interface McpServerInfo {
   readonly name: string;
-  readonly transport: 'stdio' | 'http';
+  readonly transport: 'stdio' | 'http' | 'sse';
   readonly status: 'pending' | 'connected' | 'failed' | 'disabled' | 'needs-auth';
   readonly toolCount: number;
   readonly error?: string;
diff --git a/packages/agent-core/test/mcp/client-sse.test.ts b/packages/agent-core/test/mcp/client-sse.test.ts
new file mode 100644
index 000000000..8a3c900f1
--- /dev/null
+++ b/packages/agent-core/test/mcp/client-sse.test.ts
@@ -0,0 +1,142 @@
+import { createServer, type Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { SseError } from '@modelcontextprotocol/sdk/client/sse.js';
+import { afterEach, describe, expect, it } from 'vitest';
+import { z } from 'zod';
+
+import { SseMcpClient, isTerminalSseTransportError } from '../../src/mcp/client-sse';
+
+const cleanups: Array<() => Promise<void> | void> = [];
+
+afterEach(async () => {
+  for (const cleanup of cleanups.splice(0)) {
+    await cleanup();
+  }
+});
+
+async function startInProcessSseMcpServer(opts?: {
+  authToken?: string;
+}): Promise<{ url: string; close: () => Promise<void> }> {
+  const transports = new Map<string, SSEServerTransport>();
+  const httpServer: Server = createServer((req, res) => {
+    if (opts?.authToken !== undefined) {
+      const auth = req.headers['authorization'];
+      if (auth !== `Bearer ${opts.authToken}`) {
+        res.writeHead(401, { 'content-type': 'text/plain' });
+        res.end('unauthorized');
+        return;
+      }
+    }
+
+    const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+    if (req.method === 'GET' && url.pathname === '/mcp') {
+      const mcpServer = new McpServer({ name: 'mock-sse', version: '0.0.1' });
+      mcpServer.registerTool(
+        'echo',
+        { description: 'Echoes text', inputSchema: { text: z.string() } },
+        ({ text }) => ({ content: [{ type: 'text', text }] }),
+      );
+      const transport = new SSEServerTransport('/messages', res);
+      transports.set(transport.sessionId, transport);
+      transport.onclose = () => {
+        transports.delete(transport.sessionId);
+      };
+      void mcpServer.connect(transport);
+      return;
+    }
+
+    if (req.method === 'POST' && url.pathname === '/messages') {
+      const sessionId = url.searchParams.get('sessionId');
+      const transport = sessionId === null ? undefined : transports.get(sessionId);
+      if (transport === undefined) {
+        res.writeHead(404).end('Session not found');
+        return;
+      }
+      void transport.handlePostMessage(req, res);
+      return;
+    }
+
+    res.writeHead(404).end('not found');
+  });
+
+  await new Promise<void>((resolve) => {
+    httpServer.listen(0, '127.0.0.1', resolve);
+  });
+  const port = (httpServer.address() as AddressInfo).port;
+
+  return {
+    url: `http://127.0.0.1:${port}/mcp`,
+    async close() {
+      await Promise.all([...transports.values()].map((transport) => transport.close()));
+      await new Promise<void>((resolve, reject) => {
+        httpServer.close((err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve();
+        });
+      });
+    },
+  };
+}
+
+describe('SseMcpClient', () => {
+  it('connects, lists tools, and round-trips a call over real SSE', async () => {
+    const server = await startInProcessSseMcpServer();
+    cleanups.push(server.close);
+
+    const client = new SseMcpClient({ transport: 'sse', url: server.url });
+    try {
+      await client.connect();
+      const tools = await client.listTools();
+      expect(tools.map((t) => t.name)).toEqual(['echo']);
+
+      const result = await client.callTool('echo', { text: 'hello sse' });
+      expect(result.isError).toBe(false);
+      expect(result.content).toEqual([{ type: 'text', text: 'hello sse' }]);
+    } finally {
+      await client.close();
+    }
+  }, 15000);
+
+  it('forwards bearer token from envLookup on the SSE and POST requests', async () => {
+    const server = await startInProcessSseMcpServer({ authToken: 'good-token' });
+    cleanups.push(server.close);
+
+    const client = new SseMcpClient(
+      {
+        transport: 'sse',
+        url: server.url,
+        bearerTokenEnvVar: 'EXAMPLE_TOKEN',
+      },
+      { envLookup: (name) => (name === 'EXAMPLE_TOKEN' ? 'good-token' : undefined) },
+    );
+    try {
+      await client.connect();
+      const result = await client.callTool('echo', { text: 'with auth' });
+      expect(result.content).toEqual([{ type: 'text', text: 'with auth' }]);
+    } finally {
+      await client.close();
+    }
+  }, 15000);
+
+  it('classifies terminal SSE transport errors without treating reconnect flaps as terminal', () => {
+    const unauthorized = new Error('Unauthorized');
+    unauthorized.name = 'UnauthorizedError';
+    expect(isTerminalSseTransportError(unauthorized)).toBe(true);
+    expect(
+      isTerminalSseTransportError(
+        new SseError(
+          204,
+          'Server sent HTTP 204',
+          {} as ConstructorParameters<typeof SseError>[2],
+        ),
+      ),
+    ).toBe(true);
+    expect(isTerminalSseTransportError(new Error('fetch failed'))).toBe(false);
+  });
+});
diff --git a/packages/agent-core/test/mcp/config-loader.test.ts b/packages/agent-core/test/mcp/config-loader.test.ts
index 120ffb2d6..f281c0551 100644
--- a/packages/agent-core/test/mcp/config-loader.test.ts
+++ b/packages/agent-core/test/mcp/config-loader.test.ts
@@ -194,7 +194,7 @@ describe('loadMcpServers', () => {
     const home = makeTempDir();
     const cwd = makeTempDir();
     await writeJson(join(home, 'mcp.json'), {
-      mcpServers: { bad: { transport: 'sse', url: 'https://x' } },
+      mcpServers: { bad: { transport: 'websocket', url: 'https://x' } },
     });
     await expect(loadMcpServers({ cwd, homeDir: home })).rejects.toMatchObject({
       code: ErrorCodes.CONFIG_INVALID,
@@ -243,6 +243,28 @@ describe('loadMcpServers', () => {
     });
   });
 
+  it('loads explicit SSE server config', async () => {
+    const home = makeTempDir();
+    const cwd = makeTempDir();
+    await writeJson(join(home, 'mcp.json'), {
+      mcpServers: {
+        legacy: {
+          transport: 'sse',
+          url: 'https://mcp.example.com/sse',
+          headers: { 'X-Tenant': 'kimi' },
+          bearerTokenEnvVar: 'LEGACY_MCP_TOKEN',
+        },
+      },
+    });
+    const servers = await loadMcpServers({ cwd, homeDir: home });
+    expect(servers['legacy']).toEqual({
+      transport: 'sse',
+      url: 'https://mcp.example.com/sse',
+      headers: { 'X-Tenant': 'kimi' },
+      bearerTokenEnvVar: 'LEGACY_MCP_TOKEN',
+    });
+  });
+
   it('honors KIMI_CODE_HOME env var when homeDir is not supplied', async () => {
     const home = makeTempDir();
     const cwd = makeTempDir();
diff --git a/packages/agent-core/test/mcp/connection-manager.test.ts b/packages/agent-core/test/mcp/connection-manager.test.ts
index 21c967390..a6930b948 100644
--- a/packages/agent-core/test/mcp/connection-manager.test.ts
+++ b/packages/agent-core/test/mcp/connection-manager.test.ts
@@ -117,6 +117,25 @@ describe('McpConnectionManager', () => {
     }
   });
 
+  it('marks SSE servers failed when configured bearer token env var is missing', async () => {
+    const cm = new McpConnectionManager({ envLookup: () => undefined });
+    try {
+      await cm.connectAll({
+        legacy: {
+          transport: 'sse',
+          url: 'https://example.invalid/sse',
+          bearerTokenEnvVar: 'LEGACY_MCP_TOKEN',
+        },
+      });
+      const entry = cm.get('legacy');
+      expect(entry?.transport).toBe('sse');
+      expect(entry?.status).toBe('failed');
+      expect(entry?.error).toContain('"LEGACY_MCP_TOKEN" is not set or is empty');
+    } finally {
+      await cm.shutdown();
+    }
+  });
+
   it('marks disabled servers without attempting a connection', async () => {
     const cm = new McpConnectionManager();
     try {
@@ -377,6 +396,47 @@ describe('McpConnectionManager', () => {
     }
   }, 15000);
 
+  it('flips SSE servers into needs-auth when the server returns 401 and no static token is set', async () => {
+    const server: HttpServer = createHttpServer((_req, res) => {
+      res.writeHead(401, {
+        'content-type': 'text/plain',
+        'www-authenticate': 'Bearer realm="mcp", resource_metadata="http://x/.well-known/oauth-protected-resource"',
+      });
+      res.end('unauthorized');
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const port = (server.address() as HttpAddress).port;
+    const storeDir = await mkdtemp(join(tmpdir(), 'kimi-mcp-oauth-sse-cm-'));
+    const oauthService = new McpOAuthService({ store: new JsonFileStore(storeDir) });
+    const cm = new McpConnectionManager({ oauthService });
+    try {
+      await cm.connectAll({
+        legacy: {
+          transport: 'sse',
+          url: `http://127.0.0.1:${port}/sse`,
+          startupTimeoutMs: 5_000,
+        },
+      });
+      const entry = cm.get('legacy');
+      expect(entry?.transport).toBe('sse');
+      expect(entry?.status).toBe('needs-auth');
+      expect(entry?.error).toContain('run /mcp-config login legacy');
+      expect(entry?.toolCount).toBe(0);
+    } finally {
+      await cm.shutdown();
+      await new Promise<void>((resolve, reject) => {
+        server.close((err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve();
+        });
+      });
+      await rm(storeDir, { recursive: true, force: true });
+    }
+  }, 15000);
+
   it('flips cached OAuth credentials that require reauth into needs-auth', async () => {
     const server: HttpServer = createHttpServer((req, res) => {
       if (req.url === '/token') {
diff --git a/packages/agent-core/test/plugin/manager.test.ts b/packages/agent-core/test/plugin/manager.test.ts
index 65644ff18..49dd383ce 100644
--- a/packages/agent-core/test/plugin/manager.test.ts
+++ b/packages/agent-core/test/plugin/manager.test.ts
@@ -341,6 +341,7 @@ describe('PluginManager', () => {
       mcpServers: {
         finance: { command: 'finance-mcp' },
         docs: { url: 'https://example.com/mcp' },
+        events: { transport: 'sse', url: 'https://example.com/sse' },
       },
     });
     const manager = new PluginManager({ kimiHomeDir: home });
@@ -356,10 +357,18 @@ describe('PluginManager', () => {
         command: 'finance-mcp',
       }),
     );
+    expect(manager.info('demo')?.mcpServers).toContainEqual(
+      expect.objectContaining({
+        name: 'events',
+        runtimeName: 'plugin-demo:events',
+        transport: 'sse',
+        url: 'https://example.com/sse',
+      }),
+    );
     expect(manager.summaries()[0]).toEqual(
       expect.objectContaining({
-        mcpServerCount: 2,
-        enabledMcpServerCount: 2,
+        mcpServerCount: 3,
+        enabledMcpServerCount: 3,
       }),
     );
 
@@ -373,6 +382,10 @@ describe('PluginManager', () => {
         'plugin-demo:docs': expect.objectContaining({
           url: 'https://example.com/mcp',
         }),
+        'plugin-demo:events': expect.objectContaining({
+          transport: 'sse',
+          url: 'https://example.com/sse',
+        }),
       }),
     );
 
@@ -381,8 +394,8 @@ describe('PluginManager', () => {
     expect(manager.enabledMcpServers()).not.toHaveProperty('plugin-demo:finance');
     expect(manager.summaries()[0]).toEqual(
       expect.objectContaining({
-        mcpServerCount: 2,
-        enabledMcpServerCount: 1,
+        mcpServerCount: 3,
+        enabledMcpServerCount: 2,
       }),
     );
 
diff --git a/packages/agent-core/test/plugin/manifest.test.ts b/packages/agent-core/test/plugin/manifest.test.ts
index dff208f62..4a436c4be 100644
--- a/packages/agent-core/test/plugin/manifest.test.ts
+++ b/packages/agent-core/test/plugin/manifest.test.ts
@@ -305,6 +305,11 @@ describe('parseManifest', () => {
               url: 'https://example.com/mcp',
               headers: { 'X-Test': '1' },
             },
+            events: {
+              transport: 'sse',
+              url: 'https://example.com/sse',
+              headers: { 'X-Events': '1' },
+            },
           },
         }),
       },
@@ -324,6 +329,11 @@ describe('parseManifest', () => {
       url: 'https://example.com/mcp',
       headers: { 'X-Test': '1' },
     });
+    expect(result.manifest?.mcpServers?.['events']).toEqual({
+      transport: 'sse',
+      url: 'https://example.com/sse',
+      headers: { 'X-Events': '1' },
+    });
   });
 
   it('warns and skips invalid plugin mcpServers entries', async () => {
diff --git a/packages/protocol/src/events.ts b/packages/protocol/src/events.ts
index c2d703e36..763052d78 100644
--- a/packages/protocol/src/events.ts
+++ b/packages/protocol/src/events.ts
@@ -528,7 +528,7 @@ export interface McpServerStatusEvent {
 
 export interface McpServerStatusPayload {
   readonly name: string;
-  readonly transport: 'stdio' | 'http';
+  readonly transport: 'stdio' | 'http' | 'sse';
   readonly status: 'pending' | 'connected' | 'failed' | 'disabled' | 'needs-auth';
   readonly toolCount: number;
   readonly error?: string;

From 9cef89656311974a57e6675f474ea6c2adb1d8e9 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Mon, 15 Jun 2026 12:06:56 +0800
Subject: [PATCH 13/17] fix: clarify compaction summary output target (#766)

---
 .changeset/quiet-compaction-final-answer.md                 | 6 ++++++
 .../src/agent/compaction/compaction-instruction.md          | 2 ++
 2 files changed, 8 insertions(+)
 create mode 100644 .changeset/quiet-compaction-final-answer.md

diff --git a/.changeset/quiet-compaction-final-answer.md b/.changeset/quiet-compaction-final-answer.md
new file mode 100644
index 000000000..7fd86399b
--- /dev/null
+++ b/.changeset/quiet-compaction-final-answer.md
@@ -0,0 +1,6 @@
+---
+"@moonshot-ai/agent-core": patch
+"@moonshot-ai/kimi-code": patch
+---
+
+Clarify that compaction summaries must be emitted in the final answer.
diff --git a/packages/agent-core/src/agent/compaction/compaction-instruction.md b/packages/agent-core/src/agent/compaction/compaction-instruction.md
index 68a3f3b12..49b0d80b4 100644
--- a/packages/agent-core/src/agent/compaction/compaction-instruction.md
+++ b/packages/agent-core/src/agent/compaction/compaction-instruction.md
@@ -65,3 +65,5 @@ The goal of compaction is to keep essential code patterns, technical details, an
 
 - [Detailed non tool use user message]
 - ...
+
+<!-- Must output a summary matching the above template in the **final answer**, not in thinking. -->

From 046856b740afb604132e914f1fc489de72394036 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Mon, 15 Jun 2026 12:09:05 +0800
Subject: [PATCH 14/17] fix: prefer media headers when reading media files
 (#765)

---
 .changeset/read-media-header-types.md         |  6 +++++
 .../src/tools/builtin/file/read-media.ts      |  6 ++---
 .../agent-core/src/tools/support/file-type.ts | 26 ++++++++++++++-----
 .../agent-core/test/tools/file-type.test.ts   | 19 ++++++++++++++
 .../agent-core/test/tools/read-media.test.ts  | 21 +++++++++++++++
 5 files changed, 68 insertions(+), 10 deletions(-)
 create mode 100644 .changeset/read-media-header-types.md

diff --git a/.changeset/read-media-header-types.md b/.changeset/read-media-header-types.md
new file mode 100644
index 000000000..fc6711415
--- /dev/null
+++ b/.changeset/read-media-header-types.md
@@ -0,0 +1,6 @@
+---
+"@moonshot-ai/agent-core": patch
+"@moonshot-ai/kimi-code": patch
+---
+
+Read media files using header-detected types before falling back to media extensions.
diff --git a/packages/agent-core/src/tools/builtin/file/read-media.ts b/packages/agent-core/src/tools/builtin/file/read-media.ts
index fa1ab671a..f21886974 100644
--- a/packages/agent-core/src/tools/builtin/file/read-media.ts
+++ b/packages/agent-core/src/tools/builtin/file/read-media.ts
@@ -171,10 +171,10 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
     }
 
     try {
-      // Sniff header first — read the first 512 bytes before deciding
-      // anything about MIME.
+      // For media input, the bytes are authoritative; the extension is only
+      // a fallback for formats that cannot be sniffed from the header.
       const header = await this.kaos.readBytes(safePath, MEDIA_SNIFF_BYTES);
-      const fileType = detectFileType(safePath, header);
+      const fileType = detectFileType(safePath, header, 'media');
 
       if (fileType.kind === 'text') {
         return {
diff --git a/packages/agent-core/src/tools/support/file-type.ts b/packages/agent-core/src/tools/support/file-type.ts
index 56e40529d..708cd9678 100644
--- a/packages/agent-core/src/tools/support/file-type.ts
+++ b/packages/agent-core/src/tools/support/file-type.ts
@@ -9,6 +9,8 @@ export interface FileType {
   readonly mimeType: string;
 }
 
+export type DetectFileTypeMode = 'text' | 'media';
+
 export const IMAGE_MIME_BY_SUFFIX: Readonly<Record<string, string>> = Object.freeze({
   '.png': 'image/png',
   '.jpg': 'image/jpeg',
@@ -340,7 +342,11 @@ function getSuffix(path: string): string {
   return path.slice(idx).toLowerCase();
 }
 
-export function detectFileType(path: string, header?: Buffer | Uint8Array): FileType {
+export function detectFileType(
+  path: string,
+  header?: Buffer | Uint8Array,
+  type: DetectFileTypeMode = 'text',
+): FileType {
   const suffix = getSuffix(path);
   let mediaHint: FileType | null = null;
   if (suffix in TEXT_MIME_BY_SUFFIX) {
@@ -351,16 +357,15 @@ export function detectFileType(path: string, header?: Buffer | Uint8Array): File
     mediaHint = { kind: 'video', mimeType: VIDEO_MIME_BY_SUFFIX[suffix]! };
   }
 
-  // When a header is supplied, cross-validate against the ext hint —
-  // a mismatch reports `unknown` rather than blindly trusting the
-  // extension. When ext hint + sniff agree on kind, prefer the ext's
-  // mimeType so the reported MIME matches what the filename advertised.
-  // A disagreement on `kind` (e.g. `.mp4` with JPEG magic) still
-  // collapses to `unknown`.
+  // When a header is supplied, cross-validate against the ext hint by
+  // default: a kind mismatch reports `unknown` rather than blindly trusting
+  // either signal. Media readers treat bytes as authoritative and only fall
+  // back to media suffixes when the header cannot be sniffed.
   if (header !== undefined) {
     const buf = toBuffer(header);
     const sniffed = sniffMediaFromMagic(buf);
     if (sniffed) {
+      if (type === 'media') return sniffed;
       if (mediaHint) {
         if (sniffed.kind !== mediaHint.kind) {
           return { kind: 'unknown', mimeType: '' };
@@ -369,6 +374,13 @@ export function detectFileType(path: string, header?: Buffer | Uint8Array): File
       }
       return sniffed;
     }
+    if (
+      type === 'media' &&
+      mediaHint !== null &&
+      mediaHint.kind !== 'text'
+    ) {
+      return mediaHint;
+    }
     if (buf.includes(0x00)) {
       return { kind: 'unknown', mimeType: '' };
     }
diff --git a/packages/agent-core/test/tools/file-type.test.ts b/packages/agent-core/test/tools/file-type.test.ts
index 43e92e947..3bdedb180 100644
--- a/packages/agent-core/test/tools/file-type.test.ts
+++ b/packages/agent-core/test/tools/file-type.test.ts
@@ -193,6 +193,25 @@ describe('detectFileType', () => {
     expect(result.kind).toBe('unknown');
   });
 
+  it('can prefer the sniffed media header over the extension in media mode', () => {
+    const pngHeader = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    expect(detectFileType('mismatch.mp4', pngHeader, 'media')).toEqual<FileType>({
+      kind: 'image',
+      mimeType: 'image/png',
+    });
+  });
+
+  it('falls back to a media extension in media mode when sniffing is inconclusive', () => {
+    const mpegProgramStreamHeader = Buffer.from([0x00, 0x00, 0x01, 0xba, 0x21, 0x00]);
+    expect(detectFileType('clip.mpg', mpegProgramStreamHeader, 'media')).toEqual<
+      FileType
+    >({
+      kind: 'video',
+      mimeType: 'video/mpeg',
+    });
+    expect(detectFileType('clip.mpg', mpegProgramStreamHeader).kind).toBe('unknown');
+  });
+
   it('extension in NON_TEXT_SUFFIXES → unknown', () => {
     // A `.zip` file with no header and no image/video hint must not
     // be treated as text.
diff --git a/packages/agent-core/test/tools/read-media.test.ts b/packages/agent-core/test/tools/read-media.test.ts
index 59913a1e4..8e0e9a6f0 100644
--- a/packages/agent-core/test/tools/read-media.test.ts
+++ b/packages/agent-core/test/tools/read-media.test.ts
@@ -318,6 +318,27 @@ describe('ReadMediaFileTool', () => {
     expect(parts[3]).toEqual({ type: 'text', text: '</video>' });
   });
 
+  it('falls back to a media extension when the header cannot be sniffed', async () => {
+    const data = Buffer.from([0x00, 0x00, 0x01, 0xba, 0x21, 0x00, 0x01, 0x00]);
+    const tool = makeReadMediaTool({
+      stat: vi.fn<Kaos['stat']>().mockResolvedValue({ ...DEFAULT_STAT, stSize: data.length }),
+      readBytes: vi.fn<Kaos['readBytes']>().mockResolvedValue(data),
+    });
+
+    const result = await executeTool(tool, {
+      turnId: 't1',
+      toolCallId: 'c_mpg',
+      args: { path: '/workspace/sample.mpg' },
+      signal,
+    });
+
+    const parts = outputParts(result);
+    expect(parts[1]).toEqual({ type: 'text', text: '<video path="/workspace/sample.mpg">' });
+    expect((parts[2] as { videoUrl: { url: string } }).videoUrl.url).toBe(
+      `data:video/mpeg;base64,${data.toString('base64')}`,
+    );
+  });
+
   it('uses injected videoUploader for video files when available', async () => {
     const videoUploader = vi.fn().mockResolvedValue({
       type: 'video_url',

From 35a3b37726b06f077f0b7e708148e5abd63dcf42 Mon Sep 17 00:00:00 2001
From: "haozhe.yang" <yanghaozhe@moonshot.ai>
Date: Mon, 15 Jun 2026 13:37:32 +0800
Subject: [PATCH 15/17] feat(config): add config API endpoint with redaction
 support

add GET/POST /api/v1/config routes\nadd ConfigService and config protocol schemas\nredact api_key in config response\nadd web client bindings and config event handling\nadd e2e tests for config routes and ws-broadcast
---
 apps/kimi-web/src/api/daemon/client.ts        |  46 ++++++
 apps/kimi-web/src/api/daemon/eventReducer.ts  |   8 +
 apps/kimi-web/src/api/daemon/mappers.ts       |  43 +++++
 apps/kimi-web/src/api/daemon/wire.ts          |  37 +++++
 apps/kimi-web/src/api/types.ts                |  35 ++++
 .../src/composables/useKimiWebClient.ts       |  28 +++-
 packages/protocol/src/events.ts               |  14 ++
 packages/protocol/src/index.ts                |   1 +
 packages/protocol/src/rest/config.ts          |  56 +++++++
 packages/server/src/routes/config.ts          |  74 +++++++++
 .../server/src/routes/registerApiV1Routes.ts  |   2 +
 .../services/gateway/wsBroadcastService.ts    |   2 +-
 packages/server/test/config.e2e.test.ts       | 154 ++++++++++++++++++
 packages/server/test/ws-broadcast.e2e.test.ts |  29 ++++
 packages/services/src/config/config.ts        |  12 ++
 packages/services/src/config/configService.ts | 110 +++++++++++++
 packages/services/src/index.ts                |   3 +
 17 files changed, 652 insertions(+), 2 deletions(-)
 create mode 100644 packages/protocol/src/rest/config.ts
 create mode 100644 packages/server/src/routes/config.ts
 create mode 100644 packages/server/test/config.e2e.test.ts
 create mode 100644 packages/services/src/config/config.ts
 create mode 100644 packages/services/src/config/configService.ts

diff --git a/apps/kimi-web/src/api/daemon/client.ts b/apps/kimi-web/src/api/daemon/client.ts
index 78cb3ac4c..bae735ceb 100644
--- a/apps/kimi-web/src/api/daemon/client.ts
+++ b/apps/kimi-web/src/api/daemon/client.ts
@@ -4,6 +4,7 @@
 import type { KimiApiConfig } from '../config';
 import { buildRestUrl, buildWsUrl } from '../config';
 import type {
+  AppConfig,
   AppMessage,
   AppMessageRole,
   AppModel,
@@ -34,6 +35,7 @@ import { createAgentProjector } from './agentEventProjector';
 import { DaemonHttpClient } from './http';
 import {
   toAppApprovalRequest,
+  toAppConfig,
   toAppEvent,
   toAppFsEntry,
   toAppMessage,
@@ -53,6 +55,7 @@ import {
 import type {
   WireAuthResult,
   WireBackgroundTask,
+  WireConfig,
   WireEvent,
   WireFileMeta,
   WireFsBrowseResult,
@@ -1001,6 +1004,49 @@ export class DaemonKimiWebApi implements KimiWebApi {
     return toAppProvider(data);
   }
 
+  // -------------------------------------------------------------------------
+  // Config — REAL endpoints
+  // -------------------------------------------------------------------------
+
+  async getConfig(): Promise<AppConfig> {
+    const data = await this.http.get<WireConfig>('/config');
+    return toAppConfig(data);
+  }
+
+  async setConfig(patch: Partial<AppConfig>): Promise<AppConfig> {
+    const wirePatch: Record<string, unknown> = {};
+    const keyMap: Record<keyof AppConfig, string> = {
+      providers: 'providers',
+      defaultProvider: 'default_provider',
+      defaultModel: 'default_model',
+      models: 'models',
+      thinking: 'thinking',
+      planMode: 'plan_mode',
+      yolo: 'yolo',
+      defaultThinking: 'default_thinking',
+      defaultPermissionMode: 'default_permission_mode',
+      defaultPlanMode: 'default_plan_mode',
+      permission: 'permission',
+      hooks: 'hooks',
+      services: 'services',
+      mergeAllAvailableSkills: 'merge_all_available_skills',
+      extraSkillDirs: 'extra_skill_dirs',
+      loopControl: 'loop_control',
+      background: 'background',
+      experimental: 'experimental',
+      telemetry: 'telemetry',
+      raw: 'raw',
+    };
+    for (const [key, value] of Object.entries(patch)) {
+      const wireKey = keyMap[key as keyof AppConfig];
+      if (wireKey !== undefined) {
+        wirePatch[wireKey] = value;
+      }
+    }
+    const data = await this.http.post<WireConfig>('/config', wirePatch);
+    return toAppConfig(data);
+  }
+
   // -------------------------------------------------------------------------
   // Auth — REAL endpoints
   // -------------------------------------------------------------------------
diff --git a/apps/kimi-web/src/api/daemon/eventReducer.ts b/apps/kimi-web/src/api/daemon/eventReducer.ts
index 4160f8811..0f71d4572 100644
--- a/apps/kimi-web/src/api/daemon/eventReducer.ts
+++ b/apps/kimi-web/src/api/daemon/eventReducer.ts
@@ -10,6 +10,7 @@
 
 import type {
   AppApprovalRequest,
+  AppConfig,
   AppEvent,
   AppGoal,
   AppMessage,
@@ -47,6 +48,7 @@ export interface KimiClientState {
   goalBySession: Record<string, AppGoal>;
   lastSeqBySession: Record<string, number>;
   compactionBySession: Record<string, CompactionStatus>;
+  config?: AppConfig | null;
   warnings: AppWarning[];
 }
 
@@ -499,6 +501,12 @@ export function reduceAppEvent(
       break;
     }
 
+    // -------------------------------------------------------------------------
+    case 'configChanged': {
+      next.config = event.config;
+      break;
+    }
+
     // -------------------------------------------------------------------------
     case 'unknown': {
       // Distinguish no-op known events (sentinel _noop) from agent errors/warnings
diff --git a/apps/kimi-web/src/api/daemon/mappers.ts b/apps/kimi-web/src/api/daemon/mappers.ts
index 897993979..42af704e8 100644
--- a/apps/kimi-web/src/api/daemon/mappers.ts
+++ b/apps/kimi-web/src/api/daemon/mappers.ts
@@ -4,6 +4,7 @@
 
 import type {
   AppApprovalRequest,
+  AppConfig,
   AppEvent,
   AppGoal,
   AppModel,
@@ -49,6 +50,7 @@ import type {
   WireSessionUsage,
   WireWorkspace,
   WireEvent,
+  WireConfig,
 } from './wire';
 
 // ---------------------------------------------------------------------------
@@ -628,6 +630,13 @@ export function toAppEvent(wire: WireEvent): AppEvent {
         outputBytes: w.payload.output_bytes,
       };
 
+    case 'event.config.changed':
+      return {
+        type: 'configChanged',
+        changedFields: w.payload.changed_fields,
+        config: toAppConfig(w.payload.config),
+      };
+
     default: {
       // Truly unknown event — record warning
       return { type: 'unknown', raw: wire };
@@ -663,6 +672,40 @@ export function toAppProvider(wire: WireProvider): AppProvider {
   };
 }
 
+export function toAppConfig(wire: WireConfig): AppConfig {
+  const providers: Record<string, { type: string; baseUrl?: string; defaultModel?: string; hasApiKey: boolean }> = {};
+  for (const [id, provider] of Object.entries(wire.providers)) {
+    providers[id] = {
+      type: provider.type,
+      baseUrl: provider.base_url,
+      defaultModel: provider.default_model,
+      hasApiKey: provider.has_api_key,
+    };
+  }
+  return {
+    providers,
+    defaultProvider: wire.default_provider,
+    defaultModel: wire.default_model,
+    models: wire.models,
+    thinking: wire.thinking,
+    planMode: wire.plan_mode,
+    yolo: wire.yolo,
+    defaultThinking: wire.default_thinking,
+    defaultPermissionMode: wire.default_permission_mode,
+    defaultPlanMode: wire.default_plan_mode,
+    permission: wire.permission,
+    hooks: wire.hooks,
+    services: wire.services,
+    mergeAllAvailableSkills: wire.merge_all_available_skills,
+    extraSkillDirs: wire.extra_skill_dirs,
+    loopControl: wire.loop_control,
+    background: wire.background,
+    experimental: wire.experimental,
+    telemetry: wire.telemetry,
+    raw: wire.raw,
+  };
+}
+
 // Helper to extract sessionId from a WireEvent (needed by reducer for lastSeq update)
 export function wireEventSessionId(wire: WireEvent): string {
   return wire.session_id;
diff --git a/apps/kimi-web/src/api/daemon/wire.ts b/apps/kimi-web/src/api/daemon/wire.ts
index 30d525b35..d97092c52 100644
--- a/apps/kimi-web/src/api/daemon/wire.ts
+++ b/apps/kimi-web/src/api/daemon/wire.ts
@@ -338,6 +338,36 @@ export interface WireProvider {
   models?: string[];
 }
 
+export interface WireConfigProvider {
+  type: string;
+  base_url?: string;
+  default_model?: string;
+  has_api_key: boolean;
+}
+
+export interface WireConfig {
+  providers: Record<string, WireConfigProvider>;
+  default_provider?: string;
+  default_model?: string;
+  models?: Record<string, unknown>;
+  thinking?: unknown;
+  plan_mode?: boolean;
+  yolo?: boolean;
+  default_thinking?: boolean;
+  default_permission_mode?: string;
+  default_plan_mode?: boolean;
+  permission?: unknown;
+  hooks?: unknown[];
+  services?: unknown;
+  merge_all_available_skills?: boolean;
+  extra_skill_dirs?: string[];
+  loop_control?: unknown;
+  background?: unknown;
+  experimental?: Record<string, boolean>;
+  telemetry?: boolean;
+  raw?: Record<string, unknown>;
+}
+
 // ---------------------------------------------------------------------------
 // Auth wire DTOs — REAL endpoints (GET /api/v1/auth, POST/GET/DELETE /api/v1/oauth/login, POST /api/v1/oauth/logout)
 // ---------------------------------------------------------------------------
@@ -686,6 +716,11 @@ type WireEventTaskCompleted = WireEventBase<'event.task.completed', {
   output_bytes?: number;
 }>;
 
+type WireEventConfigChanged = WireEventBase<'event.config.changed', {
+  changed_fields: string[];
+  config: WireConfig;
+}>;
+
 /** Catch-all for unrecognised event frames — keeps lastSeq advancing without warnings */
 type WireEventUnknown = { type: string; seq: number; session_id: string; timestamp: string; payload: unknown };
 
@@ -729,5 +764,7 @@ export type WireEvent =
   | WireEventTaskCreated
   | WireEventTaskProgress
   | WireEventTaskCompleted
+  // Config
+  | WireEventConfigChanged
   // Unknown / future events
   | WireEventUnknown;
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index 6a2a346ac..fca49f182 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -397,6 +397,7 @@ export type AppEvent =
   | { type: 'taskProgress'; sessionId: string; taskId: string; outputChunk: string; stream: 'stdout' | 'stderr' }
   | { type: 'taskCompleted'; sessionId: string; taskId: string; status: AppTaskStatus; outputPreview?: string; outputBytes?: number }
   | { type: 'goalUpdated'; sessionId: string; goal: AppGoal | null }
+  | { type: 'configChanged'; changedFields: string[]; config: AppConfig }
   | { type: 'unknown'; raw: unknown };
 
 // ---------------------------------------------------------------------------
@@ -513,6 +514,36 @@ export interface AppProvider {
   models?: string[];
 }
 
+export interface AppConfigProvider {
+  type: string;
+  baseUrl?: string;
+  defaultModel?: string;
+  hasApiKey: boolean;
+}
+
+export interface AppConfig {
+  providers: Record<string, AppConfigProvider>;
+  defaultProvider?: string;
+  defaultModel?: string;
+  models?: Record<string, unknown>;
+  thinking?: unknown;
+  planMode?: boolean;
+  yolo?: boolean;
+  defaultThinking?: boolean;
+  defaultPermissionMode?: string;
+  defaultPlanMode?: boolean;
+  permission?: unknown;
+  hooks?: unknown[];
+  services?: unknown;
+  mergeAllAvailableSkills?: boolean;
+  extraSkillDirs?: string[];
+  loopControl?: unknown;
+  background?: unknown;
+  experimental?: Record<string, boolean>;
+  telemetry?: boolean;
+  raw?: Record<string, unknown>;
+}
+
 /** A session-scoped skill the user can invoke from the slash menu. */
 export interface AppSkill {
   name: string;
@@ -589,6 +620,10 @@ export interface KimiWebApi {
   uploadFile(input: { file: Blob; name?: string }): Promise<{ id: string; name: string; mediaType: string; size: number }>;
   getFileUrl(fileId: string): string;
 
+  // Config — REAL endpoints
+  getConfig(): Promise<AppConfig>;
+  setConfig(patch: Partial<AppConfig>): Promise<AppConfig>;
+
   // Auth — REAL endpoints
   getAuth(): Promise<{
     ready: boolean;
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index d7b8f7a7c..3b77e1827 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -8,6 +8,7 @@ import { getKimiWebApi } from '../api';
 import { isDaemonApiError, isDaemonNetworkError } from '../api/errors';
 import type {
   AppApprovalRequest,
+  AppConfig,
   AppGoal,
   AppNotice,
   AppNoticeDetail,
@@ -348,6 +349,8 @@ interface ExtendedState extends KimiClientState {
   hiddenWorkspaceRoots: string[];
   /** Installed external apps that can be used with "Open in app". */
   availableOpenInApps: string[];
+  /** Global daemon configuration (secrets redacted). */
+  config: AppConfig | null;
 }
 
 const rawState: ExtendedState = reactive({
@@ -376,6 +379,7 @@ const rawState: ExtendedState = reactive({
   recentRoots: [],
   hiddenWorkspaceRoots: loadHiddenWorkspacesFromStorage(),
   availableOpenInApps: [],
+  config: null,
 });
 
 // Models + Providers reactive state (lazy-loaded, cached)
@@ -1758,6 +1762,7 @@ const sessionCost = computed<number>(() => {
 const authReady = computed<boolean>(() => rawState.authReady);
 const defaultModel = computed<string | null>(() => rawState.defaultModel);
 const managedProviderStatus = computed<string | null>(() => rawState.managedProviderStatus);
+const config = computed<AppConfig | null>(() => rawState.config);
 
 /** path → status map for quick badge lookup in the file tree */
 const changesByPath = computed<Record<string, string>>(() => {
@@ -2082,6 +2087,22 @@ async function checkAuth(): Promise<void> {
   }
 }
 
+/** Fetch global config from GET /api/v1/config. Defensive — never throws. */
+async function loadConfig(): Promise<void> {
+  try {
+    const api = getKimiWebApi();
+    rawState.config = await api.getConfig();
+  } catch {
+    // Daemon may not have this endpoint yet; leave null
+  }
+}
+
+/** Update global config via POST /api/v1/config. */
+async function updateConfig(patch: Partial<AppConfig>): Promise<void> {
+  const api = getKimiWebApi();
+  rawState.config = await api.setConfig(patch);
+}
+
 // False until the very first load() settles (success OR failure). Gates the
 // global connecting-splash so a page refresh doesn't flash a half-empty app.
 const initialized = ref(false);
@@ -2101,8 +2122,9 @@ async function load(): Promise<void> {
       loadModels(),
     ]);
 
-    // Check auth readiness (separate call — defensive)
+    // Check auth readiness and global config (separate calls — defensive)
     await checkAuth();
+    await loadConfig();
 
     rawState.sessions = sessionsPage.items;
 
@@ -3626,6 +3648,10 @@ export function useKimiWebClient() {
     defaultModel,
     managedProviderStatus,
 
+    // Config state + actions
+    config,
+    updateConfig,
+
     // Auth actions
     checkAuth,
     startOAuthLogin,
diff --git a/packages/protocol/src/events.ts b/packages/protocol/src/events.ts
index 8384e1bc0..08d24e487 100644
--- a/packages/protocol/src/events.ts
+++ b/packages/protocol/src/events.ts
@@ -4,6 +4,7 @@ import { ToolInputDisplaySchema, type ToolInputDisplay } from './display';
 import { messageContentSchema, type MessageContent } from './message';
 import { sessionSchema, type Session } from './session';
 import { isoDateTimeSchema } from './time';
+import { configResponseSchema, type ConfigResponse } from './rest/config';
 
 export interface TokenUsage {
   readonly inputOther: number;
@@ -314,6 +315,12 @@ export interface SessionCreatedEvent {
   readonly session: Session;
 }
 
+export interface ConfigChangedEvent {
+  readonly type: 'event.config.changed';
+  readonly changedFields: string[];
+  readonly config: ConfigResponse;
+}
+
 export interface GoalUpdatedEvent {
   readonly type: 'goal.updated';
   readonly snapshot: GoalSnapshot | null;
@@ -559,6 +566,7 @@ export type AgentEvent =
   | AgentStatusUpdatedEvent
   | SessionMetaUpdatedEvent
   | SessionCreatedEvent
+  | ConfigChangedEvent
   | GoalUpdatedEvent
   | SkillActivatedEvent
   | TurnStartedEvent
@@ -905,6 +913,12 @@ export const sessionCreatedEventSchema = z.object({
   session: sessionSchema,
 }) satisfies z.ZodType<SessionCreatedEvent>;
 
+export const configChangedEventSchema = z.object({
+  type: z.literal('event.config.changed'),
+  changedFields: z.array(z.string()),
+  config: configResponseSchema,
+}) satisfies z.ZodType<ConfigChangedEvent>;
+
 export const goalUpdatedEventSchema = z.object({
   type: z.literal('goal.updated'),
   snapshot: goalSnapshotSchema.nullable(),
diff --git a/packages/protocol/src/index.ts b/packages/protocol/src/index.ts
index 0a8c63c6c..10a6b9730 100644
--- a/packages/protocol/src/index.ts
+++ b/packages/protocol/src/index.ts
@@ -37,4 +37,5 @@ export * from './rest/task';
 export * from './rest/fs';
 export * from './rest/file';
 export * from './rest/modelCatalog';
+export * from './rest/config';
 export * from './rest/terminal';
diff --git a/packages/protocol/src/rest/config.ts b/packages/protocol/src/rest/config.ts
new file mode 100644
index 000000000..c7a60d8e3
--- /dev/null
+++ b/packages/protocol/src/rest/config.ts
@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+export const providerConfigResponseSchema = z.object({
+  type: z.string(),
+  base_url: z.string().optional(),
+  default_model: z.string().optional(),
+  has_api_key: z.boolean(),
+});
+export type ProviderConfigResponse = z.infer<typeof providerConfigResponseSchema>;
+
+export const configResponseSchema = z.object({
+  providers: z.record(z.string(), providerConfigResponseSchema).default({}),
+  default_provider: z.string().optional(),
+  default_model: z.string().optional(),
+  models: z.record(z.string(), z.unknown()).optional(),
+  thinking: z.unknown().optional(),
+  plan_mode: z.boolean().optional(),
+  yolo: z.boolean().optional(),
+  default_thinking: z.boolean().optional(),
+  default_permission_mode: z.string().optional(),
+  default_plan_mode: z.boolean().optional(),
+  permission: z.unknown().optional(),
+  hooks: z.array(z.unknown()).optional(),
+  services: z.unknown().optional(),
+  merge_all_available_skills: z.boolean().optional(),
+  extra_skill_dirs: z.array(z.string()).optional(),
+  loop_control: z.unknown().optional(),
+  background: z.unknown().optional(),
+  experimental: z.record(z.string(), z.boolean()).optional(),
+  telemetry: z.boolean().optional(),
+  raw: z.record(z.string(), z.unknown()).optional(),
+});
+export type ConfigResponse = z.infer<typeof configResponseSchema>;
+
+export const patchConfigRequestSchema = z.object({
+  providers: z.record(z.string(), z.unknown()).optional(),
+  default_provider: z.string().optional(),
+  default_model: z.string().optional(),
+  models: z.record(z.string(), z.unknown()).optional(),
+  thinking: z.unknown().optional(),
+  plan_mode: z.boolean().optional(),
+  yolo: z.boolean().optional(),
+  default_thinking: z.boolean().optional(),
+  default_permission_mode: z.string().optional(),
+  default_plan_mode: z.boolean().optional(),
+  permission: z.unknown().optional(),
+  hooks: z.array(z.unknown()).optional(),
+  services: z.unknown().optional(),
+  merge_all_available_skills: z.boolean().optional(),
+  extra_skill_dirs: z.array(z.string()).optional(),
+  loop_control: z.unknown().optional(),
+  background: z.unknown().optional(),
+  experimental: z.record(z.string(), z.boolean()).optional(),
+  telemetry: z.boolean().optional(),
+});
+export type PatchConfigRequest = z.infer<typeof patchConfigRequestSchema>;
diff --git a/packages/server/src/routes/config.ts b/packages/server/src/routes/config.ts
new file mode 100644
index 000000000..4eb44b452
--- /dev/null
+++ b/packages/server/src/routes/config.ts
@@ -0,0 +1,74 @@
+import { z } from 'zod';
+
+import {
+  configResponseSchema,
+  ErrorCode,
+  patchConfigRequestSchema,
+} from '@moonshot-ai/protocol';
+import { IConfigService } from '@moonshot-ai/services';
+import type { IInstantiationService } from '@moonshot-ai/agent-core';
+
+import { errEnvelope, okEnvelope } from '../envelope';
+import { defineRoute } from '../middleware/defineRoute';
+
+interface ConfigRouteHost {
+  get(
+    path: string,
+    options: { schema?: Record<string, unknown> },
+    handler: (
+      req: { id: string },
+      reply: { send(payload: unknown): void },
+    ) => Promise<void> | void,
+  ): unknown;
+  post(
+    path: string,
+    options: { schema?: Record<string, unknown> },
+    handler: (
+      req: { id: string; body: unknown },
+      reply: { send(payload: unknown): void },
+    ) => Promise<void> | void,
+  ): unknown;
+}
+
+export function registerConfigRoutes(app: ConfigRouteHost, ix: IInstantiationService): void {
+  const getRoute = defineRoute(
+    {
+      method: 'GET',
+      path: '/config',
+      success: { data: configResponseSchema },
+      description: 'Get the global Kimi configuration (secrets redacted)',
+      tags: ['config'],
+    },
+    async (req, reply) => {
+      const config = await ix.invokeFunction((a) => a.get(IConfigService).get());
+      reply.send(okEnvelope(config, req.id));
+    },
+  );
+  app.get(getRoute.path, getRoute.options, getRoute.handler as Parameters<ConfigRouteHost['get']>[2]);
+
+  const setRoute = defineRoute(
+    {
+      method: 'POST',
+      path: '/config',
+      body: patchConfigRequestSchema,
+      success: { data: configResponseSchema },
+      errors: {
+        [ErrorCode.VALIDATION_FAILED]: {},
+      },
+      description: 'Update the global Kimi configuration (merge semantics)',
+      tags: ['config'],
+    },
+    async (req, reply) => {
+      try {
+        const config = await ix.invokeFunction((a) =>
+          a.get(IConfigService).set(req.body),
+        );
+        reply.send(okEnvelope(config, req.id));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        reply.send(errEnvelope(ErrorCode.VALIDATION_FAILED, message, req.id));
+      }
+    },
+  );
+  app.post(setRoute.path, setRoute.options, setRoute.handler as Parameters<ConfigRouteHost['post']>[2]);
+}
diff --git a/packages/server/src/routes/registerApiV1Routes.ts b/packages/server/src/routes/registerApiV1Routes.ts
index 0a468258f..8462e2613 100644
--- a/packages/server/src/routes/registerApiV1Routes.ts
+++ b/packages/server/src/routes/registerApiV1Routes.ts
@@ -4,6 +4,7 @@ import { ulid } from 'ulid';
 import { okEnvelope } from '../envelope';
 import { registerApprovalsRoutes } from './approvals';
 import { registerAuthRoute } from './auth';
+import { registerConfigRoutes } from './config';
 import { registerDebugRoutes } from './debug';
 import { registerFilesRoutes } from './files';
 import { registerFsRoutes } from './fs';
@@ -62,6 +63,7 @@ export async function registerApiV1Routes(
     });
 
     registerAuthRoute(apiV1 as unknown as Parameters<typeof registerAuthRoute>[0], ix);
+    registerConfigRoutes(apiV1 as unknown as Parameters<typeof registerConfigRoutes>[0], ix);
     registerOAuthRoutes(apiV1 as unknown as Parameters<typeof registerOAuthRoutes>[0], ix);
     registerModelCatalogRoutes(
       apiV1 as unknown as Parameters<typeof registerModelCatalogRoutes>[0],
diff --git a/packages/server/src/services/gateway/wsBroadcastService.ts b/packages/server/src/services/gateway/wsBroadcastService.ts
index 786483a6d..484128138 100644
--- a/packages/server/src/services/gateway/wsBroadcastService.ts
+++ b/packages/server/src/services/gateway/wsBroadcastService.ts
@@ -240,7 +240,7 @@ function extractSessionId(event: Event): string | undefined {
 }
 
 function isGlobalSessionEvent(type: string): boolean {
-  return type === 'event.session.created';
+  return type === 'event.session.created' || type === 'event.config.changed';
 }
 
 /** Session ids are ULID-ish, but never trust an id used as a path segment. */
diff --git a/packages/server/test/config.e2e.test.ts b/packages/server/test/config.e2e.test.ts
new file mode 100644
index 000000000..6a8c24e01
--- /dev/null
+++ b/packages/server/test/config.e2e.test.ts
@@ -0,0 +1,154 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { pino } from 'pino';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { IRestGateway, startServer, type RunningServer } from '../src';
+
+let tmpDir: string;
+let lockPath: string;
+let bridgeHome: string;
+let server: RunningServer | undefined;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'kimi-server-config-test-'));
+  lockPath = join(tmpDir, 'lock');
+  bridgeHome = mkdtempSync(join(tmpdir(), 'kimi-server-config-home-'));
+});
+
+afterEach(async () => {
+  try {
+    await server?.close();
+  } catch {
+    // ignore
+  }
+  server = undefined;
+  rmSync(tmpDir, { recursive: true, force: true });
+  rmSync(bridgeHome, { recursive: true, force: true });
+});
+
+async function bootDaemon(): Promise<RunningServer> {
+  server = await startServer({
+    host: '127.0.0.1',
+    port: 0,
+    lockPath,
+    logger: pino({ level: 'silent' }),
+    coreProcessOptions: { homeDir: bridgeHome },
+  });
+  return server;
+}
+
+function appOf(r: RunningServer): {
+  inject: (req: unknown) => Promise<{ statusCode: number; json: () => unknown }>;
+} {
+  return r.services.invokeFunction((a) => {
+    const gw = a.get(IRestGateway);
+    return gw.app as unknown as {
+      inject: (req: unknown) => Promise<{ statusCode: number; json: () => unknown }>;
+    };
+  });
+}
+
+function envelopeOf<T>(body: unknown): {
+  code: number;
+  msg: string;
+  data: T | null;
+  request_id: string;
+} {
+  return body as {
+    code: number;
+    msg: string;
+    data: T | null;
+    request_id: string;
+  };
+}
+
+function seedConfig(toml: string): void {
+  writeFileSync(join(bridgeHome, 'config.toml'), toml, 'utf-8');
+}
+
+function seedCatalogConfig(): void {
+  seedConfig(
+    [
+      'default_model = "k2"',
+      '',
+      '[providers.kimi]',
+      'type = "kimi"',
+      'api_key = "sk-test"',
+      'base_url = "https://api.example.test/v1"',
+      '',
+      '[providers.openai]',
+      'type = "openai"',
+      '',
+      '[models.k2]',
+      'provider = "kimi"',
+      'model = "kimi-k2"',
+      'max_context_size = 131072',
+      '',
+    ].join('\n'),
+  );
+}
+
+describe('config routes', () => {
+  it('GET /config returns redacted config without api_key', async () => {
+    seedCatalogConfig();
+    const r = await bootDaemon();
+
+    const res = await appOf(r).inject({ method: 'GET', url: '/api/v1/config' });
+    expect(res.statusCode).toBe(200);
+    const env = envelopeOf<{
+      default_model: string;
+      providers: Record<string, unknown>;
+    }>(res.json());
+    expect(env.code).toBe(0);
+    expect(env.data?.default_model).toBe('k2');
+    expect(env.data?.providers).toEqual({
+      kimi: {
+        type: 'kimi',
+        base_url: 'https://api.example.test/v1',
+        has_api_key: true,
+      },
+      openai: {
+        type: 'openai',
+        has_api_key: false,
+      },
+    });
+  });
+
+  it('POST /config merges changes and persists to disk', async () => {
+    seedCatalogConfig();
+    const r = await bootDaemon();
+
+    const setRes = await appOf(r).inject({
+      method: 'POST',
+      url: '/api/v1/config',
+      payload: { default_model: 'gpt4o' },
+    });
+    const setEnv = envelopeOf<{ default_model: string }>(setRes.json());
+    expect(setEnv.code).toBe(0);
+    expect(setEnv.data?.default_model).toBe('gpt4o');
+
+    const text = readFileSync(join(bridgeHome, 'config.toml'), 'utf-8');
+    expect(text).toContain('default_model = "gpt4o"');
+
+    const getRes = await appOf(r).inject({ method: 'GET', url: '/api/v1/config' });
+    const getEnv = envelopeOf<{ default_model: string }>(getRes.json());
+    expect(getEnv.code).toBe(0);
+    expect(getEnv.data?.default_model).toBe('gpt4o');
+  });
+
+  it('POST /config rejects invalid config values', async () => {
+    seedCatalogConfig();
+    const r = await bootDaemon();
+
+    const res = await appOf(r).inject({
+      method: 'POST',
+      url: '/api/v1/config',
+      payload: { default_provider: 123 },
+    });
+    const env = envelopeOf<unknown>(res.json());
+    expect(env.code).toBe(40001);
+  });
+});
diff --git a/packages/server/test/ws-broadcast.e2e.test.ts b/packages/server/test/ws-broadcast.e2e.test.ts
index 1027a9d51..e39644c81 100644
--- a/packages/server/test/ws-broadcast.e2e.test.ts
+++ b/packages/server/test/ws-broadcast.e2e.test.ts
@@ -292,6 +292,35 @@ describe('WS broadcast + per-session seq (W5.2)', () => {
     a.ws.close();
     b.ws.close();
   });
+
+  it('event.config.changed is broadcast to all connections regardless of subscription', async () => {
+    const r = await spawn();
+    const a = await openConn(wsUrl(r.address));
+    const b = await openConn(wsUrl(r.address));
+    // Subscribe to different sessions
+    await helloAndSubscribe(a, 'A', 'sid_a');
+    await helloAndSubscribe(b, 'B', 'sid_b');
+
+    r.services.invokeFunction((acc) =>
+      acc.get(IEventService).publish({
+        type: 'event.config.changed',
+        agentId: 'main',
+        sessionId: '__global__',
+        changedFields: ['default_model'],
+        config: { providers: {} },
+      } as unknown as Event),
+    );
+
+    const evA = await receiveType(a, 'event.config.changed', 1000);
+    const evB = await receiveType(b, 'event.config.changed', 1000);
+    expect(evA.session_id).toBe('__global__');
+    expect(evB.session_id).toBe('__global__');
+    expect(evA.seq).toBe(1);
+    expect(evB.seq).toBe(1);
+
+    a.ws.close();
+    b.ws.close();
+  });
 });
 
 /** Spin until `cond()` returns true or 2s elapses. */
diff --git a/packages/services/src/config/config.ts b/packages/services/src/config/config.ts
new file mode 100644
index 000000000..7f0d7e7a8
--- /dev/null
+++ b/packages/services/src/config/config.ts
@@ -0,0 +1,12 @@
+import { createDecorator } from '@moonshot-ai/agent-core';
+import type { ConfigResponse, PatchConfigRequest } from '@moonshot-ai/protocol';
+
+export interface IConfigService {
+  readonly _serviceBrand: undefined;
+
+  get(): Promise<ConfigResponse>;
+  set(patch: PatchConfigRequest): Promise<ConfigResponse>;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const IConfigService = createDecorator<IConfigService>('configService');
diff --git a/packages/services/src/config/configService.ts b/packages/services/src/config/configService.ts
new file mode 100644
index 000000000..eec8f48f5
--- /dev/null
+++ b/packages/services/src/config/configService.ts
@@ -0,0 +1,110 @@
+import {
+  Disposable,
+  InstantiationType,
+  registerSingleton,
+} from '@moonshot-ai/agent-core';
+import type { KimiConfig, ProviderConfig } from '@moonshot-ai/agent-core';
+import type { ConfigResponse, PatchConfigRequest } from '@moonshot-ai/protocol';
+
+import { ICoreProcessService } from '../coreProcess/coreProcess';
+import { IEventService } from '../event/event';
+import { IConfigService } from './config';
+
+export class ConfigService extends Disposable implements IConfigService {
+  readonly _serviceBrand: undefined;
+
+  constructor(
+    @ICoreProcessService private readonly core: ICoreProcessService,
+    @IEventService private readonly eventService: IEventService,
+  ) {
+    super();
+  }
+
+  async get(): Promise<ConfigResponse> {
+    const config = await this.core.rpc.getKimiConfig({ reload: true });
+    return toConfigResponse(config);
+  }
+
+  async set(patch: PatchConfigRequest): Promise<ConfigResponse> {
+    const camelPatch = convertKeysSnakeToCamel(patch) as Record<string, unknown>;
+    const updated = await this.core.rpc.setKimiConfig(camelPatch);
+    const response = toConfigResponse(updated);
+
+    this.eventService.publish({
+      type: 'event.config.changed',
+      agentId: 'main',
+      sessionId: '__global__',
+      changedFields: Object.keys(patch),
+      config: response,
+    });
+
+    return response;
+  }
+}
+
+function toConfigResponse(config: KimiConfig): ConfigResponse {
+  const providers: Record<string, { type: string; base_url?: string; default_model?: string; has_api_key: boolean }> = {};
+  for (const [providerId, provider] of Object.entries(config.providers ?? {})) {
+    providers[providerId] = {
+      type: provider.type,
+      base_url: provider.baseUrl,
+      default_model: provider.defaultModel,
+      has_api_key: hasProviderCredential(provider),
+    };
+  }
+
+  return {
+    providers,
+    default_provider: config.defaultProvider,
+    default_model: config.defaultModel,
+    models: config.models,
+    thinking: config.thinking,
+    plan_mode: config.planMode,
+    yolo: config.yolo,
+    default_thinking: config.defaultThinking,
+    default_permission_mode: config.defaultPermissionMode,
+    default_plan_mode: config.defaultPlanMode,
+    permission: config.permission,
+    hooks: config.hooks,
+    services: config.services,
+    merge_all_available_skills: config.mergeAllAvailableSkills,
+    extra_skill_dirs: config.extraSkillDirs,
+    loop_control: config.loopControl,
+    background: config.background,
+    experimental: config.experimental,
+    telemetry: config.telemetry,
+    raw: config.raw,
+  };
+}
+
+function hasProviderCredential(provider: ProviderConfig): boolean {
+  if (nonEmpty(provider.apiKey) !== undefined) return true;
+  if (provider.oauth !== undefined) return true;
+  return false;
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+  if (value === undefined) return undefined;
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? undefined : trimmed;
+}
+
+function convertKeysSnakeToCamel(obj: unknown): unknown {
+  if (Array.isArray(obj)) {
+    return obj.map(convertKeysSnakeToCamel);
+  }
+  if (obj !== null && typeof obj === 'object') {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[snakeToCamel(key)] = convertKeysSnakeToCamel(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+function snakeToCamel(str: string): string {
+  return str.replaceAll(/_([a-z])/g, (_, ch: string) => ch.toUpperCase());
+}
+
+registerSingleton(IConfigService, ConfigService, InstantiationType.Delayed);
diff --git a/packages/services/src/index.ts b/packages/services/src/index.ts
index 2c4765338..bc47e0558 100644
--- a/packages/services/src/index.ts
+++ b/packages/services/src/index.ts
@@ -118,6 +118,9 @@ export {
 export type { ProviderCredentialState } from './modelCatalog/modelCatalog';
 export { ModelCatalogService } from './modelCatalog/modelCatalogService';
 
+export { IConfigService } from './config/config';
+export { ConfigService } from './config/configService';
+
 export {
   ISessionService,
   SessionNotFoundError,

From 4fa5607b4525f4aceba8560cd53459f904ddf06c Mon Sep 17 00:00:00 2001
From: "haozhe.yang" <yanghaozhe@moonshot.ai>
Date: Mon, 15 Jun 2026 20:24:37 +0800
Subject: [PATCH 16/17] feat(session): add session-level abort and expose
 current_prompt_id in snapshot

- add POST /sessions/{sid}:abort to cancel running turns without prompt_id\n- expose current_prompt_id in in-flight turn snapshot\n- wire session-level abort fallback in kimi-web stop button\n- add IPromptService.abortBySession and getCurrentPromptId\n- update protocol, server, services, and web tests
---
 .../src/api/daemon/agentEventProjector.ts     |  2 +-
 apps/kimi-web/src/api/daemon/client.ts        | 12 +++
 apps/kimi-web/src/api/daemon/wire.ts          |  5 ++
 apps/kimi-web/src/api/types.ts                |  4 +
 .../src/composables/useKimiWebClient.ts       | 65 +++++++++++++--
 .../protocol/src/__tests__/snapshot.test.ts   | 24 ++++++
 packages/protocol/src/rest/session.ts         |  5 ++
 packages/protocol/src/rest/snapshot.ts        |  2 +
 packages/server/src/routes/sessions.ts        | 14 +++-
 packages/server/src/routes/snapshot.ts        | 10 ++-
 packages/server/test/prompt.e2e.test.ts       | 57 +++++++++++++
 packages/server/test/snapshot.e2e.test.ts     | 35 +++++++-
 packages/services/src/prompt/prompt.ts        | 23 +++++
 packages/services/src/prompt/promptService.ts | 22 +++++
 packages/services/test/prompt-service.test.ts | 83 +++++++++++++++++++
 .../services/test/session-service.test.ts     |  2 +
 16 files changed, 354 insertions(+), 11 deletions(-)

diff --git a/apps/kimi-web/src/api/daemon/agentEventProjector.ts b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
index fea2c683f..05878a476 100644
--- a/apps/kimi-web/src/api/daemon/agentEventProjector.ts
+++ b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
@@ -410,7 +410,7 @@ export function createAgentProjector(): AgentProjector {
     reset(sessionId);
     const s = getOrCreate(sessionId);
 
-    const promptId = ulid('pr_');
+    const promptId = turn.promptId ?? ulid('pr_');
     s.currentPromptId = promptId;
     s.turnPromptId.set(turn.turnId, promptId);
 
diff --git a/apps/kimi-web/src/api/daemon/client.ts b/apps/kimi-web/src/api/daemon/client.ts
index bae735ceb..f8905adf0 100644
--- a/apps/kimi-web/src/api/daemon/client.ts
+++ b/apps/kimi-web/src/api/daemon/client.ts
@@ -71,6 +71,7 @@ import type {
   WirePromptSteerResult,
   WireProvider,
   WireSession,
+  WireSessionAbortResult,
   WireSessionRuntimeStatus,
   WireSessionSnapshot,
   WireWorkspace,
@@ -444,6 +445,7 @@ export class DaemonKimiWebApi implements KimiWebApi {
                 description: t.description,
                 lastProgress: t.last_progress,
               })),
+              promptId: data.in_flight_turn.current_prompt_id,
             },
       pendingApprovals: data.pending_approvals.map(toAppApprovalRequest),
       pendingQuestions: data.pending_questions.map(toAppQuestionRequest),
@@ -497,6 +499,16 @@ export class DaemonKimiWebApi implements KimiWebApi {
     return { aborted: data.aborted, atSeq: data.at_seq };
   }
 
+  // POST /sessions/{id}:abort — cancel whatever is running in the session,
+  // including skill activations that bypass IPromptService.
+  async abortSession(sessionId: string): Promise<{ aborted: boolean }> {
+    const data = await this.http.post<WireSessionAbortResult>(
+      `/sessions/${encodeURIComponent(sessionId)}:abort`,
+      {},
+    );
+    return { aborted: data.aborted };
+  }
+
   // POST /sessions/{id}:compact — request history compaction. Returns {};
   // progress and completion arrive via the WS compaction.* events (the
   // transcript itself is not reloaded — a divider marker is appended).
diff --git a/apps/kimi-web/src/api/daemon/wire.ts b/apps/kimi-web/src/api/daemon/wire.ts
index d97092c52..6269e0399 100644
--- a/apps/kimi-web/src/api/daemon/wire.ts
+++ b/apps/kimi-web/src/api/daemon/wire.ts
@@ -505,6 +505,7 @@ export interface WireInFlightTurn {
   assistant_text: string;
   thinking_text: string;
   running_tools: WireInFlightToolCall[];
+  current_prompt_id?: string;
 }
 
 /** `GET /sessions/{sid}/snapshot` — atomic rebuild state at a watermark. */
@@ -518,6 +519,10 @@ export interface WireSessionSnapshot {
   pending_questions: WireQuestionRequest[];
 }
 
+export interface WireSessionAbortResult {
+  aborted: boolean;
+}
+
 export interface WireErrorFrame {
   type: 'error';
   timestamp: string;
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index fca49f182..19a65f773 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -424,6 +424,8 @@ export interface AppInFlightTurn {
   assistantText: string;
   thinkingText: string;
   runningTools: AppInFlightToolCall[];
+  /** Authoritative daemon prompt_id for the active prompt, if known. */
+  promptId?: string;
 }
 
 /**
@@ -573,6 +575,8 @@ export interface KimiWebApi {
   /** Steer daemon-queued prompts into the active turn (TUI ctrl+s). */
   steerPrompts(sessionId: string, promptIds: string[]): Promise<{ steered: boolean; promptIds: string[] }>;
   abortPrompt(sessionId: string, promptId: string): Promise<{ aborted: boolean; atSeq?: number }>;
+  /** Cancel whatever is running in the session, including skill activations. */
+  abortSession(sessionId: string): Promise<{ aborted: boolean }>;
   compactSession(sessionId: string, instruction?: string): Promise<void>;
   undoSession(sessionId: string, count?: number): Promise<void>;
   forkSession(sessionId: string, input?: { title?: string }): Promise<AppSession>;
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 3b77e1827..72cfccf95 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -70,6 +70,7 @@ const PLAN_MODE_STORAGE_KEY = 'kimi-web.plan-mode';
 const SWARM_MODE_STORAGE_KEY = 'kimi-web.swarm-mode';
 const THEME_STORAGE_KEY = 'kimi-web.theme';
 const SESSION_NOT_FOUND_CODE = 40401;
+const PROMPT_NOT_FOUND_CODE = 40402;
 const ONBOARDED_STORAGE_KEY = 'kimi-web.onboarded';
 const THINKING_LEVELS: readonly ThinkingLevel[] = ['off', 'low', 'medium', 'high', 'xhigh', 'max'];
 
@@ -744,6 +745,23 @@ function connectEventsIfNeeded(): void {
       // is kept, only a marker line records the compaction).
       applyEvent(appEvent, meta.sessionId, meta.seq);
 
+      // The daemon's prompt.submitted event is projected as a user messageCreated
+      // carrying the real prompt_id. When the HTTP submit response is lost
+      // (timeout / network error) this is the fallback that lets Stop work.
+      if (
+        appEvent.type === 'messageCreated' &&
+        appEvent.message.role === 'user' &&
+        appEvent.message.promptId !== undefined
+      ) {
+        const sid = appEvent.message.sessionId;
+        if (rawState.promptIdBySession[sid] !== appEvent.message.promptId) {
+          rawState.promptIdBySession = {
+            ...rawState.promptIdBySession,
+            [sid]: appEvent.message.promptId,
+          };
+        }
+      }
+
       if (appEvent.type === 'assistantDelta' && meta.sessionId === rawState.activeSessionId) {
         recordMoonDelta((appEvent.delta.text?.length ?? 0) + (appEvent.delta.thinking?.length ?? 0));
       }
@@ -1982,6 +2000,13 @@ function onSessionIdle(sid: string): void {
   // The turn finished — this session no longer has a prompt in flight.
   inFlightPromptSessions.delete(sid);
   rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: false };
+  // Drop any cached prompt_id so a later skill activation (which has no
+  // prompt_id) doesn't accidentally reuse this stale id for :abort.
+  if (rawState.promptIdBySession[sid] !== undefined) {
+    const next = { ...rawState.promptIdBySession };
+    delete next[sid];
+    rawState.promptIdBySession = next;
+  }
 
   // For the session on screen, refresh git status (edits the agent just made)
   // and runtime status (model/context usage may have changed this turn).
@@ -2780,13 +2805,41 @@ async function abortCurrentPrompt(): Promise<void> {
   const sid = rawState.activeSessionId;
   if (!sid) return;
   const session = rawState.sessions.find((s) => s.id === sid);
-  // Prefer the authoritative prompt_id captured at submit time; fall back to the
-  // projector-derived one only if we never recorded a submit (e.g. resumed turn).
-  const promptId = rawState.promptIdBySession[sid] ?? session?.currentPromptId;
-  if (!promptId) return;
+
+  // 1. Authoritative id captured at submit time.
+  let promptId = rawState.promptIdBySession[sid];
+
+  // 2. Fallback to projector-derived id only when it is a real daemon prompt_id
+  //    (synthetic `pr_...` ids are rejected by the daemon).
+  if (promptId === undefined) {
+    const candidate = session?.currentPromptId;
+    if (candidate?.startsWith('prompt_')) {
+      promptId = candidate;
+    }
+  }
+
+  const api = getKimiWebApi();
+
+  // 3. If we have a real id, try the per-prompt abort first. On 40402 fall back
+  //    to session-level abort (the daemon may have restarted or the id is stale).
+  if (promptId !== undefined) {
+    try {
+      await api.abortPrompt(sid, promptId);
+      return;
+    } catch (err) {
+      if (isDaemonApiError(err) && err.code === PROMPT_NOT_FOUND_CODE) {
+        // Stale id — try the session-level fallback below.
+      } else {
+        pushOperationFailure('abortCurrentPrompt', err, { sessionId: sid });
+        return;
+      }
+    }
+  }
+
+  // 4. No real id, or the prompt id is no longer recognized: cancel whatever
+  //    is running in the session (including skill activations).
   try {
-    const api = getKimiWebApi();
-    await api.abortPrompt(sid, promptId);
+    await api.abortSession(sid);
   } catch (err) {
     pushOperationFailure('abortCurrentPrompt', err, { sessionId: sid });
   }
diff --git a/packages/protocol/src/__tests__/snapshot.test.ts b/packages/protocol/src/__tests__/snapshot.test.ts
index ff909d6f9..7baa199e7 100644
--- a/packages/protocol/src/__tests__/snapshot.test.ts
+++ b/packages/protocol/src/__tests__/snapshot.test.ts
@@ -82,6 +82,30 @@ describe('rest/snapshot — session snapshot', () => {
     expect(result.success).toBe(true);
   });
 
+  it('parses an in-flight turn with current_prompt_id', () => {
+    const result = sessionSnapshotResponseSchema.safeParse({
+      as_of_seq: 12,
+      epoch: 'ep_01ABC',
+      session: SESSION,
+      messages: { items: [], has_more: false },
+      in_flight_turn: {
+        turn_id: 3,
+        assistant_text: 'partial answer…',
+        thinking_text: '',
+        running_tools: [],
+        current_prompt_id: 'prompt_01KV589KCS5PG9ZYDNP8KFDQHZ',
+      },
+      pending_approvals: [],
+      pending_questions: [],
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.in_flight_turn?.current_prompt_id).toBe(
+        'prompt_01KV589KCS5PG9ZYDNP8KFDQHZ',
+      );
+    }
+  });
+
   it('rejects a snapshot missing the watermark', () => {
     const result = sessionSnapshotResponseSchema.safeParse({
       epoch: 'ep_01ABC',
diff --git a/packages/protocol/src/rest/session.ts b/packages/protocol/src/rest/session.ts
index 70c20a0dc..50f98fd51 100644
--- a/packages/protocol/src/rest/session.ts
+++ b/packages/protocol/src/rest/session.ts
@@ -123,3 +123,8 @@ export const deleteSessionResponseSchema = z.object({
   deleted: z.literal(true),
 });
 export type DeleteSessionResponse = z.infer<typeof deleteSessionResponseSchema>;
+
+export const sessionAbortResponseSchema = z.object({
+  aborted: z.boolean(),
+});
+export type SessionAbortResponse = z.infer<typeof sessionAbortResponseSchema>;
diff --git a/packages/protocol/src/rest/snapshot.ts b/packages/protocol/src/rest/snapshot.ts
index cf002e6e4..642772b69 100644
--- a/packages/protocol/src/rest/snapshot.ts
+++ b/packages/protocol/src/rest/snapshot.ts
@@ -54,6 +54,8 @@ export const inFlightTurnSchema = z.object({
   thinking_text: z.string(),
   /** Tool calls started but without a `tool.result` yet. */
   running_tools: z.array(inFlightToolCallSchema),
+  /** Daemon prompt_id of the active prompt, if the turn was started by IPromptService. */
+  current_prompt_id: z.string().optional(),
 });
 export type InFlightTurn = z.infer<typeof inFlightTurnSchema>;
 
diff --git a/packages/server/src/routes/sessions.ts b/packages/server/src/routes/sessions.ts
index 3f69e9ce2..4432151fc 100644
--- a/packages/server/src/routes/sessions.ts
+++ b/packages/server/src/routes/sessions.ts
@@ -11,6 +11,7 @@ import {
   forkSessionRequestSchema,
   listSessionChildrenResponseSchema,
   pageResponseSchema,
+  sessionAbortResponseSchema,
   sessionSchema,
   sessionStatusResponseSchema,
   sessionStatusSchema,
@@ -20,6 +21,7 @@ import {
   workspaceIdSchema,
 } from '@moonshot-ai/protocol';
 import {
+  IPromptService,
   ISessionService,
   SessionNotFoundError,
   SessionUndoUnavailableError,
@@ -366,7 +368,7 @@ export function registerSessionsRoutes(
       path: '/sessions/{tail}',
       params: sessionActionTailParamSchema,
       body: sessionActionRequestSchema,
-      success: { data: z.union([sessionSchema, compactSessionResponseSchema, undoSessionResponseSchema]) },
+      success: { data: z.union([sessionSchema, compactSessionResponseSchema, undoSessionResponseSchema, sessionAbortResponseSchema]) },
       errors: {
         [ErrorCode.VALIDATION_FAILED]: { detailsSchema },
         [ErrorCode.SESSION_NOT_FOUND]: {},
@@ -383,7 +385,7 @@ export function registerSessionsRoutes(
         const { tail } = req.params;
         const parsed = parseActionSuffix({
           tail,
-          allowedActions: ['fork', 'compact', 'undo'] as const,
+          allowedActions: ['fork', 'compact', 'undo', 'abort'] as const,
           resourceLabel: 'session',
         });
         if (parsed.kind !== 'action') {
@@ -417,6 +419,14 @@ export function registerSessionsRoutes(
           return;
         }
 
+        if (parsed.action === 'abort') {
+          const result = await ix.invokeFunction((a) =>
+            a.get(IPromptService).abortBySession(parsed.id),
+          );
+          reply.send(okEnvelope(result, req.id));
+          return;
+        }
+
         const body = undoSessionRequestSchema.parse(req.body);
         const result = await ix.invokeFunction((a) =>
           a.get(ISessionService).undo(parsed.id, body),
diff --git a/packages/server/src/routes/snapshot.ts b/packages/server/src/routes/snapshot.ts
index 918f4869f..7d986993a 100644
--- a/packages/server/src/routes/snapshot.ts
+++ b/packages/server/src/routes/snapshot.ts
@@ -30,6 +30,7 @@ import {
 import {
   IApprovalService,
   IMessageService,
+  IPromptService,
   IQuestionService,
   ISessionService,
   SessionNotFoundError,
@@ -86,6 +87,7 @@ export function registerSnapshotRoutes(
           const broadcast = a.get(IWSBroadcastService);
           const sessionService = a.get(ISessionService);
           const messageService = a.get(IMessageService);
+          const promptService = a.get(IPromptService);
           const approvals = a.get(IApprovalService) as ApprovalService;
           const questions = a.get(IQuestionService) as QuestionService;
 
@@ -109,12 +111,18 @@ export function registerSnapshotRoutes(
             if (stable) break;
           }
 
+          const currentPromptId = promptService.getCurrentPromptId(session_id);
+          const inFlightTurn = snapState.inFlightTurn;
+          if (inFlightTurn !== null && currentPromptId !== undefined) {
+            inFlightTurn.current_prompt_id = currentPromptId;
+          }
+
           return {
             as_of_seq: snapState.seq,
             epoch: snapState.epoch,
             session: session!,
             messages: { items, has_more: hasMore },
-            in_flight_turn: snapState.inFlightTurn,
+            in_flight_turn: inFlightTurn,
             pending_approvals: approvals.listPending(session_id),
             pending_questions: questions.listPending(session_id),
           };
diff --git a/packages/server/test/prompt.e2e.test.ts b/packages/server/test/prompt.e2e.test.ts
index fe528f76c..40ded91a6 100644
--- a/packages/server/test/prompt.e2e.test.ts
+++ b/packages/server/test/prompt.e2e.test.ts
@@ -118,6 +118,8 @@ function createPromptServiceOverride(
       prompt_ids: [...promptIds],
     }),
     abort: async () => ({ aborted: true }),
+    abortBySession: async () => ({ aborted: true }),
+    getCurrentPromptId: () => undefined,
     applyAgentState: async () => undefined,
     getAgentStateSnapshot: () => undefined,
     onDidComplete: noopComplete,
@@ -750,3 +752,58 @@ describe('Prompt lifecycle: WS receives events + synthesized prompt.completed (W
     ws.close();
   });
 });
+
+describe('POST /api/v1/sessions/{sid}:abort — session-level cancel', () => {
+  it('cancels an active daemon prompt', async () => {
+    const r = await bootDaemon();
+    const sid = await createSession(r);
+
+    const promptId = `prompt_SESSION_ABORT_${sid}`;
+    const turnId = 9;
+    const impl = r.services.invokeFunction(
+      (a) => a.get(IPromptService) as PromptService,
+    );
+    impl._injectActiveForTest(sid, promptId, turnId);
+
+    const res = await appOf(r).inject({
+      method: 'POST',
+      url: `/api/v1/sessions/${sid}:abort`,
+    });
+    const env = envelopeOf<{ aborted: boolean }>(res.json());
+    expect(env.code).toBe(0);
+    expect(env.data).toEqual({ aborted: true });
+  });
+
+  it('cancels a non-prompt turn (skill activation) without requiring prompt_id', async () => {
+    const r = await bootDaemon();
+    const sid = await createSession(r);
+
+    // Publish a running turn without creating a daemon prompt.
+    const eventBus = r.services.invokeFunction((a) => a.get(IEventService));
+    eventBus.publish({
+      type: 'turn.started',
+      turnId: 3,
+      origin: { kind: 'skill_activation', skillName: 'demo', activationId: 'act_1' },
+      sessionId: sid,
+      agentId: 'main',
+    } as unknown as Event);
+
+    const res = await appOf(r).inject({
+      method: 'POST',
+      url: `/api/v1/sessions/${sid}:abort`,
+    });
+    const env = envelopeOf<{ aborted: boolean }>(res.json());
+    expect(env.code).toBe(0);
+    expect(env.data).toEqual({ aborted: true });
+  });
+
+  it('returns 40401 for an unknown session id', async () => {
+    const r = await bootDaemon();
+    const res = await appOf(r).inject({
+      method: 'POST',
+      url: '/api/v1/sessions/sess_missing:abort',
+    });
+    const env = envelopeOf<unknown>(res.json());
+    expect(env.code).toBe(40401);
+  });
+});
diff --git a/packages/server/test/snapshot.e2e.test.ts b/packages/server/test/snapshot.e2e.test.ts
index b0e5ab755..59768cdb4 100644
--- a/packages/server/test/snapshot.e2e.test.ts
+++ b/packages/server/test/snapshot.e2e.test.ts
@@ -22,7 +22,7 @@ import { pino } from 'pino';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import type { Event, SessionSnapshotResponse } from '@moonshot-ai/protocol';
-import { IEventService } from '@moonshot-ai/services';
+import { IEventService, IPromptService, PromptService } from '@moonshot-ai/services';
 
 import { IRestGateway, IWSBroadcastService, startServer, type RunningServer } from '../src';
 import { WSBroadcastService } from '#/services/gateway/wsBroadcastService';
@@ -207,6 +207,39 @@ describe('GET /api/v1/sessions/{sid}/snapshot (v2 initial sync)', () => {
     expect(after.env.data!.in_flight_turn).toBeNull();
   });
 
+  it('in_flight_turn carries current_prompt_id from the active prompt', async () => {
+    const r = await bootDaemon();
+    const sid = await createSession(r);
+    const bus = r.services.invokeFunction((a) => a.get(IEventService));
+
+    bus.publish({
+      type: 'turn.started',
+      sessionId: sid,
+      agentId: 'main',
+      turnId: 1,
+      origin: { kind: 'user' },
+    } as unknown as Event);
+    bus.publish({
+      type: 'assistant.delta',
+      sessionId: sid,
+      agentId: 'main',
+      turnId: 1,
+      delta: 'partial',
+    } as unknown as Event);
+
+    // Inject an active prompt record so the snapshot route can read its id.
+    const promptId = `prompt_SNAPSHOT_TEST_${sid}`;
+    const impl = r.services.invokeFunction(
+      (a) => a.get(IPromptService) as PromptService,
+    );
+    impl._injectActiveForTest(sid, promptId, 1);
+
+    const { env } = await getSnapshot(r, sid);
+    const turn = env.data!.in_flight_turn;
+    expect(turn).not.toBeNull();
+    expect(turn!.current_prompt_id).toBe(promptId);
+  });
+
   it('returns 40401 for an unknown session id', async () => {
     const r = await bootDaemon();
     const { env } = await getSnapshot(r, 'sess_missing');
diff --git a/packages/services/src/prompt/prompt.ts b/packages/services/src/prompt/prompt.ts
index 00b31892d..9586a6cae 100644
--- a/packages/services/src/prompt/prompt.ts
+++ b/packages/services/src/prompt/prompt.ts
@@ -154,6 +154,29 @@ export interface IPromptService {
    */
   abort(sid: string, pid: string): Promise<PromptAbortResult>;
 
+  /**
+   * `POST /v1/sessions/{sid}:abort` — cancel whatever is currently running in
+   * the session without requiring a prompt_id.
+   *
+   * If `IPromptService` has an active prompt, this delegates to `abort()` so
+   * the normal synthetic `prompt.aborted` event is emitted. Otherwise it calls
+   * `core.rpc.cancel({ sessionId, agentId: 'main' })` without a `turnId`, which
+   * cancels any active agent-core turn (including skill activations).
+   *
+   * Returns `{ aborted: true }` when a cancel RPC was issued, `{ aborted: false }`
+   * when the session was idle. Throws `SessionNotFoundError` (→ 40401) for
+   * unknown `sid`.
+   */
+  abortBySession(sid: string): Promise<PromptAbortResult>;
+
+  /**
+   * Return the daemon prompt_id currently active for a session, if any.
+   * Returns `undefined` when the session is idle or the active prompt has
+   * already completed/aborted. Used by the snapshot route to expose the
+   * authoritative id for reconnecting clients.
+   */
+  getCurrentPromptId(sid: string): string | undefined;
+
   /**
    * Apply a partial runtime-controls patch to a session's shadow,
    * diff-dispatching the matching `core.rpc.*` setter for any field that
diff --git a/packages/services/src/prompt/promptService.ts b/packages/services/src/prompt/promptService.ts
index e93088f0e..6c112c962 100644
--- a/packages/services/src/prompt/promptService.ts
+++ b/packages/services/src/prompt/promptService.ts
@@ -487,6 +487,28 @@ export class PromptService
     return { aborted: true };
   }
 
+  async abortBySession(sid: string): Promise<PromptAbortResult> {
+    await this._requireSession(sid);
+    const state = this._active.get(sid);
+    if (state !== undefined && !state.completed && !state.aborted) {
+      // Normal prompt path: let abort() handle turnId mapping and event synthesis.
+      return this.abort(sid, state.promptId);
+    }
+    // No daemon-managed active prompt. Cancel whatever agent-core turn is
+    // running (e.g. a skill activation) without requiring a turnId.
+    // TurnFlow.cancel(undefined) is a safe no-op when idle.
+    await this.core.rpc.cancel({ sessionId: sid, agentId: MAIN_AGENT_ID });
+    return { aborted: true };
+  }
+
+  getCurrentPromptId(sid: string): string | undefined {
+    const state = this._active.get(sid);
+    if (state === undefined || state.completed || state.aborted) {
+      return undefined;
+    }
+    return state.promptId;
+  }
+
   /**
    * `IPromptService.applyAgentState` — entry point shared by
    * `submit` (per-turn override) and `SessionService.update`
diff --git a/packages/services/test/prompt-service.test.ts b/packages/services/test/prompt-service.test.ts
index f29f9d74c..c7333ed01 100644
--- a/packages/services/test/prompt-service.test.ts
+++ b/packages/services/test/prompt-service.test.ts
@@ -773,6 +773,89 @@ describe('PromptService.abort', () => {
   });
 });
 
+describe('PromptService.getCurrentPromptId', () => {
+  it('returns the active prompt id while running', async () => {
+    const { bridge } = makeBridge();
+    const { bus } = makeBus();
+    const impl = newSvc(bridge, bus);
+    const submit = await impl.submit(SID, mkBody());
+    expect(impl.getCurrentPromptId(SID)).toBe(submit.prompt_id);
+  });
+
+  it('returns undefined when idle', async () => {
+    const { bridge } = makeBridge();
+    const { bus } = makeBus();
+    const impl = newSvc(bridge, bus);
+    expect(impl.getCurrentPromptId(SID)).toBeUndefined();
+  });
+
+  it('returns undefined after the prompt completes', async () => {
+    const { bridge } = makeBridge();
+    const { bus, triggerSubscribers } = makeBus();
+    const impl = newSvc(bridge, bus);
+    const submit = await impl.submit(SID, mkBody());
+    triggerSubscribers({
+      type: 'turn.started',
+      turnId: 1,
+      origin: { kind: 'user' },
+      sessionId: SID,
+      agentId: 'main',
+    } as unknown as Event);
+    triggerSubscribers({
+      type: 'turn.ended',
+      turnId: 1,
+      reason: 'completed',
+      sessionId: SID,
+      agentId: 'main',
+    } as unknown as Event);
+    expect(impl.getCurrentPromptId(SID)).toBeUndefined();
+  });
+});
+
+describe('PromptService.abortBySession', () => {
+  it('delegates to abort when a daemon prompt is active', async () => {
+    const { bridge, record } = makeBridge();
+    const { bus, events, triggerSubscribers } = makeBus();
+    const impl = newSvc(bridge, bus);
+    const submit = await impl.submit(SID, mkBody());
+    triggerSubscribers({
+      type: 'turn.started',
+      turnId: 7,
+      origin: { kind: 'user' },
+      sessionId: SID,
+      agentId: 'main',
+    } as unknown as Event);
+    events.length = 0;
+
+    const result = await impl.abortBySession(SID);
+
+    expect(result.aborted).toBe(true);
+    expect(record.cancelCalls).toHaveLength(1);
+    expect(record.cancelCalls[0]).toEqual({
+      sessionId: SID,
+      agentId: 'main',
+      turnId: 7,
+    });
+    expect(events).toHaveLength(1);
+    expect((events[0] as unknown as { type: string }).type).toBe('prompt.aborted');
+  });
+
+  it('calls core.rpc.cancel without turnId when no daemon prompt is active', async () => {
+    const { bridge, record } = makeBridge();
+    const { bus } = makeBus();
+    const impl = newSvc(bridge, bus);
+
+    const result = await impl.abortBySession(SID);
+
+    expect(result.aborted).toBe(true);
+    expect(record.cancelCalls).toHaveLength(1);
+    expect(record.cancelCalls[0]).toEqual({
+      sessionId: SID,
+      agentId: 'main',
+    });
+  });
+});
+
 describe('PromptService queue steer', () => {
   it('steers a queued prompt into the active turn without starting a new prompt', async () => {
     const { bridge, record } = makeBridge();
diff --git a/packages/services/test/session-service.test.ts b/packages/services/test/session-service.test.ts
index 3f3db750d..082575c4b 100644
--- a/packages/services/test/session-service.test.ts
+++ b/packages/services/test/session-service.test.ts
@@ -270,6 +270,8 @@ function makePromptServiceStub(): {
     submit: vi.fn() as unknown as IPromptService['submit'],
     steer: vi.fn() as unknown as IPromptService['steer'],
     abort: vi.fn() as unknown as IPromptService['abort'],
+    abortBySession: vi.fn() as unknown as IPromptService['abortBySession'],
+    getCurrentPromptId: vi.fn().mockReturnValue(undefined) as unknown as IPromptService['getCurrentPromptId'],
     applyAgentState,
     onDidComplete: emitter.event as unknown as IPromptService['onDidComplete'],
     onDidAbort: emitter.event as unknown as IPromptService['onDidAbort'],

From ae5b8113d662175b46e1f78222412b20bf68dc92 Mon Sep 17 00:00:00 2001
From: "haozhe.yang" <yanghaozhe@moonshot.ai>
Date: Mon, 15 Jun 2026 21:21:17 +0800
Subject: [PATCH 17/17] fix(server): allow aborting queued prompts and add
 server-e2e send/cancel coverage

add server-e2e scenario (12-send-and-cancel) and vitest cases for send prompt / cancel prompt flows, including repeated ESC idempotency\nsupport aborting queued prompts in PromptService.abort and add abortSession helper to DaemonClient/HttpClient\nhandle SSE transport case in MCP server mapping and fix related typecheck issues\nadd changeset for @moonshot-ai/services and @moonshot-ai/kimi-code
---
 .changeset/server-send-cancel-e2e.md          |   6 +
 .../scenarios/12-send-and-cancel.ts           | 246 +++++++++++
 packages/server-e2e/scenarios/README.md       |   1 +
 packages/server-e2e/src/client.ts             |   4 +
 packages/server-e2e/src/http.ts               |   4 +
 packages/server-e2e/test/client.test.ts       |   1 +
 .../server-e2e/test/send-and-cancel.test.ts   | 406 ++++++++++++++++++
 packages/services/src/mcp/mcp.ts              |   6 +-
 packages/services/src/prompt/prompt.ts        |  11 +-
 packages/services/src/prompt/promptService.ts |  68 +--
 packages/services/test/prompt-service.test.ts |  26 ++
 11 files changed, 748 insertions(+), 31 deletions(-)
 create mode 100644 .changeset/server-send-cancel-e2e.md
 create mode 100644 packages/server-e2e/scenarios/12-send-and-cancel.ts
 create mode 100644 packages/server-e2e/test/send-and-cancel.test.ts

diff --git a/.changeset/server-send-cancel-e2e.md b/.changeset/server-send-cancel-e2e.md
new file mode 100644
index 000000000..7a936174f
--- /dev/null
+++ b/.changeset/server-send-cancel-e2e.md
@@ -0,0 +1,6 @@
+---
+"@moonshot-ai/services": patch
+"@moonshot-ai/kimi-code": patch
+---
+
+Allow aborting queued prompts and handle the SSE transport case in MCP server mapping.
diff --git a/packages/server-e2e/scenarios/12-send-and-cancel.ts b/packages/server-e2e/scenarios/12-send-and-cancel.ts
new file mode 100644
index 000000000..a1bed4173
--- /dev/null
+++ b/packages/server-e2e/scenarios/12-send-and-cancel.ts
@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Scenario 12 — send prompt + cancel prompt.
+ *
+ * Verifies that the server can arbitrarily start and stop prompts through
+ * the REST + WS surface:
+ *
+ *   1. create and subscribe to a session;
+ *   2. submit a simple prompt and wait for `prompt.completed`;
+ *   3. inject an active prompt via the debug hook, submit a second prompt
+ *      (queued), then abort the queued prompt and observe `prompt.aborted`;
+ *   4. inject another active prompt and cancel it with the session-level
+ *      `POST /sessions/{sid}:abort` endpoint (no prompt_id required);
+ *   5. submit a third prompt after the cancellations and assert it completes,
+ *      proving the scheduler recovers to an idle state.
+ *
+ * The server must be launched with `--debug-endpoints` because normal prompt
+ * submission usually completes too quickly to deterministically hold an active
+ * turn while queued prompts are submitted.
+ *
+ * Usage:
+ *   KIMI_SERVER_URL=http://127.0.0.1:7878 npx tsx scenarios/12-send-and-cancel.ts
+ *
+ * Exit codes:
+ *   0  — pass
+ *   1  — assertion failure or server error
+ */
+import assert from 'node:assert/strict';
+
+import { DaemonClient } from '../src/index';
+import { fetchWithReport } from '../src/report';
+
+const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:7878';
+const API_PREFIX = '/api/v1';
+const PROMPT_TIMEOUT_MS = 120_000;
+
+interface Envelope<T> {
+  code: number;
+  msg?: string;
+  data: T | null;
+}
+
+async function main() {
+  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
+
+  let sid: string | undefined;
+  const promptIdsForCleanup: string[] = [];
+  try {
+    const session = await client.createSession({
+      title: 'server-e2e send and cancel',
+      metadata: { cwd: process.cwd(), scenario: 'send-and-cancel' },
+    });
+    sid = session.id;
+    console.log(`▶ session ${sid} created`);
+
+    await client.connect();
+    await client.subscribe(sid);
+    console.log(`▶ session ${sid} subscribed`);
+
+    // 1. Happy-path send: submit a prompt and wait for completion.
+    const completed = await client.submitAndWait(
+      sid,
+      { content: [{ type: 'text', text: 'Reply with the single word "OK".' }] },
+      { waitFor: 'prompt.completed', timeoutMs: PROMPT_TIMEOUT_MS },
+    );
+    promptIdsForCleanup.push(completed.prompt_id);
+    console.log(`▶ prompt completed: ${completed.prompt_id}`);
+    assert.equal(completed.finalFrame.type, 'prompt.completed');
+
+    // 2. Cancel a queued prompt: hold the turn with a debug active prompt,
+    //    submit a second prompt, then abort it by prompt_id.
+    const activeForQueued = await injectActivePrompt(sid, {
+      prompt_id: `prompt_debug_cancel_queued_${process.pid}`,
+    });
+    promptIdsForCleanup.push(activeForQueued.prompt_id);
+    console.log(`▶ injected active prompt for queued cancel: ${activeForQueued.prompt_id}`);
+
+    const queued = await client.submitPrompt(sid, {
+      content: [{ type: 'text', text: 'Count slowly to 100.' }],
+    });
+    promptIdsForCleanup.push(queued.prompt_id);
+    assert.equal(queued.status, 'queued', `queued prompt status=${queued.status}, want queued`);
+    console.log(`▶ queued prompt submitted: ${queued.prompt_id}`);
+
+    const abortedFramePromise = client.waitForFrame(
+      (f) =>
+        f.type === 'prompt.aborted' &&
+        (f.payload as { promptId?: string } | undefined)?.promptId === queued.prompt_id,
+      { timeoutMs: 30_000 },
+    );
+
+    const abortQueued = await client.abortPrompt(sid, queued.prompt_id);
+    console.log(`▶ abort queued response: ${JSON.stringify(abortQueued)}`);
+    assert.equal(abortQueued.aborted, true);
+
+    const abortedFrame = await abortedFramePromise;
+    assert.equal(abortedFrame.type, 'prompt.aborted');
+    console.log(`▶ prompt.aborted frame received for queued prompt ${queued.prompt_id}`);
+
+    // 3. Cancel an active prompt via session-level abort (no prompt_id).
+    const activeForSession = await injectActivePrompt(sid, {
+      prompt_id: `prompt_debug_cancel_session_${process.pid}`,
+    });
+    promptIdsForCleanup.push(activeForSession.prompt_id);
+    console.log(`▶ injected active prompt for session abort: ${activeForSession.prompt_id}`);
+
+    const sessionAbortFramePromise = client.waitForFrame(
+      (f) =>
+        f.type === 'prompt.aborted' &&
+        (f.payload as { promptId?: string } | undefined)?.promptId === activeForSession.prompt_id,
+      { timeoutMs: 30_000 },
+    );
+
+    const sessionAbort = await client.abortSession(sid);
+    console.log(`▶ session abort response: ${JSON.stringify(sessionAbort)}`);
+    assert.equal(sessionAbort.aborted, true);
+
+    const sessionAbortFrame = await sessionAbortFramePromise;
+    assert.equal(sessionAbortFrame.type, 'prompt.aborted');
+    console.log(`▶ prompt.aborted frame received for session-aborted prompt ${activeForSession.prompt_id}`);
+
+    // 4. Repeated ESC (prompt-level): abort an active prompt, then abort it
+    //    again and assert idempotent 40903 / { aborted: false }.
+    const activeForRepeated = await injectActivePrompt(sid, {
+      prompt_id: `prompt_debug_repeated_esc_${process.pid}`,
+    });
+    promptIdsForCleanup.push(activeForRepeated.prompt_id);
+    console.log(`▶ injected active prompt for repeated ESC: ${activeForRepeated.prompt_id}`);
+
+    const repeatedEscFramePromise = client.waitForFrame(
+      (f) =>
+        f.type === 'prompt.aborted' &&
+        (f.payload as { promptId?: string } | undefined)?.promptId === activeForRepeated.prompt_id,
+      { timeoutMs: 30_000 },
+    );
+
+    const firstEsc = await client.abortPrompt(sid, activeForRepeated.prompt_id);
+    console.log(`▶ first ESC abort response: ${JSON.stringify(firstEsc)}`);
+    assert.equal(firstEsc.aborted, true);
+
+    const repeatedEscFrame = await repeatedEscFramePromise;
+    assert.equal(repeatedEscFrame.type, 'prompt.aborted');
+    console.log(`▶ prompt.aborted frame received for repeated ESC prompt ${activeForRepeated.prompt_id}`);
+
+    let secondEscError: unknown;
+    try {
+      await client.abortPrompt(sid, activeForRepeated.prompt_id);
+    } catch (error) {
+      secondEscError = error;
+    }
+    assert.ok(
+      secondEscError instanceof Error && secondEscError.message.includes('40903'),
+      `expected second ESC to return 40903, got ${String(secondEscError)}`,
+    );
+    console.log(`▶ second ESC abort returned 40903 as expected`);
+
+    // 5. Repeated session-level ESC: cancel repeatedly and assert stability.
+    const activeForRepeatedSession = await injectActivePrompt(sid, {
+      prompt_id: `prompt_debug_repeated_session_abort_${process.pid}`,
+    });
+    promptIdsForCleanup.push(activeForRepeatedSession.prompt_id);
+    console.log(`▶ injected active prompt for repeated session abort: ${activeForRepeatedSession.prompt_id}`);
+
+    const repeatedSessionFrames: Array<{ type: string; promptId?: string }> = [];
+    const unsubscribe = client.onFrame((f) => {
+      if (
+        f.type === 'prompt.aborted' &&
+        (f.payload as { promptId?: string } | undefined)?.promptId === activeForRepeatedSession.prompt_id
+      ) {
+        repeatedSessionFrames.push({ type: f.type, promptId: (f.payload as { promptId?: string }).promptId });
+      }
+    });
+    try {
+      const firstSessionAbort = await client.abortSession(sid);
+      console.log(`▶ first session-level ESC abort response: ${JSON.stringify(firstSessionAbort)}`);
+      assert.equal(firstSessionAbort.aborted, true);
+
+      const secondSessionAbort = await client.abortSession(sid);
+      console.log(`▶ second session-level ESC abort response: ${JSON.stringify(secondSessionAbort)}`);
+      assert.equal(secondSessionAbort.aborted, true);
+
+      const thirdSessionAbort = await client.abortSession(sid);
+      console.log(`▶ third session-level ESC abort response: ${JSON.stringify(thirdSessionAbort)}`);
+      assert.equal(thirdSessionAbort.aborted, true);
+
+      assert.equal(repeatedSessionFrames.length, 1, `expected exactly one prompt.aborted frame, got ${repeatedSessionFrames.length}`);
+      console.log(`▶ repeated session-level ESC produced exactly one prompt.aborted frame`);
+    } finally {
+      unsubscribe();
+    }
+
+    // 6. Scheduler recovery: submit another prompt after cancellations and
+    //    assert it completes normally.
+    const recovered = await client.submitAndWait(
+      sid,
+      { content: [{ type: 'text', text: 'Reply with the single word "RECOVERED".' }] },
+      { waitFor: 'prompt.completed', timeoutMs: PROMPT_TIMEOUT_MS },
+    );
+    promptIdsForCleanup.push(recovered.prompt_id);
+    console.log(`▶ recovered prompt completed: ${recovered.prompt_id}`);
+    assert.equal(recovered.finalFrame.type, 'prompt.completed');
+
+    console.log('✓ 12-send-and-cancel: submit + abort round-trips succeeded');
+  } finally {
+    if (sid !== undefined) {
+      for (const promptId of promptIdsForCleanup.toReversed()) {
+        try {
+          await client.abortPrompt(sid, promptId);
+        } catch {
+          // ignore
+        }
+      }
+      try {
+        await client.deleteSession(sid);
+      } catch {
+        // ignore
+      }
+    }
+    await client.close();
+  }
+}
+
+async function injectActivePrompt(
+  sid: string,
+  body: { prompt_id: string },
+): Promise<{ prompt_id: string }> {
+  const url = `${KIMI_SERVER_URL}${API_PREFIX}/debug/prompts/${encodeURIComponent(sid)}/active`;
+  const res = await fetchWithReport(url, {
+    method: 'POST',
+    headers: { accept: 'application/json', 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  if (res.status === 404) {
+    throw new Error(`POST ${url} -> 404. Did you start the server with --debug-endpoints?`);
+  }
+  const envelope = (await res.json()) as Envelope<{ prompt_id: string }>;
+  if (envelope.code !== 0 || envelope.data === null) {
+    throw new Error(`POST ${url} -> code=${envelope.code} msg=${envelope.msg ?? ''}`);
+  }
+  return envelope.data;
+}
+
+main().catch((error) => {
+  console.error('✗ 12-send-and-cancel failed:', error);
+  process.exit(1);
+});
diff --git a/packages/server-e2e/scenarios/README.md b/packages/server-e2e/scenarios/README.md
index 1e605a271..207043d3a 100644
--- a/packages/server-e2e/scenarios/README.md
+++ b/packages/server-e2e/scenarios/README.md
@@ -43,6 +43,7 @@ somewhere else.
 | `09-image-file-prompts.ts` | Uploaded file prompt references: missing file, non-image validation, and PNG prompt submission. |
 | `10-prompt-queue-steer.ts` | Prompt queue steer: debug-inject an active prompt, queue two prompts, steer them through `POST /prompts:steer`, and assert REST, WS, content, and queue-drain behavior. |
 | `11-terminal.ts` | Terminal flow: create/list/get a session terminal, attach over WS, write input, observe output, resize, close, and assert terminal exit/final state. |
+| `12-send-and-cancel.ts` | Send prompt + cancel prompt: happy-path completion, abort a queued prompt by id, session-level abort of an active prompt, and scheduler recovery after aborts. |
 
 ## Writing a new scenario
 
diff --git a/packages/server-e2e/src/client.ts b/packages/server-e2e/src/client.ts
index 6aff98264..9e45d6fc7 100644
--- a/packages/server-e2e/src/client.ts
+++ b/packages/server-e2e/src/client.ts
@@ -43,6 +43,7 @@ import type {
   QuestionResolveResult,
   QuestionResponse,
   ServerHelloMessage,
+  SessionAbortResponse,
   SetDefaultModelResponse,
   Session,
   SessionChildCreate,
@@ -333,6 +334,9 @@ export class DaemonClient {
   abortPrompt(sid: string, pid: string): Promise<PromptAbortResponse> {
     return this.http.abortPrompt(sid, pid);
   }
+  abortSession(sid: string): Promise<SessionAbortResponse> {
+    return this.http.abortSession(sid);
+  }
   resolveApproval(
     sid: string,
     aid: string,
diff --git a/packages/server-e2e/src/http.ts b/packages/server-e2e/src/http.ts
index 11ba3b054..418e82c0c 100644
--- a/packages/server-e2e/src/http.ts
+++ b/packages/server-e2e/src/http.ts
@@ -29,6 +29,7 @@ import type {
   PromptSubmitResult,
   QuestionResolveResult,
   QuestionResponse,
+  SessionAbortResponse,
   SetDefaultModelResponse,
   Session,
   SessionChildCreate,
@@ -383,6 +384,9 @@ export class HttpClient {
       {},
     );
   }
+  abortSession(sid: string): Promise<SessionAbortResponse> {
+    return this.request('POST', `/sessions/${encodeURIComponent(sid)}:abort`, {});
+  }
 
   // ── Approvals / Questions (reverse-RPC resolves) ────────────────────────
   resolveApproval(
diff --git a/packages/server-e2e/test/client.test.ts b/packages/server-e2e/test/client.test.ts
index 1c746af26..222b669e1 100644
--- a/packages/server-e2e/test/client.test.ts
+++ b/packages/server-e2e/test/client.test.ts
@@ -709,6 +709,7 @@ function testSessionStatus(): SessionStatusResponse {
     thinking_level: 'off',
     permission: 'manual',
     plan_mode: false,
+    swarm_mode: false,
     context_tokens: 0,
     max_context_tokens: 100,
     context_usage: 0,
diff --git a/packages/server-e2e/test/send-and-cancel.test.ts b/packages/server-e2e/test/send-and-cancel.test.ts
new file mode 100644
index 000000000..d00b0d7f6
--- /dev/null
+++ b/packages/server-e2e/test/send-and-cancel.test.ts
@@ -0,0 +1,406 @@
+/**
+ * Send prompt + cancel prompt live-server invariant.
+ *
+ * Verifies the server can arbitrarily start and stop prompts:
+ *   1. submit a prompt and wait for `prompt.completed`;
+ *   2. inject an active prompt via the debug hook, queue a second prompt,
+ *      abort it by prompt_id, and observe `prompt.aborted`;
+ *   3. inject another active prompt and cancel it via session-level
+ *      `POST /sessions/{sid}:abort` (no prompt_id required);
+ *   4. submit a prompt after cancellations and assert the scheduler recovers.
+ *
+ * Requires a server launched with debug endpoints enabled. Normal production
+ * daemons do not expose `/debug/*`, so this file skips when that surface is
+ * absent.
+ */
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { DaemonClient, EnvelopeError, type AnyFrame } from '../src/index.js';
+import { fetchWithReport } from '../src/report.js';
+import { createCaseLogger, errorForLog } from './log.js';
+
+const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:7878';
+const API_PREFIX = '/api/v1';
+const PROMPT_TIMEOUT_MS = 120_000;
+const SHORT_TIMEOUT_MS = 30_000;
+
+async function daemonReachable(): Promise<boolean> {
+  try {
+    const res = await fetchWithReport(`${BASE_URL}${API_PREFIX}/meta`, {
+      signal: AbortSignal.timeout(500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function debugPromptsReachable(): Promise<boolean> {
+  try {
+    const res = await fetchWithReport(
+      `${BASE_URL}${API_PREFIX}/debug/prompts/debug_probe/state`,
+      { signal: AbortSignal.timeout(500) },
+    );
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+const reachable = await daemonReachable();
+const debugReachable = reachable && (await debugPromptsReachable());
+const describeLive = debugReachable ? describe : describe.skip;
+
+const created: Array<{ client: DaemonClient; sid: string; promptIds: string[] }> = [];
+
+afterEach(async () => {
+  for (const { client, sid, promptIds } of created.splice(0)) {
+    for (const promptId of promptIds.toReversed()) {
+      try {
+        await client.abortPrompt(sid, promptId);
+      } catch {
+        // ignore
+      }
+    }
+    try {
+      await client.deleteSession(sid);
+    } catch {
+      // ignore
+    }
+    try {
+      await client.close();
+    } catch {
+      // ignore
+    }
+  }
+});
+
+describeLive('send prompt + cancel prompt (live server required)', () => {
+  it(
+    'submits a prompt and receives prompt.completed',
+    async () => {
+      const log = createCaseLogger('send: prompt completes');
+      const client = new DaemonClient({ baseUrl: BASE_URL });
+      const session = await client.createSession({
+        title: 'server-e2e send and cancel',
+        metadata: { cwd: process.cwd(), scenario: 'send-and-cancel' },
+      });
+      const cleanup = { client, sid: session.id, promptIds: [] as string[] };
+      created.push(cleanup);
+      log('created session', session);
+
+      await client.connect();
+      await client.subscribe(session.id);
+      log('subscribe accepted', { session_id: session.id });
+
+      const result = await client.submitAndWait(
+        session.id,
+        { content: [{ type: 'text', text: 'Reply with the single word "OK".' }] },
+        { waitFor: 'prompt.completed', timeoutMs: PROMPT_TIMEOUT_MS },
+      );
+      cleanup.promptIds.push(result.prompt_id);
+      log('prompt completed', {
+        prompt_id: result.prompt_id,
+        final_frame: frameForLog(result.finalFrame),
+      });
+
+      expect(result.prompt_id).toMatch(/^prompt_/);
+      expect(result.finalFrame.type).toBe('prompt.completed');
+    },
+    PROMPT_TIMEOUT_MS + SHORT_TIMEOUT_MS,
+  );
+
+  it(
+    'aborts a queued prompt and receives prompt.aborted',
+    async () => {
+      const log = createCaseLogger('cancel: queued prompt abort');
+      const client = new DaemonClient({ baseUrl: BASE_URL });
+      const session = await client.createSession({
+        title: 'server-e2e send and cancel',
+        metadata: { cwd: process.cwd(), scenario: 'send-and-cancel' },
+      });
+      const cleanup = { client, sid: session.id, promptIds: [] as string[] };
+      created.push(cleanup);
+      log('created session', session);
+
+      await client.connect();
+      await client.subscribe(session.id);
+      log('subscribe accepted', { session_id: session.id });
+
+      const active = await injectActivePrompt(session.id, {
+        prompt_id: `prompt_debug_cancel_queued_${process.pid}`,
+      });
+      log('debug active prompt injected', active);
+      cleanup.promptIds.push(active.prompt_id);
+
+      const queued = await client.submitPrompt(session.id, {
+        content: [{ type: 'text', text: 'Count slowly to 100.' }],
+      });
+      cleanup.promptIds.push(queued.prompt_id);
+      log('queued prompt submitted', queued);
+      expect(queued.status).toBe('queued');
+
+      const listedBefore = await client.listPrompts(session.id);
+      log('prompt list before abort', listedBefore);
+      expect(listedBefore.active?.prompt_id).toBe(active.prompt_id);
+      expect(listedBefore.queued.map((prompt) => prompt.prompt_id)).toEqual([
+        queued.prompt_id,
+      ]);
+
+      const abortedFramePromise = client.waitForFrame(
+        (f) =>
+          f.type === 'prompt.aborted' &&
+          (f.payload as { promptId?: string } | undefined)?.promptId === queued.prompt_id,
+        { timeoutMs: SHORT_TIMEOUT_MS },
+      );
+
+      const abort = await client.abortPrompt(session.id, queued.prompt_id);
+      log('abort response', abort);
+      expect(abort.aborted).toBe(true);
+
+      const abortedFrame = await abortedFramePromise;
+      log('prompt.aborted frame', frameForLog(abortedFrame));
+      expect(abortedFrame.type).toBe('prompt.aborted');
+
+      const listedAfter = await client.listPrompts(session.id);
+      log('prompt list after abort', listedAfter);
+      expect(listedAfter.queued).toHaveLength(0);
+    },
+    PROMPT_TIMEOUT_MS + SHORT_TIMEOUT_MS,
+  );
+
+  it(
+    'aborts an active prompt via session-level abort',
+    async () => {
+      const log = createCaseLogger('cancel: session-level abort');
+      const client = new DaemonClient({ baseUrl: BASE_URL });
+      const session = await client.createSession({
+        title: 'server-e2e send and cancel',
+        metadata: { cwd: process.cwd(), scenario: 'send-and-cancel' },
+      });
+      const cleanup = { client, sid: session.id, promptIds: [] as string[] };
+      created.push(cleanup);
+      log('created session', session);
+
+      await client.connect();
+      await client.subscribe(session.id);
+      log('subscribe accepted', { session_id: session.id });
+
+      const active = await injectActivePrompt(session.id, {
+        prompt_id: `prompt_debug_cancel_session_${process.pid}`,
+      });
+      cleanup.promptIds.push(active.prompt_id);
+      log('debug active prompt injected', active);
+
+      const listedBefore = await client.listPrompts(session.id);
+      log('prompt list before session abort', listedBefore);
+      expect(listedBefore.active?.prompt_id).toBe(active.prompt_id);
+
+      const abortedFramePromise = client.waitForFrame(
+        (f) =>
+          f.type === 'prompt.aborted' &&
+          (f.payload as { promptId?: string } | undefined)?.promptId === active.prompt_id,
+        { timeoutMs: SHORT_TIMEOUT_MS },
+      );
+
+      const abort = await client.abortSession(session.id);
+      log('session abort response', abort);
+      expect(abort.aborted).toBe(true);
+
+      const abortedFrame = await abortedFramePromise;
+      log('prompt.aborted frame', frameForLog(abortedFrame));
+      expect(abortedFrame.type).toBe('prompt.aborted');
+
+      const listedAfter = await client.listPrompts(session.id);
+      log('prompt list after session abort', listedAfter);
+      expect(listedAfter.active).toBeNull();
+    },
+    PROMPT_TIMEOUT_MS + SHORT_TIMEOUT_MS,
+  );
+
+  it(
+    'recovers and completes a prompt after aborts',
+    async () => {
+      const log = createCaseLogger('send: scheduler recovery after abort');
+      const client = new DaemonClient({ baseUrl: BASE_URL });
+      const session = await client.createSession({
+        title: 'server-e2e send and cancel',
+        metadata: { cwd: process.cwd(), scenario: 'send-and-cancel' },
+      });
+      const cleanup = { client, sid: session.id, promptIds: [] as string[] };
+      created.push(cleanup);
+      log('created session', session);
+
+      await client.connect();
+      await client.subscribe(session.id);
+      log('subscribe accepted', { session_id: session.id });
+
+      const active = await injectActivePrompt(session.id, {
+        prompt_id: `prompt_debug_cancel_recovery_${process.pid}`,
+      });
+      cleanup.promptIds.push(active.prompt_id);
+      log('debug active prompt injected', active);
+
+      const abort = await client.abortSession(session.id);
+      log('session abort response', abort);
+      expect(abort.aborted).toBe(true);
+
+      const result = await client.submitAndWait(
+        session.id,
+        { content: [{ type: 'text', text: 'Reply with the single word "RECOVERED".' }] },
+        { waitFor: 'prompt.completed', timeoutMs: PROMPT_TIMEOUT_MS },
+      );
+      cleanup.promptIds.push(result.prompt_id);
+      log('recovered prompt completed', {
+        prompt_id: result.prompt_id,
+        final_frame: frameForLog(result.finalFrame),
+      });
+
+      expect(result.finalFrame.type).toBe('prompt.completed');
+    },
+    PROMPT_TIMEOUT_MS + SHORT_TIMEOUT_MS,
+  );
+
+  it(
+    'idempotently aborts a prompt on repeated ESC',
+    async () => {
+      const log = createCaseLogger('cancel: repeated ESC idempotent');
+      const client = new DaemonClient({ baseUrl: BASE_URL });
+      const session = await client.createSession({
+        title: 'server-e2e send and cancel',
+        metadata: { cwd: process.cwd(), scenario: 'send-and-cancel' },
+      });
+      const cleanup = { client, sid: session.id, promptIds: [] as string[] };
+      created.push(cleanup);
+      log('created session', session);
+
+      await client.connect();
+      await client.subscribe(session.id);
+      log('subscribe accepted', { session_id: session.id });
+
+      const active = await injectActivePrompt(session.id, {
+        prompt_id: `prompt_debug_repeated_esc_${process.pid}`,
+      });
+      cleanup.promptIds.push(active.prompt_id);
+      log('debug active prompt injected', active);
+
+      const abortedFramePromise = client.waitForFrame(
+        (f) =>
+          f.type === 'prompt.aborted' &&
+          (f.payload as { promptId?: string } | undefined)?.promptId === active.prompt_id,
+        { timeoutMs: SHORT_TIMEOUT_MS },
+      );
+
+      const first = await client.abortPrompt(session.id, active.prompt_id);
+      log('first ESC abort response', first);
+      expect(first.aborted).toBe(true);
+
+      const abortedFrame = await abortedFramePromise;
+      log('prompt.aborted frame', frameForLog(abortedFrame));
+      expect(abortedFrame.type).toBe('prompt.aborted');
+
+      let secondError: unknown;
+      try {
+        await client.abortPrompt(session.id, active.prompt_id);
+      } catch (error) {
+        secondError = error;
+      }
+      log('second ESC abort error', errorForLog(secondError));
+      expect(secondError).toBeInstanceOf(EnvelopeError);
+      expect((secondError as EnvelopeError).code).toBe(40903);
+      expect((secondError as EnvelopeError).data).toEqual({ aborted: false });
+
+      const listed = await client.listPrompts(session.id);
+      log('prompt list after repeated ESC', listed);
+      expect(listed.active).toBeNull();
+    },
+    PROMPT_TIMEOUT_MS + SHORT_TIMEOUT_MS,
+  );
+
+  it(
+    'remains stable when session-level abort is sent repeatedly',
+    async () => {
+      const log = createCaseLogger('cancel: repeated session-level ESC stable');
+      const client = new DaemonClient({ baseUrl: BASE_URL });
+      const session = await client.createSession({
+        title: 'server-e2e send and cancel',
+        metadata: { cwd: process.cwd(), scenario: 'send-and-cancel' },
+      });
+      const cleanup = { client, sid: session.id, promptIds: [] as string[] };
+      created.push(cleanup);
+      log('created session', session);
+
+      await client.connect();
+      await client.subscribe(session.id);
+      log('subscribe accepted', { session_id: session.id });
+
+      const active = await injectActivePrompt(session.id, {
+        prompt_id: `prompt_debug_repeated_session_abort_${process.pid}`,
+      });
+      cleanup.promptIds.push(active.prompt_id);
+      log('debug active prompt injected', active);
+
+      const abortedFrames: AnyFrame[] = [];
+      const unsubscribe = client.onFrame((f) => {
+        if (
+          f.type === 'prompt.aborted' &&
+          (f.payload as { promptId?: string } | undefined)?.promptId === active.prompt_id
+        ) {
+          abortedFrames.push(f);
+        }
+      });
+      try {
+        const first = await client.abortSession(session.id);
+        log('first session-level ESC abort response', first);
+        expect(first.aborted).toBe(true);
+
+        const second = await client.abortSession(session.id);
+        log('second session-level ESC abort response', second);
+        expect(second.aborted).toBe(true);
+
+        const third = await client.abortSession(session.id);
+        log('third session-level ESC abort response', third);
+        expect(third.aborted).toBe(true);
+
+        expect(abortedFrames).toHaveLength(1);
+      } finally {
+        unsubscribe();
+      }
+
+      const listed = await client.listPrompts(session.id);
+      log('prompt list after repeated session-level abort', listed);
+      expect(listed.active).toBeNull();
+    },
+    PROMPT_TIMEOUT_MS + SHORT_TIMEOUT_MS,
+  );
+});
+
+function frameForLog(frame: AnyFrame): Record<string, unknown> {
+  return {
+    type: frame.type,
+    seq: frame.seq,
+    session_id: frame.session_id,
+    payload: frame.payload,
+  };
+}
+
+async function injectActivePrompt(
+  sid: string,
+  body: { prompt_id: string },
+): Promise<{ prompt_id: string }> {
+  const res = await fetchWithReport(
+    `${BASE_URL}${API_PREFIX}/debug/prompts/${encodeURIComponent(sid)}/active`,
+    {
+      method: 'POST',
+      headers: { accept: 'application/json', 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    },
+  );
+  const envelope = (await res.json()) as {
+    code: number;
+    msg: string;
+    data: { prompt_id: string };
+  };
+  expect(envelope.code, envelope.msg).toBe(0);
+  return envelope.data;
+}
diff --git a/packages/services/src/mcp/mcp.ts b/packages/services/src/mcp/mcp.ts
index 9c1ccc0cd..3020d0156 100644
--- a/packages/services/src/mcp/mcp.ts
+++ b/packages/services/src/mcp/mcp.ts
@@ -61,13 +61,15 @@ function mapMcpStatus(s: McpServerInfo['status']): McpServerStatus {
 }
 
 function mapMcpTransport(t: McpServerInfo['transport']): McpServerTransport {
-  // SCHEMAS §8 transport is a superset (adds 'sse'); the two agent-core
-  // literals pass through unchanged.
+  // SCHEMAS §8 transport is a superset (adds 'sse'); agent-core literals
+  // pass through unchanged, and 'sse' is already a valid wire value.
   switch (t) {
     case 'stdio':
       return 'stdio';
     case 'http':
       return 'http';
+    case 'sse':
+      return 'sse';
   }
 }
 
diff --git a/packages/services/src/prompt/prompt.ts b/packages/services/src/prompt/prompt.ts
index 9586a6cae..c9a905a8d 100644
--- a/packages/services/src/prompt/prompt.ts
+++ b/packages/services/src/prompt/prompt.ts
@@ -142,7 +142,13 @@ export interface IPromptService {
   steer(sid: string, promptIds: readonly string[]): Promise<PromptSteerResult>;
 
   /**
-   * `POST /v1/sessions/{sid}/prompts/{pid}:abort` — cancel an in-flight prompt.
+   * `POST /v1/sessions/{sid}/prompts/{pid}:abort` — cancel an in-flight or
+   * queued prompt.
+   *
+   * For an active prompt, this issues `core.rpc.cancel` and synthesizes a
+   * `prompt.aborted` event. For a queued prompt, it removes the prompt from
+   * the queue and synthesizes `prompt.aborted` without dispatching to
+   * agent-core.
    *
    * Per REST.md §3.5: aborting an already-completed prompt returns
    * `PromptAlreadyCompletedError` (→ 40903 with `data.aborted: false`).
@@ -150,7 +156,8 @@ export interface IPromptService {
    * RPC + subsequent calls return 40903.
    *
    * Throws `SessionNotFoundError` (→ 40401) for unknown `sid`.
-   * Throws `PromptNotFoundError`  (→ 40402) when `pid` is unknown for `sid`.
+   * Throws `PromptNotFoundError`  (→ 40402) when `pid` is neither active nor
+   * queued for `sid`.
    */
   abort(sid: string, pid: string): Promise<PromptAbortResult>;
 
diff --git a/packages/services/src/prompt/promptService.ts b/packages/services/src/prompt/promptService.ts
index 6c112c962..c8b7550bf 100644
--- a/packages/services/src/prompt/promptService.ts
+++ b/packages/services/src/prompt/promptService.ts
@@ -445,33 +445,7 @@ export class PromptService
     this.eventService.publish(event);
   }
 
-  async abort(sid: string, pid: string): Promise<PromptAbortResult> {
-    await this._requireSession(sid);
-    const state = this._active.get(sid);
-    if (state === undefined || state.promptId !== pid) {
-      throw new PromptNotFoundError(sid, pid);
-    }
-    if (state.completed || state.aborted) {
-      throw new PromptAlreadyCompletedError(sid, pid);
-    }
-    // Mark aborted optimistically — _handleBusEvent will not re-synthesize.
-    state.aborted = true;
-    try {
-      const cancelArgs: { sessionId: string; agentId: string; turnId?: number } = {
-        sessionId: sid,
-        agentId: MAIN_AGENT_ID,
-      };
-      if (state.turnId !== null) cancelArgs.turnId = state.turnId;
-      await this.core.rpc.cancel(cancelArgs);
-    } catch (error) {
-      // Roll back the optimistic flag so the route surfaces a real error;
-      // the caller will see a 50001 (internal) via the global error handler.
-      state.aborted = false;
-      throw error;
-    }
-    // Synthesize the prompt.aborted event immediately. agent-core may also
-    // emit a turn.ended(cancelled) later; _handleBusEvent suppresses a second
-    // synthesis since `state.aborted === true`.
+  private _publishAborted(sid: string, pid: string): void {
     const ev: SyntheticPromptAbortedEvent = {
       type: 'prompt.aborted',
       agentId: MAIN_AGENT_ID,
@@ -484,6 +458,46 @@ export class PromptService
     // event.
     this._onDidAbort.fire(ev);
     this.eventService.publish(ev as unknown as Event);
+  }
+
+  async abort(sid: string, pid: string): Promise<PromptAbortResult> {
+    await this._requireSession(sid);
+    const state = this._active.get(sid);
+    if (state !== undefined && state.promptId === pid) {
+      if (state.completed || state.aborted) {
+        throw new PromptAlreadyCompletedError(sid, pid);
+      }
+      // Mark aborted optimistically — _handleBusEvent will not re-synthesize.
+      state.aborted = true;
+      try {
+        const cancelArgs: { sessionId: string; agentId: string; turnId?: number } = {
+          sessionId: sid,
+          agentId: MAIN_AGENT_ID,
+        };
+        if (state.turnId !== null) cancelArgs.turnId = state.turnId;
+        await this.core.rpc.cancel(cancelArgs);
+      } catch (error) {
+        // Roll back the optimistic flag so the route surfaces a real error;
+        // the caller will see a 50001 (internal) via the global error handler.
+        state.aborted = false;
+        throw error;
+      }
+      this._publishAborted(sid, pid);
+      return { aborted: true };
+    }
+
+    // Queued prompt: remove it from the queue and synthesize prompt.aborted.
+    // No core RPC is needed because the prompt was never dispatched.
+    const queue = this._queued.get(sid) ?? [];
+    const index = queue.findIndex((item) => item.promptId === pid);
+    if (index === -1) {
+      throw new PromptNotFoundError(sid, pid);
+    }
+    queue.splice(index, 1);
+    if (queue.length === 0) {
+      this._queued.delete(sid);
+    }
+    this._publishAborted(sid, pid);
     return { aborted: true };
   }
 
diff --git a/packages/services/test/prompt-service.test.ts b/packages/services/test/prompt-service.test.ts
index c7333ed01..a5525bf6e 100644
--- a/packages/services/test/prompt-service.test.ts
+++ b/packages/services/test/prompt-service.test.ts
@@ -771,6 +771,32 @@ describe('PromptService.abort', () => {
       PromptAlreadyCompletedError,
     );
   });
+
+  it('aborts a queued prompt without calling core.rpc.cancel', async () => {
+    const { bridge, record } = makeBridge();
+    const { bus, events } = makeBus();
+    const impl = newSvc(bridge, bus);
+
+    const first = await impl.submit(SID, mkBody());
+    const second = await impl.submit(
+      SID,
+      mkBodyMinimal({ content: [{ type: 'text', text: 'queued' }] }),
+    );
+    expect(second.status).toBe('queued');
+
+    events.length = 0;
+    const result = await impl.abort(SID, second.prompt_id);
+
+    expect(result.aborted).toBe(true);
+    expect(record.cancelCalls).toHaveLength(0);
+    const listed = await impl.list(SID);
+    expect(listed.active?.prompt_id).toBe(first.prompt_id);
+    expect(listed.queued).toHaveLength(0);
+    expect(events).toHaveLength(1);
+    const ev = events[0] as unknown as { type: string; promptId?: string };
+    expect(ev.type).toBe('prompt.aborted');
+    expect(ev.promptId).toBe(second.prompt_id);
+  });
 });
 
 describe('PromptService.getCurrentPromptId', () => {