Add files using upload-large-folder tool

.github/pr-title-checker-config.json

@@ -0,0 +1,12 @@
+{
+    "LABEL": {
+        "name": "Invalid PR Title",
+        "color": "B60205"
+    },
+    "CHECKS": {
+        "regexp": "^(feat|fix|test|refactor|chore|style|docs|perf|build|ci|revert)(\\(.*\\))?:.*"
+    },
+    "MESSAGES": {
+        "failure": "The PR title is invalid. Please refer to https://www.conventionalcommits.org/en/v1.0.0/ for the convention."
+    }
+}

.github/pull_request_template.md

@@ -0,0 +1,29 @@
+<!--
+Thank you for your contribution to Kimi Code!
+External PRs are accepted for approved bug fixes only: link an issue that a maintainer has approved (an `/approve` comment). External feature PRs are not accepted.
+外部 PR 仅接受获批准的 bug 修复：请链接维护者已批准（`/approve` 评论）的 issue；不接受外部 feature PR。
+
+See https://github.com/MoonshotAI/kimi-code/blob/main/CONTRIBUTING.md for more.
+-->
+
+## Related Issue
+
+<!-- Link the issue this change came from. External PRs must link an issue approved by a maintainer (an `/approve` comment) — PRs without one may be closed. -->
+
+Resolve #(issue_number)
+
+## Problem
+
+<!-- What user need or limitation does this address? If the linked issue already covers this, write "See linked issue". -->
+
+## What changed
+
+<!-- What did you implement, and why does this approach fit Kimi Code? -->
+
+## Checklist
+
+- [ ] I have read the [CONTRIBUTING](https://github.com/MoonshotAI/kimi-code/blob/main/CONTRIBUTING.md) document.
+- [ ] I have linked a related issue (external PRs: the issue must have a maintainer's `/approve`).
+- [ ] I have added tests that prove my feature works.
+- [ ] Ran `gen-changesets` skill, or this PR needs no changeset.
+- [ ] Ran `gen-docs` skill, or this PR needs no doc update.

apps/kimi-code/.gitignore

@@ -0,0 +1,11 @@
+# Copied from packages/kimi-core at build time
+agents/
+
+# Generated at build time by scripts/build-vis-asset.mjs.
+# Only the ~150KB base64 VALUE file is ignored; the committed `.d.ts` stub
+# next to it keeps `#/generated/vis-web-asset` type-resolvable on a fresh
+# clone (before any build has produced the `.ts`).
+src/generated/vis-web-asset.ts
+
+# Copied from packages/pi-tui/native at build time by scripts/copy-native-assets.mjs
+/native/

apps/kimi-code/AGENTS.md

@@ -0,0 +1,72 @@
+# apps/kimi-code Development Guide
+
+This file only contains rules local to `apps/kimi-code`. For cross-repo rules, see the root `AGENTS.md`.
+
+> **Writing or modifying the TUI?** Use the `write-tui` skill (`.agents/skills/write-tui/SKILL.md`). It covers the architecture orientation, where new features go, test placement, theme mechanics, and the dialog interaction/visual spec (`DESIGN.md`). This file keeps only the map, boundaries, and hard constraints.
+
+## TUI File Layout
+
+`apps/kimi-code` is the terminal UI / CLI app. The entry chain is:
+
+`src/main.ts` -> `src/cli/commands.ts` -> `src/cli/run-shell.ts` -> SDK `KimiHarness` -> `src/tui/kimi-tui.ts`
+
+Main directories:
+
+- `src/constant/`: non-copy constants shared by CLI/TUI — product, protocol, paths, terminal control, updates, and so on.
+- `src/cli/`: command-line arguments, subcommands, and CLI startup.
+- `src/tui/`: the interactive terminal UI.
+- `src/tui/kimi-tui.ts`: the `KimiTUI` coordinator — wires state, layout, editor, session, SDK events, and dialogs together, and dispatches slash-command handlers. Heavy logic is delegated to `controllers/`, not accumulated here.
+- `src/tui/tui-state.ts`: `TUIState`, `createTUIState`, `createInitialAppState` — the single global UI-state shape.
+- `src/tui/controllers/`: independently-testable responsibilities — `session-event-handler` (SDK event routing), `streaming-ui` (streaming render), `session-replay` (resume/replay), `tasks-browser`, `editor-keyboard`, `auth-flow`.
+- `src/tui/commands/`: slash command definitions, parsing, ordering, and dynamic skill command generation.
+- `src/tui/components/`: pi-tui components, organized by UI type.
+- `src/tui/constant/`: non-copy constants reused across TUI modules — symbols, terminal sequences, render sizing, streaming-arg match rules, and so on.
+- `src/tui/components/chrome/`: persistent UI chrome — footer, todo panel, welcome, loader, device code.
+- `src/tui/components/dialogs/`: selectors, approval panels, question popups, and settings popups that temporarily replace the editor.
+- `src/tui/components/editor/`: the custom input box and the file mention provider.
+- `src/tui/components/media/`: image, diff, code highlight, and other media displays.
+- `src/tui/components/messages/`: message blocks in the transcript — assistant, user, tool call, thinking, usage, subagent, and so on.
+- `src/tui/components/panes/`: right-side / activity-area panes such as the activity pane and queue pane.
+- `src/tui/reverse-rpc/`: the adapter layer that bridges SDK approval/question callbacks to the UI.
+- `src/tui/theme/`: themes, color tokens, style helpers, terminal-background detection, and the pi-tui markdown theme.
+- `src/tui/utils/`: TUI-only utility functions.
+- `src/utils/`: app-wide utilities — clipboard, git, history, image, process, usage, and so on.
+
+## Module Responsibilities
+
+- `cli` only interprets command-line input, assembles startup arguments, and invokes the TUI. Do not put TUI interaction logic into the CLI.
+- `KimiTUI` coordinates; it does not accumulate complex business rules. New logic that can be tested independently should be split into `controllers`, `commands`, `components`, `reverse-rpc`, or `utils` first.
+- `controllers` own the heavy, independently-testable slices (event routing, streaming render, session replay, tasks browser, editor keyboard, auth). Event-routing and rendering logic belong here, not on the `KimiTUI` class.
+- `commands` only owns slash-command declaration, parsing, and the parsed-result types. The actual execution can be dispatched from `KimiTUI`, but complex logic should continue to sink downward.
+- `components` only handle presentation and local interaction; they must not call the SDK directly, and must not read or write session state directly.
+- `reverse-rpc` converts SDK approval/question requests into the data shape a UI panel/dialog needs, and converts the user's choice back into an SDK response.
+- `theme` is the single source of truth for colors and styles. Components must not bypass the theme system and use chalk named colors directly.
+- `utils` holds utility functions with no UI-state dependency. Logic that needs `TUIState` or a component instance must not live under app-level `src/utils`.
+- `apps/kimi-code` may only use core capabilities through `@moonshot-ai/kimi-code-sdk`. Do not import engine packages directly in app code.
+
+## TUI Coding Conventions
+
+- Do not over-encapsulate, especially for one- or two-line functions — do not introduce a two-layer wrapper, just inline.
+- Functions with no state / UI side effects do not belong as private methods on the `KimiTUI` class; put them in external utils.
+- Constants must live in the corresponding `constant` directory; they must not be scattered through component or logic code.
+- Inside `handleInput(data)`, when comparing a printable character (letter, digit, space, punctuation), it is **forbidden** to write literal comparisons such as `data === 'q'`. With the Kitty keyboard protocol enabled in terminals like VSCode, these keys are sent as CSI-u sequences (e.g. `\x1b[113u`), and a bare comparison will never match. Decode with `printableChar(data)` from `src/tui/utils/printable-key.ts` first, then compare; function keys continue to use `matchesKey(data, Key.*)`; control characters (codepoint < 32) may still be compared against the raw `data`. `test/tui/printable-key-guard.test.ts` enforces this in CI.
+
+## Color Rules (normative)
+
+The theme apply/switch mechanics live in the `write-tui` skill. The following rules are hard and guard-enforced:
+
+- Do not use chalk named colors such as `chalk.red`, `chalk.cyan`, `chalk.white`, `chalk.gray`, `chalk.dim`, or `chalk.yellow` directly.
+- If a component already has `colors`, use `chalk.hex(colors.<token>)(text)`.
+- If a component already has `state.theme.styles` or styles passed in, prefer helpers such as `styles.error(text)`, `styles.dim(text)`.
+- When new visual semantics have no token, first add a semantic field to `ColorPalette`, and fill in both `darkColors` and `lightColors`.
+- In light themes, text tokens against a white background must be at least 4.5:1; borders and large chrome must be at least 3:1.
+- Do not cache styled chalk functions at module top level. Theme switching must take effect within a single render, so styles must be generated on the render path from the current palette.
+- Non-comment code must not contain chalk named colors such as `chalk.white`, `chalk.cyan`, `chalk.red`, `chalk.green`, `chalk.gray`, `chalk.yellow`, `chalk.blue`, `chalk.magenta`, `chalk.whiteBright`, or `chalk.blackBright`. `test/tui/chalk-named-color-guard.test.ts` enforces this in CI.
+
+## General Coding Requirements
+
+- The startup path before the workspace trust gate (`KimiTUI.start()` -> `maybeRunWorkspaceTrustPrompt()`) must not spawn child processes by bare command name — on Windows, cmd.exe / CreateProcess resolve them from the current directory first, so a binary planted in an untrusted workspace would run before the user confirms trust. When an external command is unavoidable, resolve it with `resolveCommandPath` from `src/utils/process/resolve-command.ts`, which returns an absolute PATH hit and refuses matches inside the cwd.
+- For optional object properties, pass `undefined` directly — do not use conditional spread.
+- Optional object properties do not need to additionally allow `undefined` in the type.
+- Internal methods with only a single parameter should not be turned into options objects just for stylistic uniformity.
+- Except for a package's own `index.ts`, other `index.ts` files should prefer `export * from './module'`.

apps/kimi-code/README.md

@@ -0,0 +1,90 @@
+# @moonshot-ai/kimi-code
+
+> The Starting Point for Next-Gen Agents
+
+[![npm](https://img.shields.io/npm/v/@moonshot-ai/kimi-code)](https://www.npmjs.com/package/@moonshot-ai/kimi-code) [![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE)  [![Docs](https://img.shields.io/badge/docs-online-blue)](https://moonshotai.github.io/kimi-code/en/)
+
+## What is Kimi Code CLI
+
+Kimi Code CLI is an AI coding agent that runs in your terminal. It can read and edit code, run shell commands, search files, fetch web pages, and choose the next step based on the feedback it receives. It works out of the box with Moonshot AI's Kimi models and can also be configured to use other compatible providers.
+
+## Install
+
+The recommended install path is the official script. It does not require Node.js to be installed first.
+
+- **macOS / Linux**:
+
+```sh
+curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
+```
+
+- **Windows (PowerShell)**:
+
+```powershell
+irm https://code.kimi.com/kimi-code/install.ps1 | iex
+```
+
+> On Windows, install [Git for Windows](https://gitforwindows.org/) before first launch because Kimi Code CLI uses the bundled Git Bash as its shell environment. If Git Bash is installed in a custom location, set `KIMI_SHELL_PATH` to the absolute path of `bash.exe`.
+
+Then run it with a new Terminal session:
+
+```sh
+kimi --version
+```
+
+### Alternative: npm
+
+If you prefer npm, use Node.js 22.19.0 or later:
+
+```sh
+npm install -g @moonshot-ai/kimi-code
+```
+
+Or with pnpm:
+
+```sh
+pnpm add -g @moonshot-ai/kimi-code
+```
+
+For upgrade and uninstall instructions, see the [Getting Started guide](https://moonshotai.github.io/kimi-code/en/guides/getting-started).
+
+## Quick Start
+
+Open a project and start the interactive UI:
+
+```sh
+cd your-project
+kimi
+```
+
+On first launch, run `/login` inside Kimi Code CLI and choose either Kimi Code OAuth or a Kimi Platform API key. After login, try a first task:
+
+```
+Take a look at this project and explain the main directories.
+```
+
+## Key Features
+
+- **Single-binary distribution.** Install with one command — no Node.js setup, no PATH gymnastics, no global module conflicts.
+- **Blazing-fast startup.** The TUI is ready in milliseconds, so opening a session never feels heavy.
+- **Polished TUI.** A carefully tuned interface designed for long, focused agent sessions.
+- **Video input.** Drop a screen recording or demo clip into the chat — let the agent watch instead of typing out what's hard to describe in words.
+- **AI-native MCP configuration.** Add, edit, and authenticate Model Context Protocol servers conversationally via `/mcp-config` — no hand-editing JSON.
+- **Subagents for focused, parallel work.** Dispatch built-in `coder`, `explore`, and `plan` subagents in isolated context windows; the main conversation stays clean.
+- **Lifecycle hooks.** Run local commands at key points — gate risky tool calls, audit decisions, fire desktop notifications, wire into your own automation.
+
+## Documentation
+
+- Full docs: https://moonshotai.github.io/kimi-code/en/
+- 中文文档: https://moonshotai.github.io/kimi-code/zh/
+- Getting Started: https://moonshotai.github.io/kimi-code/en/guides/getting-started
+
+## Repository & Issues
+
+- Source: https://github.com/MoonshotAI/kimi-code
+- Issues: https://github.com/MoonshotAI/kimi-code/issues
+- Security: see SECURITY.md in the main repository
+
+## License
+
+MIT

apps/kimi-code/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "@moonshot-ai/kimi-code",
+  "version": "0.43.1",
+  "description": "The Starting Point for Next-Gen Agents",
+  "license": "MIT",
+  "author": "Moonshot AI",
+  "homepage": "https://github.com/MoonshotAI/kimi-code/tree/main/apps/kimi-code#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MoonshotAI/kimi-code.git",
+    "directory": "apps/kimi-code"
+  },
+  "bugs": {
+    "url": "https://github.com/MoonshotAI/kimi-code/issues"
+  },
+  "keywords": [
+    "kimi",
+    "kimi-code",
+    "cli",
+    "agent",
+    "coding-agent",
+    "ai",
+    "tui"
+  ],
+  "bin": {
+    "kimi": "dist/main.mjs"
+  },
+  "files": [
+    "dist",
+    "dist-web",
+    "native",
+    "scripts/postinstall.mjs",
+    "scripts/postinstall",
+    "README.md"
+  ],
+  "type": "module",
+  "imports": {
+    "#/tui/theme": "./src/tui/theme/index.ts",
+    "#/tui/commands": "./src/tui/commands/index.ts",
+    "#/cli/sub/web": "./src/cli/sub/web/index.ts",
+    "#/cli/sub/web/*": "./src/cli/sub/web/*.ts",
+    "#/generated/vis-web-asset": [
+      "./src/generated/vis-web-asset.ts",
+      "./src/generated/vis-web-asset.d.ts"
+    ],
+    "#/*": "./src/*.ts"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsdown && tsdown --config tsdown.dist-worker.config.ts && node scripts/copy-native-assets.mjs && node scripts/check-web-assets.mjs",
+    "prebuild": "node scripts/build-vis-asset.mjs",
+    "catalog:update": "node scripts/update-catalog.mjs --out dist/built-in-catalog.json",
+    "smoke": "node scripts/smoke.mjs",
+    "build:native:js": "node scripts/native/01-bundle.mjs",
+    "build:native:sea": "node scripts/native/build.mjs --profile=local",
+    "build:native:release": "node scripts/native/build.mjs --profile=release",
+    "package:native": "node scripts/native/package.mjs",
+    "produce:native:manifest": "node scripts/native/produce-manifest.mjs",
+    "release:native:resolve": "node scripts/native/resolve-release.mjs",
+    "test:native:smoke": "node scripts/native/smoke.mjs",
+    "dev": "node scripts/dev.mjs",
+    "dev:cli-only": "tsx --import ../../build/register-raw-text-loader.mjs ./src/main.ts",
+    "dev:server": "KIMI_CODE_DEV_SERVER=1 tsx --tsconfig ./tsconfig.dev.json --import ../../build/register-raw-text-loader.mjs ./src/main.ts web --no-open --debug-endpoints",
+    "dev:kap-server": "KIMI_CODE_DEV_SERVER=1 tsx --tsconfig ./tsconfig.dev.json --import ../../build/register-raw-text-loader.mjs ./src/main.ts web --no-open --debug-endpoints",
+    "dev:kap-server:multi": "KIMI_CODE_DEV_SERVER=1 tsx --tsconfig ./tsconfig.dev.json --import ../../build/register-raw-text-loader.mjs ./src/main.ts web --no-open --debug-endpoints",
+    "dev:server:restart": "node scripts/dev-server-restart.mjs",
+    "dev:plugin-marketplace": "node scripts/dev-plugin-marketplace-server.mjs",
+    "build:plugin-marketplace": "node scripts/build-plugin-marketplace-cdn.mjs",
+    "dev:prod": "node dist/main.mjs",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm -w run build:packages && vitest run",
+    "e2e": "pnpm -w run build:packages && KIMI_E2E=1 vitest run test/e2e",
+    "e2e:real": "pnpm -w run build:packages && KIMI_E2E_REAL=1 vitest run test/e2e/real-llm-smoke.e2e.test.ts",
+    "postinstall": "node scripts/postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "@mariozechner/clipboard": "^0.3.9",
+    "node-pty": "^1.1.0"
+  },
+  "devDependencies": {
+    "@moonshot-ai/acp-server": "workspace:^",
+    "@moonshot-ai/agent-core-v2": "workspace:^",
+    "@moonshot-ai/kap-server": "workspace:^",
+    "@moonshot-ai/kimi-code-oauth": "workspace:^",
+    "@moonshot-ai/kimi-code-sdk": "workspace:^",
+    "@moonshot-ai/kimi-telemetry": "workspace:^",
+    "@moonshot-ai/migration-legacy": "workspace:^",
+    "@moonshot-ai/minidb": "workspace:^",
+    "@moonshot-ai/pi-tui": "workspace:^",
+    "@moonshot-ai/remote-control": "workspace:^",
+    "@moonshot-ai/vis-server": "workspace:^",
+    "@moonshot-ai/vis-web": "workspace:*",
+    "@types/qrcode": "^1.5.6",
+    "@types/semver": "^7.7.0",
+    "@types/ws": "^8.18.0",
+    "@types/yazl": "^2.4.6",
+    "chalk": "^5.4.1",
+    "cli-highlight": "^2.1.11",
+    "commander": "^13.1.0",
+    "jimp": "^1.6.1",
+    "pathe": "^2.0.3",
+    "postject": "1.0.0-alpha.6",
+    "semver": "^7.7.4",
+    "smol-toml": "^1.6.1",
+    "tsx": "^4.21.0",
+    "yazl": "^3.3.1",
+    "zod": "^4.3.6"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dependencies": {
+    "qrcode": "^1.5.4",
+    "ws": "^8.18.0"
+  }
+}

apps/kimi-code/tsconfig.dev.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "experimentalDecorators": true
+  },
+  "include": [
+    "src",
+    "test",
+    "../../packages/*/src/**/*.ts",
+    "../../packages/*/src/**/*.tsx",
+    "../../packages/*/test/**/*.ts"
+  ]
+}

apps/kimi-code/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "experimentalDecorators": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src", "test", "../../packages/agent-core-v2/src/env.d.ts"]
+}

apps/kimi-code/tsdown.config.ts

@@ -0,0 +1,40 @@
+import { resolve } from 'node:path';
+
+import { defineConfig } from 'tsdown';
+
+import { rawTextPlugin } from '../../build/raw-text-plugin.mjs';
+import { BUILT_IN_CATALOG_DEFINE, builtInCatalogDefine } from './scripts/built-in-catalog.mjs';
+
+const appRoot = import.meta.dirname;
+
+export default defineConfig({
+  entry: ['./src/main.ts'],
+  format: ['esm'],
+  outDir: 'dist',
+  clean: true,
+  dts: false,
+  hash: false,
+  banner: {
+    js: [
+      '#!/usr/bin/env node',
+      "import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';",
+      "import { dirname as __cjsShimDirname } from 'node:path';",
+      'const __filename = __cjsShimFileURLToPath(import.meta.url);',
+      'const __dirname = __cjsShimDirname(__filename);',
+    ].join('\n'),
+  },
+  plugins: [rawTextPlugin()],
+  alias: {
+    '@': resolve(appRoot, 'src'),
+  },
+  define: {
+    [BUILT_IN_CATALOG_DEFINE]: builtInCatalogDefine(),
+  },
+  deps: {
+    onlyBundle: false,
+  },
+  outputOptions: {
+    codeSplitting: false,
+    entryFileNames: 'main.mjs',
+  },
+});

apps/kimi-code/tsdown.dist-worker.config.ts

@@ -0,0 +1,41 @@
+// Bundles the kap-server global-search worker
+// (packages/kap-server/src/search/worker/entry.ts) into ONE self-contained
+// `dist/search-worker.mjs` sibling of the main bundle. The search worker
+// host resolves it at runtime next to `dist/main.mjs` (dev/tests use the TS
+// source; the SEA binary uses the extracted asset from
+// tsdown.worker.config.ts). Separate config because rolldown forbids
+// `codeSplitting: false` with multiple inputs.
+
+import { resolve } from 'node:path';
+
+import { defineConfig } from 'tsdown';
+
+const appRoot = import.meta.dirname;
+
+export default defineConfig({
+  entry: {
+    'search-worker': resolve(
+      appRoot,
+      '../../packages/kap-server/src/search/worker/entry.ts',
+    ),
+  },
+  format: ['esm'],
+  // Shares the main bundle's dist (never wipe it) and lands as
+  // `dist/search-worker.mjs`.
+  outDir: 'dist',
+  clean: false,
+  dts: false,
+  hash: false,
+  platform: 'node',
+  target: 'node24',
+  sourcemap: false,
+  minify: false,
+  silent: true,
+  deps: {
+    onlyBundle: false,
+  },
+  outputOptions: {
+    codeSplitting: false,
+    entryFileNames: '[name].mjs',
+  },
+});

apps/kimi-code/tsdown.native.config.ts

@@ -0,0 +1,69 @@
+import { readFileSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import { resolve } from 'node:path';
+
+import { defineConfig } from 'tsdown';
+
+import { rawTextPlugin } from '../../build/raw-text-plugin.mjs';
+import { BUILT_IN_CATALOG_DEFINE, builtInCatalogDefine } from './scripts/built-in-catalog.mjs';
+
+const appRoot = import.meta.dirname;
+const packageJson = JSON.parse(
+  readFileSync(new URL('./package.json', import.meta.url), 'utf-8'),
+) as { version: string };
+
+const builtins = new Set([
+  ...builtinModules,
+  ...builtinModules.map((name) => `node:${name}`),
+]);
+const optionalNativeDependencies = new Set(['cpu-features']);
+
+function shouldAlwaysBundle(id: string): boolean {
+  if (builtins.has(id) || id.startsWith('node:')) return false;
+  if (optionalNativeDependencies.has(id)) return false;
+  // Everything else is force-bundled, which covers `@moonshot-ai/*` (incl.
+  // vis-server for `kimi vis`) plus its transitive `hono` / `@hono/node-server`
+  // — so the SEA bundle is self-contained (check-bundle.mjs enforces this).
+  return true;
+}
+
+function buildTarget(): string {
+  return process.env['KIMI_CODE_BUILD_TARGET'] ?? `${process.platform}-${process.arch}`;
+}
+
+export default defineConfig({
+  entry: ['./src/main.ts'],
+  format: ['cjs'],
+  outDir: 'dist-native/intermediates',
+  clean: true,
+  dts: false,
+  fixedExtension: true,
+  hash: false,
+  platform: 'node',
+  target: 'node24',
+  banner: { js: '#!/usr/bin/env node' },
+  plugins: [rawTextPlugin()],
+  alias: {
+    '@': resolve(appRoot, 'src'),
+  },
+  define: {
+    [BUILT_IN_CATALOG_DEFINE]: builtInCatalogDefine(),
+    __KIMI_CODE_VERSION__: JSON.stringify(packageJson.version),
+    __KIMI_CODE_CHANNEL__: JSON.stringify(process.env['KIMI_CODE_CHANNEL'] ?? ''),
+    __KIMI_CODE_COMMIT__: JSON.stringify(process.env['KIMI_CODE_COMMIT'] ?? ''),
+    __KIMI_CODE_BUILD_TARGET__: JSON.stringify(buildTarget()),
+    __KIMI_CODE_NATIVE_BUNDLE__: 'true',
+  },
+  deps: {
+    alwaysBundle: shouldAlwaysBundle,
+    neverBundle: [...optionalNativeDependencies],
+    onlyBundle: false,
+  },
+  outputOptions: {
+    codeSplitting: false,
+    entryFileNames: 'main.cjs',
+  },
+  checks: {
+    legacyCjs: false,
+  },
+});

apps/kimi-code/tsdown.worker.config.ts

@@ -0,0 +1,50 @@
+// Dedicated tsdown config that bundles the off-main-thread workers into
+// self-contained ESM files so they can ride the SEA blob as assets
+// (02-sea-blob.mjs) and be spawned from disk at runtime:
+//   - text-build-worker.mjs: the minidb text-build worker
+//     (packages/minidb/src/worker/text-build-worker.ts);
+//   - search-worker.mjs: the kap-server global-search worker
+//     (packages/kap-server/src/search/worker/entry.ts).
+// Without them the bundled binary lacks the worker entry files on disk and
+// heavy index work degrades to the inline main-thread cores, stalling the
+// event loop on large corpora. Runs after the main bundle with clean:false
+// so all verified files remain.
+//
+// One config per entry: rolldown forbids `codeSplitting: false` with
+// multiple inputs, and each worker must be a single self-contained file
+// (check-bundle.mjs enforces zero remaining externals/relative imports).
+
+import { resolve } from 'node:path';
+
+import { defineConfig } from 'tsdown';
+
+const here = import.meta.dirname;
+
+function workerConfig(name: string, entry: string) {
+  return defineConfig({
+    entry: { [name]: resolve(here, entry) },
+    format: ['esm'],
+    outDir: resolve(here, 'dist-native/intermediates'),
+    entryFileNames: '[name].mjs',
+    codeSplitting: false,
+    platform: 'node',
+    target: 'node24',
+    dts: false,
+    sourcemap: false,
+    minify: false,
+    silent: true,
+    deps: {
+      // Force-bundle the workspace packages the entries import
+      // (`@moonshot-ai/minidb` and its subpaths) so the output is
+      // self-contained.
+      alwaysBundle: [/^@moonshot-ai\//],
+    },
+    // The intermediates dir also holds main.cjs & co. — never wipe it.
+    clean: false,
+  });
+}
+
+export default [
+  workerConfig('text-build-worker', '../../packages/minidb/src/worker/text-build-worker.ts'),
+  workerConfig('search-worker', '../../packages/kap-server/src/search/worker/entry.ts'),
+];

apps/kimi-code/vitest.config.ts

@@ -0,0 +1,20 @@
+import { resolve } from 'node:path';
+
+import { defineConfig } from 'vitest/config';
+
+const appRoot = import.meta.dirname;
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@': resolve(appRoot, 'src'),
+    },
+  },
+  test: {
+    name: 'cli',
+    env: {
+      KIMI_LOG_LEVEL: 'off',
+    },
+    include: ['test/**/*.test.ts', 'test/**/*.test.tsx'],
+  },
+});

apps/kimi-inspect/AGENTS.md

@@ -0,0 +1,44 @@
+# kimi-inspect Agent Guide
+
+Web inspector for the kap-server `/api/v1/debug` RPC surface — workspace/session browser, per-session chat, and Service panels (data + trigger buttons) for the Session and Agent scopes.
+
+## Top-level views
+
+A left icon rail (`src/components/NavRail.tsx`) switches top-level views:
+
+- **Chat workspace** — the per-session chat (see "Chat view" below), with the session tree on the left: `src/components/Sidebar.tsx` is a single-column workspace → session tree over the v2 list's grouped projection (`GET /api/v2/sessions?view=by_workspace`, client in `src/sessions/api.ts` — v1-style `{ code, msg, data }` envelope, opaque-cursor pagination over groups; each workspace group carries its first `group.page_size` sessions plus the full matching total, and a "Show all" row falls back to the flat per-workspace listing). Preset views in `src/sessions/views.ts` map onto the endpoint's status / archived / git query conditions; the active view, collapsed workspaces, and panel width persist to localStorage; live activity badges come from the hub.
+- **Global message search** (`src/components/SearchView.tsx`) — cross-session full-text search over `POST /api/v1/search`, cursor-paged via a manual Load more; an exact-match checkbox maps to the API's `mode: 'literal'` substring search, which ignores sort and orders newest-first; a `live`/`index` badge on the results shows which server route served them (in-memory session transcript vs the persisted index).
+- **Model Catalog** (`src/components/ModelCatalogView.tsx`) — every Provider with its Models and the default marker, via `IModelCatalog` / `IModelService` channel proxies, with per-model ping and session creation actions.
+- **App Services** (`src/components/AppServicesView.tsx`) — the app-scope Service reflection, full width, joined by the **Workspace Services** view (`src/components/WorkspaceServicesView.tsx`) — the workspace-scope counterpart with a left sidebar directory browser (`src/components/WorkspaceDirBrowser.tsx` — server-side fs browsing over the App-scope `IHostFolderBrowser`, marking entries that are registered workspaces with their `IWorkspaceTrust` trust state, and registering a picked folder on demand via `IWorkspaceService.createOrTouch`), its proxies riding the `/workspace/:id` route, which materializes the handler on demand via `IWorkspaceLifecycleService.handlerFor`.
+- **DI view** (`src/components/DiInspectionView.tsx`) — the engine's Service × Effect × DI debug surface over the App-scope `IDebugLedgerService` / `IDebugGraphService` / `IDebugEventsService` / `IDebugCascadeService`: the unit tree = ledger tree with unprovide / update / dispose triggers, the dependency DAG as Miller columns (`di/DiGraphPanel.tsx`), the event-subscription ledger (unit-book `on:<name>` entries + per-bus listener counts, `di/DiEventsPanel.tsx`), the cascade history, and the waiting area; the five panels poll on a short interval and refresh eagerly off the global `event.di.unit_changed` WS frame via `src/activity/di.ts`, which invalidates the `['di']` react-query prefix.
+
+The **Agent scope** stays in the Chat view's right dock (`src/components/RightPanel.tsx` — Audit / Agent / State / Session tabs) across two of them:
+
+- `Agent` tab — `Inspector`: agent switcher + a Plan lookup card (`PlanCard` in `src/components/Inspector.tsx` — deriving the reviewed plan of one ExitPlanMode tool call, or every plan of the agent, from the message stream: a full `GET /sessions/{id}/history` read via `src/transcript/api.ts`'s `fetchFullHistory` + client-side `projectPlans` in `src/transcript/plan.ts`) plus the agent Service panels.
+- `State` tab — every key an Agent Service registered into the agent-state container, polled live via `IAgentStateService.snapshot()` — the same live diff-tree view as the session State tab, sharing `StateCard` from `src/components/StateCard.tsx`.
+
+The **Session scope** lives in the same right dock as the `Session` tab (`src/components/SessionPane.tsx`, embedded by `RightPanel`) with two sub-tabs: Services (the pending-interactions card — `src/components/InteractionsCard.tsx`, which lists and answers approvals/questions over the public REST endpoints `/api/v1/sessions/{id}/approvals|questions` via `src/interactions/api.ts`, since the interaction kernel is a process-global singleton with no debug channel — plus the session Service panels) and State (every key a Session Service registered into the session-state container, read on demand via `ISessionStateService.snapshot()`).
+
+## Channel layer
+
+Built on its own old-klient-style channel layer (`src/channel/`: the VS Code `ProxyChannel` model — service-bound `IChannel`, HTTP `ProxyChannel` for calls routed to `/api/v1/debug`), typed by `agent-core-v2` Service interfaces; `GET /api/v1/debug/channels` loads the whole wire protocol 1:1 (every scoped Service, no whitelist). There is no Service-event push channel: panels fetch/refresh on demand (`Sidebar` polls react-query on a 15 s interval), and a connection failure shows a blocking "Debug surface unavailable" screen instead of falling back anywhere.
+
+## Session activity
+
+Session-level coarse status is the one exception to no-push: `src/activity/` holds a second `/api/v1/ws` client (`GlobalEventsWs`) that subscribes to nothing and consumes the server-pushed global facts — `event.session.work_changed` updates a per-session activity map (`SessionActivityHub` + subscribe/version store, seeded on connect/reconnect from `GET /api/v1/sessions`), while `event.session.created` / `event.session.archived` / `session.meta.updated` / `event.workspace.*` invalidate the `['sessions']` / `['v2-sessions']` / `['workspaces']` queries (an archive also drops the session's live activity entry, since no further `work_changed` frames will correct a stale badge); the session tree rows render `running` / `approval` / `question` / `failed` badges from it via `useSessionActivities` (live facts override the REST `activity.status`).
+
+## Dev server
+
+The Vite dev server proxies `/api` to a running kap-server (`KIMI_SERVER_URL`, default `http://127.0.0.1:58627`) and exposes `GET /__inspect/servers` (`vite/serverDiscovery.ts`), which scans the local kap-server instance registry (`~/.kimi-code/server/instances` + legacy `lock`) and the home token so the app can zero-config auto-connect and switch servers from the header dropdown at runtime.
+
+## Chat view
+
+The per-session chat (`src/components/ChatView.tsx`) renders turn-granularly from the **message protocol v3** surface and carries an in-chat search bar (`src/components/ChatSearchBar.tsx`): it searches the current session via `POST /api/v1/search` with `container: { session_id }` (usually served by the live route, since selecting a session resumes it), and a result click funnels through the app shell's `openSearchHit` — the same agent-switch + `ChatJump` (page-back, scroll, flash) path the global search view uses.
+
+Persisted state comes from `GET /api/v1/sessions/{id}/history` only (client in `src/transcript/api.ts`): the initial load reads the newest page (default 500 messages, replace mode), older history auto-pages with `before_turn` via an IntersectionObserver sentinel at the top of the scroll view (prepend mode; a short or empty page ends paging — the response deliberately carries no has-more flag), and each timeline item is wrapped in `content-visibility: auto` + `contain-intrinsic-size` so the browser virtualizes off-screen rendering natively (no windowing library).
+
+`/api/v3/ws` (client in `src/transcript/ws.ts`) is the live channel: server `hello` → `subscribe {id, session_id, agent_ids: [agent]}` → `ack` → recovery payload (in-flight entities + pending interactions + running tasks + todo + `session.state`) → live traffic, heartbeat at the WS protocol level. The store (`src/transcript/store.ts`) applies recovery and live messages through one idempotent path — entity messages upsert by (type, own id) with content fields authoritative, the delta family (`assistant.delta` / `thinking.delta` / `tool_call.delta`) appends by id, `tool.progress` patches the entity, `system(undo/clear)` truncates the timeline by `payload.removed_ids` (subtree included, linked interactions cascaded), and `interaction` / `task` / `todo` / `session.state` upsert their own single-source maps; an upsert older than the held entity's `timestamp` is skipped. Notifications are throttled trailing-edge so the per-token delta stream does not re-render per token. Every subscribe ack (initial and every reconnect) triggers an `after_step` catch-up from the newest terminal step; an empty catch-up whose anchor vanished (undo/clear while away) falls back to a full refresh. All of this is orchestrated by `ChatChannel` (`src/transcript/channel.ts`) — no buffering, no cursors beyond the two REST page cursors, no reset frames.
+
+## Transcript audit panel
+
+The Transcript audit panel (`src/components/audit/`, the `Audit` tab of the chat view's right dock — `src/components/RightPanel.tsx`, fed the trail by `ChatView`'s `onTrailChange`) replays how the visible store was built: an `AuditTrail` (`src/audit/`) records every step — each REST history page (request + replace/prepend/tail mode), every WS message (entity/delta/state as applied), channel events (subscribe ack, reconnect, catch-up fallback, protocol errors), and prompt/cancel actions — with the resulting immutable `ChatState` per entry; the panel offers a draggable timeline plus a Diff tab (structural diff vs the previous entry: added/modified/removed colored, long strings tail-truncated, all fields kept), a full State view (the flat entity timeline plus the interaction/task/todo/session.state entities), and the raw Event payload.

apps/kimi-inspect/README.md

@@ -0,0 +1,57 @@
+# kimi-inspect
+
+Web inspector for the kap-server `/api/v1/debug` RPC surface — a read/trigger
+window into a running Kimi Code engine (workspaces, sessions, agents, and the
+scoped DI registry).
+
+## Run
+
+1. Start a kap-server with the debug surface mounted (repo dev scripts do this
+   for you): `pnpm dev:v1` / `pnpm dev:v2` from the repo root pass
+   `--debug-endpoints` on a loopback bind; the surface inherits the global
+   bearer auth.
+2. `pnpm --filter @moonshot-ai/kimi-inspect dev` — the Vite dev server proxies
+   `/api` to the server (`KIMI_SERVER_URL`, default `http://127.0.0.1:58627`)
+   and auto-discovers running instances
+   (`~/.kimi-code/server/instances`); switch servers from the header dropdown.
+
+A connection failure shows a blocking "Debug surface unavailable" screen —
+there is no fallback data source.
+
+## Views (left icon rail)
+
+- **Chat workspace** — session list (activity badges from the global-events WS)
+  plus a transcript-driven per-session chat; the right dock hosts the
+  Agent-scope Service panels, a plan lookup card, and the transcript audit
+  panel. The Session scope has its own column (pending interactions + session
+  Service panels, and a State tab).
+- **Search** — cross-session full-text search over `POST /api/v1/search`
+  (cursor-paged; exact-match maps to the API's `literal` mode; a `live`/`index`
+  badge shows which server route served the results).
+- **Model Catalog** — every provider with its models and the default marker,
+  with per-model ping and session creation actions.
+- **App / Workspace Services** — the full Service reflection over the App
+  scope, and over each Workspace scope (picked via the directory browser;
+  workspace handlers materialize on demand).
+- **DI** — the engine's Service × Effect × DI debug surface, four panels fed
+  by the App-scope debug Services (`IDebugLedgerService` / `IDebugGraphService`
+  / `IDebugCascadeService`) and refreshed eagerly off the `event.di.unit_changed`
+  WS frame:
+  - **Unit tree** — scope → unit → ledger entries (label, five-state
+    `Pending / Activating / Active / Unloading / Failed`, uid, `pinned` flag,
+    unit error object), with **unprovide / update / dispose** triggers.
+  - **Graph** — the dependency DAG (instance edges across scopes + collection
+    edges).
+  - **Cascade** — the cascade transaction history ring (changes, contagion set,
+    torn-down / rebuilt / failed, abort wait, duration).
+  - **Pending** — the waiting area: units parked on unsatisfied dependencies
+    with their missing-token sets.
+
+## Notes for maintainers
+
+- The channel layer (`src/channel/`) is a VS Code-style `ProxyChannel`:
+  `GET /api/v1/debug/channels` enumerates every scoped Service — there is no
+  whitelist; new Services appear automatically.
+- There is no Service-event push channel besides the global events listed
+  above; panels fetch/refresh on demand (react-query, 15 s poll) plus the
+  `event.di.unit_changed` invalidation for the DI view.

apps/kimi-inspect/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Kimi Inspect</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

apps/kimi-inspect/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@moonshot-ai/kimi-inspect",
+  "version": "0.0.0",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "imports": {
+    "#/*": {
+      "types": [
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ],
+      "default": "./src/*"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@moonshot-ai/agent-core-v2": "workspace:^",
+    "@moonshot-ai/kap-server": "workspace:^",
+    "@tanstack/react-query": "^5.74.4",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.1.4",
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.2",
+    "@vitejs/plugin-react": "^4.4.1",
+    "tailwindcss": "^4.1.4",
+    "typescript": "6.0.2",
+    "vite": "^6.3.3",
+    "vitest": "4.1.4"
+  }
+}

apps/kimi-inspect/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  // Mirror the repo root tsconfig: agent-core-v2 is consumed through source
+  // `exports`, so its sources are type-checked here too, and the strictness
+  // flags must match the root exactly. The src includes are required (not
+  // just for speed): agent-core-v2 fills interfaces like `AgentTaskInfoByKind`
+  // via cross-module `declare module` augmentation, and those collapse to
+  // `never` when the augmenting files are not in the program. Only the
+  // environment (DOM + vite client types) differs.
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "types": ["node", "vite/client"],
+    "noEmit": true
+  },
+  "include": [
+    "src",
+    "vite",
+    "vite.config.ts",
+    "../../packages/agent-core-v2/src"
+  ],
+  "exclude": ["../../packages/agent-core-v2/src/human"]
+}

apps/kimi-inspect/vite.config.ts

@@ -0,0 +1,37 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+
+import { serverDiscoveryPlugin } from './vite/serverDiscovery';
+
+const webPort = Number(process.env['INSPECT_PORT']) || 5176;
+// Where the dev proxy forwards server traffic. The app can also connect to an
+// arbitrary server URL typed into the connect screen (loopback cross-origin is
+// allowed by kap-server), but the default connection is same-origin through
+// this proxy so no CORS / Origin handling is involved.
+const serverTarget = process.env['KIMI_SERVER_URL'] || 'http://127.0.0.1:58627';
+
+export default defineConfig({
+  plugins: [react(), tailwindcss(), serverDiscoveryPlugin({ proxyTarget: serverTarget })],
+  define: {
+    __KIMI_INSPECT_PROXY_TARGET__: JSON.stringify(serverTarget),
+  },
+  server: {
+    port: webPort,
+    strictPort: false,
+    proxy: {
+      '/api': { target: serverTarget, changeOrigin: true, ws: true },
+    },
+  },
+  preview: {
+    port: Number(process.env['INSPECT_PREVIEW_PORT']) || 4176,
+    proxy: {
+      '/api': { target: serverTarget, changeOrigin: true, ws: true },
+    },
+  },
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+    target: 'es2022',
+  },
+});

apps/vis/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@moonshot-ai/vis",
+  "version": "0.1.1",
+  "private": true,
+  "description": "Debug visualization tool for kimi-code sessions",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "dev": "node scripts/dev.mjs",
+    "build": "pnpm --filter @moonshot-ai/vis-server build && pnpm --filter @moonshot-ai/vis-web build && node scripts/copy-web-dist.mjs",
+    "prestart": "pnpm run build",
+    "start": "node server/dist/server.mjs"
+  },
+  "devDependencies": {
+    "concurrently": "^9.1.2"
+  }
+}

apps/vscode/.vscode-test.mjs

@@ -0,0 +1,5 @@
+import { defineConfig } from "@vscode/test-cli";
+
+export default defineConfig({
+  files: "out/test/**/*.test.js",
+});

apps/vscode/.vscodeignore

@@ -0,0 +1,50 @@
+# Source files
+src/**
+webview-ui/**
+shared/**
+**/*.ts
+**/*.tsx
+
+# Node modules (bundled via esbuild/vite)
+**/node_modules/**
+
+# Build configs
+.vscode/**
+tsconfig.json
+tsdown.config.ts
+vitest.config.ts
+.vscode-test.mjs
+eslint.config.mjs
+webview-ui/tsconfig.json
+webview-ui/vite.config.ts
+webview-ui/components.json
+
+# Scripts
+scripts/**
+test/**
+runtime/**
+artifacts/**
+
+# Never package generated test/debug state
+**/.kimi/**
+**/.kimi-code/**
+**/cache/**
+**/caches/**
+**/credentials/**
+**/logs/**
+**/profile/**
+**/profiles/**
+**/session/**
+**/sessions/**
+**/tokens/**
+**/*.jsonl
+**/*.log
+
+# Other
+.gitignore
+**/*.map
+*.vsix
+**/.DS_Store
+
+# Prevent parent directory traversal via symlinks
+../**

apps/vscode/CHANGELOG.md

@@ -0,0 +1,203 @@
+# Changelog
+
+## 0.7.5
+
+### Patch Changes
+
+- [#3453](https://github.com/MoonshotAI/kimi-code/pull/3453) [`411572e`](https://github.com/MoonshotAI/kimi-code/commit/411572e166edee8581ba9c5a7f1bbf6c8b405606) Thanks [@Grapedge](https://github.com/Grapedge)! - Highlight matched characters in @ file suggestions and allow folders to be inserted as mentions.
+
+- [#3453](https://github.com/MoonshotAI/kimi-code/pull/3453) [`411572e`](https://github.com/MoonshotAI/kimi-code/commit/411572e166edee8581ba9c5a7f1bbf6c8b405606) Thanks [@Grapedge](https://github.com/Grapedge)! - Show the image/video picker entry in the @ menu only before a search query is typed, and remove the Browse folders mode.
+
+- [#3453](https://github.com/MoonshotAI/kimi-code/pull/3453) [`411572e`](https://github.com/MoonshotAI/kimi-code/commit/411572e166edee8581ba9c5a7f1bbf6c8b405606) Thanks [@Grapedge](https://github.com/Grapedge)! - Fix the @ and / suggestion lists jittering when the mouse rests at the scroll edge.
+
+- Updated dependencies [[`411572e`](https://github.com/MoonshotAI/kimi-code/commit/411572e166edee8581ba9c5a7f1bbf6c8b405606)]:
+  - @moonshot-ai/kimi-code-sdk@0.20.0
+
+## 0.7.4
+
+### Patch Changes
+
+- [#3371](https://github.com/MoonshotAI/kimi-code/pull/3371) [`9e88152`](https://github.com/MoonshotAI/kimi-code/commit/9e881528a89945a373002b0b229f91735e8f2c4f) Thanks [@tpoisonooo](https://github.com/tpoisonooo)! - Fix prompts remaining queued forever after reopening a session.
+
+- [#3366](https://github.com/MoonshotAI/kimi-code/pull/3366) [`9619277`](https://github.com/MoonshotAI/kimi-code/commit/961927739ef34819d67d76fa5870cbe4ba7a01ff) Thanks [@kimi-agent-bot](https://github.com/kimi-agent-bot)! - Use the Unicode ellipsis "…" in user-facing TUI and VS Code webview text.
+
+## 0.7.3
+
+### Patch Changes
+
+- [#3098](https://github.com/MoonshotAI/kimi-code/pull/3098) [`75550c5`](https://github.com/MoonshotAI/kimi-code/commit/75550c5686cb867c0cb34bc515997d5e6305fc94) Thanks [@LCZcn96](https://github.com/LCZcn96)! - Restore live context-window usage updates after switching to the v2 engine.
+
+- [#3276](https://github.com/MoonshotAI/kimi-code/pull/3276) [`f34b2ec`](https://github.com/MoonshotAI/kimi-code/commit/f34b2ecfb01dc194aaa3f209a00772991caad3f3) Thanks [@Grapedge](https://github.com/Grapedge)! - Fix streamed replies occasionally showing every character twice and tool calls appearing in duplicate.
+
+- Updated dependencies [[`75550c5`](https://github.com/MoonshotAI/kimi-code/commit/75550c5686cb867c0cb34bc515997d5e6305fc94), [`d723cc4`](https://github.com/MoonshotAI/kimi-code/commit/d723cc47ee43e5ca3c3c4ec2473f205d44acede2)]:
+  - @moonshot-ai/kimi-code-sdk@0.19.2
+
+## 0.7.2
+
+### Patch Changes
+
+- [#3079](https://github.com/MoonshotAI/kimi-code/pull/3079) [`35befdc`](https://github.com/MoonshotAI/kimi-code/commit/35befdcef2be344d931ea20063cb64113350dc4b) Thanks [@gaoyuan1223m](https://github.com/gaoyuan1223m)! - Fix multi-select questions jumping to the next question after only one answer is selected.
+
+- Updated dependencies [[`3d77620`](https://github.com/MoonshotAI/kimi-code/commit/3d7762003a4a35cbeb8571d471c6898a006152e6)]:
+  - @moonshot-ai/kimi-code-sdk@0.19.1
+
+## 0.7.1
+
+### Patch Changes
+
+- [#3026](https://github.com/MoonshotAI/kimi-code/pull/3026) [`13857f3`](https://github.com/MoonshotAI/kimi-code/commit/13857f383200881aa77dc972a8963ba421eeb2b6) Thanks [@bj456736](https://github.com/bj456736)! - Show plugin- and file-declared MCP servers as read-only entries in the MCP servers panel.
+
+- Updated dependencies [[`d833a1a`](https://github.com/MoonshotAI/kimi-code/commit/d833a1a893c4d69d96af542f40557442992085e0), [`61591bc`](https://github.com/MoonshotAI/kimi-code/commit/61591bce09f4467aa1664cb8ecb6aa6904b7accd), [`d833a1a`](https://github.com/MoonshotAI/kimi-code/commit/d833a1a893c4d69d96af542f40557442992085e0), [`13857f3`](https://github.com/MoonshotAI/kimi-code/commit/13857f383200881aa77dc972a8963ba421eeb2b6)]:
+  - @moonshot-ai/kimi-code-sdk@0.19.0
+
+## 0.7.0
+
+### Minor Changes
+
+- [#2916](https://github.com/MoonshotAI/kimi-code/pull/2916) [`7475c2e`](https://github.com/MoonshotAI/kimi-code/commit/7475c2e2e3dd86ac0b8a8d51d4f1d233ed7df797) Thanks [@Grapedge](https://github.com/Grapedge)! - Run the extension on the v2 agent engine by default; the interface, sessions, and workflows are unchanged. To roll back, enable the `kimi.useAgentCoreV1` setting and reload the window.
+
+### Patch Changes
+
+- Updated dependencies [[`6be2697`](https://github.com/MoonshotAI/kimi-code/commit/6be26978b123bacf1c5ebce52bbeb6f7b7ff0629), [`7475c2e`](https://github.com/MoonshotAI/kimi-code/commit/7475c2e2e3dd86ac0b8a8d51d4f1d233ed7df797), [`7475c2e`](https://github.com/MoonshotAI/kimi-code/commit/7475c2e2e3dd86ac0b8a8d51d4f1d233ed7df797), [`7475c2e`](https://github.com/MoonshotAI/kimi-code/commit/7475c2e2e3dd86ac0b8a8d51d4f1d233ed7df797)]:
+  - @moonshot-ai/kimi-code-sdk@0.18.0
+
+## 0.6.9
+
+### Patch Changes
+
+- Updated dependencies [[`c9bfe8b`](https://github.com/MoonshotAI/kimi-code/commit/c9bfe8b2c8314ba4ef8806fb3b92ac654c1d1860), [`c212ae9`](https://github.com/MoonshotAI/kimi-code/commit/c212ae9715371c0d7939c15e664acbe0d7cf7fc3)]:
+  - @moonshot-ai/kimi-code-sdk@0.17.0
+
+## 0.6.8
+
+### Patch Changes
+
+- Updated dependencies [[`437a1b8`](https://github.com/MoonshotAI/kimi-code/commit/437a1b8ba1b7e0f6662bdadc669564fdc58c3f5a), [`0b2e803`](https://github.com/MoonshotAI/kimi-code/commit/0b2e803d5e71afaab45212bb2ee6117ecbf8bbc9), [`3c9e3b2`](https://github.com/MoonshotAI/kimi-code/commit/3c9e3b297cf5286c761159c1b4d642c478fd394d)]:
+  - @moonshot-ai/kimi-code-sdk@0.16.0
+
+## 0.6.7
+
+### Patch Changes
+
+- [#2326](https://github.com/MoonshotAI/kimi-code/pull/2326) [`302b2cd`](https://github.com/MoonshotAI/kimi-code/commit/302b2cd680e0ec66f68b4572238de84ce311c5f4) Thanks [@gaoyuan1223m](https://github.com/gaoyuan1223m)! - Fix only the first question being answerable when the agent asked multiple questions at once; each question is now answered one by one and submitted together.
+
+## 0.6.6
+
+### Patch Changes
+
+- [#2393](https://github.com/MoonshotAI/kimi-code/pull/2393) [`6d0a046`](https://github.com/MoonshotAI/kimi-code/commit/6d0a046488edda56219961b253c4787abae7a113) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Fix new users getting stranded on "Model setup required" with no way back to sign-in when the first login finishes authorization but fails to complete model setup; the screen now offers a path back to the sign-in page so login can be retried.
+- [#2402](https://github.com/MoonshotAI/kimi-code/pull/2402) [`0f3b106`](https://github.com/MoonshotAI/kimi-code/commit/0f3b106c4260ad626f66bc5c457a535d3163f2bc) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Reword the sign-in waiting message from "Waiting for authorization" to "Waiting for authentication".
+
+- Updated dependencies [[`40172c7`](https://github.com/MoonshotAI/kimi-code/commit/40172c7ca96ca981b043b793588dd32e898979fa)]:
+  - @moonshot-ai/kimi-code-sdk@0.15.0
+
+## 0.6.5
+
+### Patch Changes
+
+- [#1994](https://github.com/MoonshotAI/kimi-code/pull/1994) [`beeb964`](https://github.com/MoonshotAI/kimi-code/commit/beeb964393c8f9a38c2b1e2273e4415fc434b16d) Thanks [@RealKai42](https://github.com/RealKai42)! - Reduce webview streaming re-render churn: settled assistant messages no longer re-render on every streaming delta, and local images over 10MB are no longer inlined into the webview DOM.
+- Updated dependencies [[`ec88d35`](https://github.com/MoonshotAI/kimi-code/commit/ec88d352e8f4dc5e8ffd1212f016138458f69893), [`b5efba7`](https://github.com/MoonshotAI/kimi-code/commit/b5efba7abcaf4041f81ec520097a61e6546e8c50), [`ce0e3ce`](https://github.com/MoonshotAI/kimi-code/commit/ce0e3ceb04223bdaad8e8931bad46eff561055b6), [`e458323`](https://github.com/MoonshotAI/kimi-code/commit/e45832398d0d9cad98dbad1cbf1e5b103a20aace)]:
+  - @moonshot-ai/kimi-code-sdk@0.14.0
+
+## 0.6.4
+
+### Changed
+
+- Picking a model's highest thinking effort now applies to the current session
+  only instead of becoming the global default: the top tier saves just the
+  on/off toggle, lower tiers persist as the default as before, and
+  re-confirming the current effort no longer rewrites the saved preference.
+  The model and thinking pickers also note that switching mid-conversation
+  invalidates the existing prompt cache.
+- Unified the YOLO and Auto permission mode naming and descriptions with the
+  CLI (`/afk` is now `/auto`), and approval requests that fall outside the
+  active permission mode (sensitive files, plan reviews, ask rules) are now
+  always shown to you instead of being auto-approved.
+
+## 0.6.3
+
+### Fixed
+
+- Editor mentions now work for files outside the working directory, and paths
+  containing spaces are quoted correctly.
+- Cancelling a running turn now reliably reaches the engine, and the UI no
+  longer reports a task as stopped when there is nothing to cancel.
+- Attaching to or resuming an existing session no longer overwrites its model
+  and thinking effort with the configured defaults; model or effort changes
+  picked in the composer are applied when the prompt is sent.
+
+## 0.6.2
+
+### Fixed
+
+- A core error arriving in the middle of a turn no longer corrupts the active
+  turn; the turn now ends cleanly with an error instead of leaving the chat in
+  a broken state.
+- Kimi sign-in and connection failures now include the underlying transport
+  cause (for example DNS or connection refused) instead of a generic error.
+- Closed several FetchURL SSRF bypasses and the DNS-rebinding window.
+- Tool calls interrupted mid-stream are now recorded and closed, so they no
+  longer corrupt the session history.
+
+## 0.6.1
+
+### Fixed
+
+- The **Sign in** action in the settings (gear) menu now actually starts the
+  Kimi login flow and shows an error toast when sign-in fails, instead of
+  silently doing nothing.
+
+## 0.6.0
+
+### Breaking
+
+- Raised the minimum supported editor version to VS Code 1.100.0.
+- Legacy Kimi Code OAuth credentials and MCP OAuth credentials are deliberately
+  not migrated. Sign in to Kimi Code again and re-authorize affected MCP
+  servers after upgrading.
+- Removed the `kimi.executablePath` and `kimi.environmentVariables` settings.
+  The old `kimi.environmentVariables.KIMI_SHARE_DIR` value is consulted only to
+  discover legacy data during migration; it is not applied to the new runtime.
+  The system-level `KIMI_CODE_HOME` environment variable remains supported.
+
+### Changed
+
+- Replaced the legacy Python/stdio runtime with the in-process Kimi Code Node
+  SDK. The extension no longer downloads or starts a separate Kimi executable.
+- The in-process engine is the same one that powers the Kimi Code CLI, so the
+  agent gains CLI-parity capabilities beyond the legacy runtime, including
+  parallel subagent swarms, background tasks, and long-running goal runs.
+- Added an opt-in legacy migration prompt on the first launch that detects data
+  from version 0.5.x. The migration copies or merges supported data into the
+  current Kimi Code home and does not delete the legacy source. If migration is
+  skipped or needs to be retried, run **Kimi Code: Migrate Legacy Data** from the
+  Command Palette.
+- When VS Code and the Kimi Code terminal app resolve to the same
+  `KIMI_CODE_HOME`, they use the same configuration and session storage. Running
+  the same session concurrently from multiple processes is not supported or
+  protected by cross-process locking.
+- The model picker groups models by provider when multiple providers are
+  configured, keeps provider identity when display names match, and recognizes
+  adaptive-thinking metadata. A configured custom default provider no longer
+  requires dismissing the Kimi account login screen on every launch.
+- The file changes panel and Undo actions use extension-maintained baselines.
+  Files changed through Kimi's Write and Edit operations are tracked on a
+  best-effort basis. File deletions performed inside Bash are not tracked by
+  this baseline and therefore cannot be restored by the panel's Undo action.
+
+### Fixed
+
+- The `kimi.yoloMode` setting now reaches the permission engine: enabling it
+  maps to the core `yolo` permission mode and takes effect when a session
+  attaches, including sessions that previously stored a disabled auto-approve
+  state.
+- Kept the chat header and input toolbar readable when the sidebar is narrow:
+  controls wrap and shrink instead of being clipped.
+
+### Distribution boundary
+
+Release packaging produces target-specific VSIX files for `darwin-x64`,
+`darwin-arm64`, `linux-x64`, `linux-arm64`, `win32-x64`, and `win32-arm64`.
+Archive and static verification for a target does not by itself prove that the
+extension has run successfully in that target's Extension Host; runtime test
+results must be recorded separately for each operating system and architecture.

apps/vscode/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

apps/vscode/README.md

@@ -0,0 +1,43 @@
+# Kimi Code
+
+AI coding assistant for VS Code, built for long-context workflows and complex coding tasks.
+
+## Features
+
+- **Works alongside you**: Kimi autonomously explores your codebase, reads and writes code, and runs terminal commands with your permission
+- **Thinking controls**: Toggle reasoning or choose a model-supported thinking effort
+- **Provider-aware models**: Distinguish and select same-named models across configured providers
+- **Native editor integration**: Review AI-proposed changes directly in VS Code's diff viewer
+- **MCP support**: Extend capabilities with Model Context Protocol servers
+- **Slash commands**: Quick actions like `/init` to analyze your project and `/compact` to manage context
+
+## Install
+
+Kimi Code requires VS Code 1.100.0 or later.
+
+1. Install from the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=moonshot-ai.kimi-code)
+2. Open a folder in VS Code
+3. Click the Kimi icon in the Activity Bar
+4. Sign in with a [kimi.com/code](https://www.kimi.com/code) subscription, or use a provider already configured in the shared `config.toml`
+
+The extension runs the Kimi Code Node SDK in the VS Code Extension Host. When
+the extension and the Kimi Code terminal app resolve to the same
+`KIMI_CODE_HOME`, they share `config.toml`, MCP configuration, login state, and
+sessions. The system-level `KIMI_CODE_HOME` environment variable is supported;
+there is no separate VS Code setting for it. Do not run the same session from
+both applications at the same time, because cross-process session locking is
+not guaranteed.
+
+After upgrading from version 0.5.x, the extension prompts before migrating any
+legacy data it finds. Migration copies or merges data into the current Kimi Code
+home and does not delete the legacy source. Legacy Kimi Code OAuth and MCP OAuth
+credentials are not copied, so those connections must be authorized again.
+See [the changelog](CHANGELOG.md) for the full compatibility notes.
+
+## Docs
+
+Official doc for Kimi Code can be found at [www.kimi.com/code/docs](https://www.kimi.com/code/docs/en/kimi-code-for-vscode/guides/getting-started.html)
+
+## License
+
+[Apache-2.0](LICENSE)

apps/vscode/docs/node-sdk-migration.md

@@ -0,0 +1,396 @@
+# VS Code Node SDK Migration Design
+
+Status: accepted and implemented for extension `0.6.0`
+
+Last updated: 2026-07-16
+
+## Context
+
+The `0.5.x` VS Code extension launched a separately installed Python Kimi CLI
+and communicated with it over stdio. That architecture duplicated runtime
+installation, configuration, authentication, and session behavior between the
+editor and Kimi Code.
+
+Version `0.6.0` moves the extension into this monorepo under `apps/vscode` and
+runs the stable TypeScript v1 engine through `@moonshot-ai/kimi-code-sdk` in the
+VS Code Extension Host. The migration preserves the existing extension ID,
+commands, Webview, and user-visible workflows. It does not redesign the UI or
+introduce unrelated TUI features.
+
+This document records the durable design decisions behind that migration. It
+is not a release checklist or a transcript of the implementation process.
+
+## Goals
+
+- Keep the extension ID `moonshot-ai.kimi-code` so `0.6.0` upgrades existing
+  installations.
+- Preserve the existing VS Code commands, shortcuts, Webview workflows, editor
+  integration, session management, MCP management, and file changes panel.
+- Replace the Python/stdio host with the in-process v1 Node SDK.
+- Share Kimi Code configuration, authentication, MCP configuration, and
+  sessions with the TUI when both processes resolve the same Kimi Code home.
+- Reuse the shared legacy migration package instead of maintaining a VS
+  Code-specific session translator.
+- Add only the smallest SDK/core APIs needed to preserve existing VS Code
+  behavior.
+- Package and test platform-targeted VSIX artifacts for macOS, Linux, and
+  Windows.
+
+The only intentional UI capability added during the migration is
+model-aware thinking effort selection. It is necessary to represent the model
+capabilities exposed by the v1 configuration.
+
+## Non-goals
+
+- Replacing the React Webview with VS Code native views or Chat Participants.
+- Migrating to the v2 engine.
+- Adding TUI-only features such as goals, cron, swarm, or BTW.
+- Keeping a Python CLI fallback or a custom executable setting.
+- Adding cross-process locks for concurrent access to one session.
+- Making the core wait for VS Code before file tools execute.
+- Parsing arbitrary shell commands to infer file changes.
+- Copying legacy OAuth or MCP OAuth credentials.
+- Publishing an extension as part of the build or package commands.
+
+## Runtime architecture
+
+```mermaid
+flowchart LR
+  UI["React Webview<br/>browser sandbox"]
+  Host["VS Code Extension Host<br/>Node process"]
+  SDK["@moonshot-ai/kimi-code-sdk<br/>KimiHarness and Session"]
+  Core["agent-core-v2"]
+  Home["Kimi Code home<br/>config, auth, MCP, sessions"]
+
+  UI <-->|"postMessage RPC and events"| Host
+  Host -->|"in-process calls"| SDK
+  SDK -->|"in-process calls"| Core
+  SDK <--> Home
+```
+
+There is no Python process, secondary Node process, or local HTTP server in the
+production extension path.
+
+The Webview remains because it is the existing product UI. It cannot import the
+Node SDK directly: the Webview is a browser sandbox and must not access the file
+system, credentials, process environment, or session storage. Those operations
+stay in the trusted Extension Host.
+
+### Extension identity
+
+The runtime constructs the SDK client with:
+
+- `productName: "kimi-code-vscode"`
+- `version` from `apps/vscode/package.json`
+- `uiMode: "vscode"`
+
+For `0.6.0`, the normal HTTP User-Agent product is therefore
+`kimi-code-vscode/0.6.0`. The version has one source of truth and is not copied
+into runtime code or packaging scripts.
+
+### Package boundaries
+
+- `apps/vscode` depends on `@moonshot-ai/kimi-code-sdk`.
+- `apps/vscode` must not depend directly on engine packages.
+- Core capabilities needed by released clients are exposed through the Node SDK
+  and tested at that public boundary.
+- The Webview communicates only through the typed bridge in
+  `apps/vscode/shared`.
+
+## Main components
+
+| Area | Primary implementation |
+|---|---|
+| Activation and VS Code commands | `apps/vscode/src/extension.ts` |
+| Webview lifecycle | `apps/vscode/src/KimiWebviewProvider.ts` |
+| Webview RPC boundary | `apps/vscode/src/bridge-handler.ts`, `apps/vscode/src/handlers` |
+| SDK host | `apps/vscode/src/runtime/kimi-runtime.ts` |
+| Session lifecycle and event routing | `apps/vscode/src/runtime/session-runtime.ts` |
+| SDK-to-Webview event conversion | `apps/vscode/src/runtime/event-adapter.ts` |
+| Session replay | `apps/vscode/src/runtime/replay-adapter.ts` |
+| File changes and baselines | `apps/vscode/src/managers` |
+| Legacy migration coordination | `apps/vscode/src/migration` |
+| React UI | `apps/vscode/webview-ui` |
+| Packaging and smoke tests | `apps/vscode/scripts`, `.github/workflows/ci.yml` |
+
+## Data ownership
+
+### Shared Kimi Code home
+
+The SDK resolves the home directory using the normal Kimi Code rules:
+
+1. system-level `KIMI_CODE_HOME`, when set;
+2. otherwise `~/.kimi-code`.
+
+The extension does not add a separate `kimi.homeDir` setting and does not pass
+its own default home to the SDK. VS Code and the TUI share the following data
+only when they resolve the same home:
+
+- `config.toml`
+- `mcp.json`
+- authentication state
+- `sessions/`
+- `session_index.jsonl`
+- other SDK-owned Kimi Code data
+
+Remote SSH, WSL, and Dev Container installations use the environment and home
+of the remote Extension Host. They do not automatically share the local
+machine's Kimi Code home.
+
+### VS Code-owned state
+
+VS Code settings and Extension Host storage own editor-specific behavior:
+
+- autosave and keyboard behavior;
+- thinking display preferences;
+- editor context injection mode;
+- Webview state;
+- file change baselines and legacy baseline acceptance markers.
+
+These values are not written into the shared core configuration unless they
+are already a shared product setting, such as the selected model or thinking
+effort.
+
+### Environment variables
+
+The old `kimi.environmentVariables` setting existed to populate the environment
+of the Python child process. It was removed with that process model.
+
+- Provider-specific environment variables remain in `config.toml`.
+- MCP server environment variables remain in `mcp.json`.
+- proxy and other process-level variables are inherited from the Extension
+  Host environment.
+- a legacy `KIMI_SHARE_DIR` in the removed setting is consulted only as an
+  additional migration source.
+- other values from the removed global environment map are not migrated.
+
+## Webview bridge
+
+The bridge keeps the request/response and event-broadcast shape of the previous
+extension so the React UI did not require a product redesign. The Extension
+Host validates method names, payloads, workspace containment, and file paths.
+The Webview uses a nonce-based content security policy and does not receive
+tokens, complete configuration files, or unnecessary absolute paths.
+
+The event adapter maps v1 SDK events such as `turn.started`,
+`assistant.delta`, `tool.call.started`, approvals, questions, compaction, and
+errors into the UI state expected by the migrated Webview. Session replay uses
+the SDK/core replay surface rather than parsing current core storage directly
+from the UI.
+
+Provider errors may arrive after a failed turn-end event. Session subscriptions
+therefore remain alive long enough to deliver the final error instead of being
+cancelled immediately when a turn ends.
+
+## Sessions
+
+The Node SDK exposes the session operations required by the existing editor UI:
+
+- create, resume, list, rename, and export;
+- permanent delete;
+- fork from a selected historical turn;
+- replayed context and records needed to restore the UI;
+- approval, question, stop, steer, plan mode, model, and thinking controls.
+
+Permanent delete keeps the old VS Code meaning; it is not silently mapped to
+archive. A running target session is stopped and closed before its persisted
+data and index references are removed.
+
+Historical fork keeps the selected turn and its preceding context, then removes
+later conversation state. Baselines are materialized into the fork so Keep or
+Undo actions in one session cannot affect the other.
+
+The TUI and VS Code may resume sessions created by each other. They must not run
+the same session concurrently because the v1 store has no cross-process write
+lock.
+
+## Provider-aware models and thinking
+
+Model aliases retain their provider identity. The picker groups models by
+provider when multiple providers are configured, so same-named models remain
+distinct. Media fallback prefers a compatible model from the current provider
+before considering another provider.
+
+Thinking controls follow each model's declared capabilities:
+
+- models with `support_efforts` expose those effort values;
+- boolean-thinking models expose on/off;
+- `always_thinking` models do not expose an invalid off state;
+- adaptive-thinking capability is preserved when applying the selection.
+
+Changing the model or thinking effort updates the active session and the shared
+default configuration used by new TUI and VS Code sessions.
+
+## MCP
+
+Home-level MCP operations are exposed by the SDK harness rather than by direct
+file access from the extension. They cover configuration CRUD, OAuth/reset,
+connection testing, and user-global `mcp.json` entries. Session-level status and
+reconnect behavior remain on the Session surface.
+
+The extension supports stdio and HTTP servers, including their environment,
+headers, and authorization flows. Legacy MCP OAuth credentials are not copied
+and may require authorization after upgrade.
+
+## Legacy migration
+
+Migration is opt-in and uses `@moonshot-ai/migration-legacy` for detection and
+translation. The extension coordinates prompts and reports but does not
+maintain another config/session translator.
+
+### Sources and target
+
+- default source: `~/.kimi`;
+- optional additional source: a valid legacy `KIMI_SHARE_DIR` from the removed
+  VS Code setting;
+- target: the SDK-resolved Kimi Code home.
+
+Migration covers the shared config, MCP config, user history, supported skills,
+and sessions. Existing target data wins according to the shared migration
+package's conflict rules. Migration is repeatable and does not delete the
+legacy source.
+
+On first launch, the extension detects work without mutating either home and
+offers **Migrate now** or **Later**. The command
+`Kimi Code: Migrate Legacy Data` remains available for manual runs and retries.
+
+The shared marker `.migrated-to-kimi-code` can contain multiple target homes.
+This prevents duplicate migration when the TUI migrated the same source first,
+while still allowing a different `KIMI_CODE_HOME` to be migrated later.
+
+Migrated sessions keep source metadata in `state.json.custom`, including the
+legacy source path and session identity. This metadata also supports legacy
+baseline fallback.
+
+OAuth and MCP OAuth credentials are intentionally not copied. Refresh tokens
+may rotate, so copying them can invalidate one installation or create ambiguous
+ownership. The upgrade flow and release notes must tell users to authorize
+again when needed.
+
+## File changes and baselines
+
+The baseline feature exists only to support the VS Code File Changes panel,
+diff view, Keep Changes, and Undo. It is not core session state and is not a TUI
+feature.
+
+### New sessions
+
+Baselines are stored under the extension's `globalStorage`, namespaced by the
+resolved Kimi Code home and session ID. The home namespace prevents sessions
+with the same ID in different homes from sharing baseline state.
+
+The session runtime observes `tool.call.started` for the explicit `Write` and
+`Edit` tools. It captures the first pre-change content for each file and
+refreshes the File Changes panel after tool results. A missing original file is
+represented as a newly created file.
+
+- **Keep** removes the effective baseline entry from the panel.
+- **Undo** restores the original content or deletes a file that did not exist.
+- keeping a file and editing it again starts a new baseline period.
+- all paths are resolved against the session work directory and checked for
+  traversal and symlink escape.
+
+This is intentionally best-effort. The core does not pause tool execution for a
+VS Code callback, and arbitrary Bash file mutations are not tracked.
+
+### Migrated sessions
+
+Legacy baselines are not copied in bulk. A migrated session uses its recorded
+legacy source path and reads `<legacy-session>/baseline` as a read-only
+fallback.
+
+The lookup order is:
+
+1. extension-owned baseline;
+2. an extension-owned marker saying a legacy path was accepted;
+3. the legacy baseline.
+
+Keeping a legacy change writes the acceptance marker instead of deleting old
+data. Forking materializes the currently effective baseline into the target
+session's extension storage. If the user deletes the legacy home, the migrated
+conversation remains usable but legacy diff/Undo information is no longer
+available.
+
+## Packaging and CI
+
+The Webview and Extension Host are separate build products:
+
+- Vite builds browser assets for the Webview.
+- the Extension Host bundle includes the Node SDK and v1 runtime; only VS Code
+  host modules remain external.
+
+The production VSIX excludes tests, fixtures, source maps, local profiles,
+sessions, caches, logs, tokens, and the old Python/stdio runtime. Package audit
+checks the manifest, assets, unresolved runtime imports, and sensitive files
+after test state has been created.
+
+The extension produces six target artifacts:
+
+- `darwin-x64`, `darwin-arm64`
+- `linux-x64`, `linux-arm64`
+- `win32-x64`, `win32-arm64`
+
+The CI matrix builds and audits the target VSIX files. Installed-extension smoke
+tests run on Linux, macOS, and Windows x64 runners. Linux checks the declared
+minimum VS Code version and stable; macOS and Windows check the declared
+minimum. Architecture targets without a matching runner remain package/audit
+evidence rather than runtime E2E evidence.
+
+Packaging never publishes. Marketplace and Open VSX publication require a
+separate authorized release action.
+
+## Validation snapshot
+
+The migration was validated with:
+
+- package-local tests for the extension, Node SDK, v1 core, and legacy
+  migration;
+- real temporary homes and workspaces for migration and baseline behavior;
+- provider-aware model, identity, MCP, error, session replay, delete, and fork
+  contract tests;
+- production Extension Host and Webview builds;
+- six target VSIX package audits;
+- an upgrade from the released `0.5.10` extension to local `0.6.0` in an
+  isolated profile;
+- installed VSIX Extension Host smoke on Linux, macOS, and Windows x64 CI;
+- local installed `darwin-arm64` VSIX smoke on VS Code `1.100.0`;
+- repository lint, typecheck, tests, Nix build, workspace sync, changeset
+  status, and whitespace checks.
+
+All automated CI checks for the migration branch were green when this document
+was finalized.
+
+## Known limitations and release gates
+
+- Remote SSH, WSL, and Dev Container behavior follows `extensionKind:
+  ["workspace"]` and remote home resolution, but still needs representative
+  release-candidate smoke in a real remote environment.
+- Cursor installation, activation, Webview, and basic chat require a usable
+  Cursor environment; VS Code smoke is not a substitute.
+- A release candidate should receive one real-account auth/provider smoke in a
+  workspace containing no sensitive files.
+- Migrated nested subagents preserve the parent call/summary but cannot recreate
+  every child prompt, step, tool, and approval detail from the legacy format.
+- Legacy OAuth and MCP OAuth require reauthorization.
+- Bash-based deletes and arbitrary external file edits are outside baseline
+  tracking.
+- Concurrent writes to one session from multiple processes are unsupported.
+- The package script uses a pinned `@vscode/vsce` programmatic `pack()` entry;
+  upgrading that package requires revalidating the packaging contract.
+
+## Maintenance invariants
+
+Future changes must preserve these boundaries unless a new design explicitly
+replaces them:
+
+1. The Webview never imports the Node SDK or gains direct Node/file/auth access.
+2. `apps/vscode` never imports engine packages directly.
+3. Shared config and sessions live in the SDK-resolved Kimi Code home; editor
+   preferences and baselines remain VS Code-owned.
+4. Legacy migration translation stays in `packages/migration-legacy`.
+5. Session storage is accessed through SDK/core APIs, not parsed or mutated by
+   the Webview.
+6. Baselines remain an extension compatibility layer and do not make core tool
+   execution wait for VS Code.
+7. Package-only evidence is not reported as runtime E2E evidence.
+8. Build/package commands do not publish artifacts.

apps/vscode/package.json

@@ -0,0 +1,321 @@
+{
+  "name": "kimi-code",
+  "publisher": "moonshot-ai",
+  "displayName": "Kimi Code",
+  "description": "Official Kimi Code plugin for VS Code",
+  "version": "0.7.5",
+  "private": true,
+  "license": "Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MoonshotAI/kimi-code.git",
+    "directory": "apps/vscode"
+  },
+  "engines": {
+    "vscode": "^1.100.0"
+  },
+  "extensionKind": [
+    "workspace"
+  ],
+  "capabilities": {
+    "untrustedWorkspaces": {
+      "supported": false
+    },
+    "virtualWorkspaces": false
+  },
+  "categories": [
+    "AI",
+    "Chat",
+    "Programming Languages"
+  ],
+  "keywords": [
+    "ai",
+    "assistant",
+    "code",
+    "chat",
+    "agent",
+    "mcp",
+    "skills",
+    "json",
+    "autocomplete",
+    "moonshot",
+    "kimi",
+    "moonshot-ai"
+  ],
+  "pricing": "Free",
+  "activationEvents": [],
+  "main": "./dist/extension.js",
+  "icon": "resources/kimi-icon-storefront.png",
+  "contributes": {
+    "configuration": {
+      "title": "Kimi Code",
+      "properties": {
+        "kimi.yoloMode": {
+          "type": "boolean",
+          "default": false,
+          "description": "Auto-approve regular tool calls; the agent may still ask questions"
+        },
+        "kimi.autosave": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically save files before Kimi reads or writes them"
+        },
+        "kimi.enableNewConversationShortcut": {
+          "type": "boolean",
+          "default": false,
+          "description": "Use Cmd/Ctrl+N to start a new conversation when Kimi is focused"
+        },
+        "kimi.useCtrlEnterToSend": {
+          "type": "boolean",
+          "default": false,
+          "description": "Use Ctrl/Cmd+Enter to send prompts instead of Enter"
+        },
+        "kimi.showThinkingContent": {
+          "type": "boolean",
+          "default": true,
+          "description": "Show thinking/reasoning content in the chat UI"
+        },
+        "kimi.showThinkingExpanded": {
+          "type": "boolean",
+          "default": false,
+          "description": "Auto-expand thinking/reasoning sections when shown (requires 'Show Thinking Content' to be enabled)"
+        },
+        "kimi.editorContext": {
+          "type": "string",
+          "default": "never",
+          "enum": [
+            "never",
+            "onConversationStart",
+            "onFileChange"
+          ],
+          "enumDescriptions": [
+            "Never share editor context",
+            "Share once when conversation starts",
+            "Share when active file changes"
+          ],
+          "description": "Control when to share the active editor's file and cursor position with Kimi"
+        }
+      }
+    },
+    "commands": [
+      {
+        "command": "kimi.clearAllState",
+        "title": "Kimi Code: [DEBUG] Clear All State"
+      },
+      {
+        "command": "kimi.openInTab",
+        "title": "Kimi Code: Open in New Tab",
+        "icon": "$(link-external)"
+      },
+      {
+        "command": "kimi.openInSideBar",
+        "title": "Kimi Code: Open in Side Panel",
+        "icon": "$(layout-sidebar-left)"
+      },
+      {
+        "command": "kimi.focusInput",
+        "title": "Kimi Code: Focus Input",
+        "icon": "$(edit)"
+      },
+      {
+        "command": "kimi.insertMention",
+        "title": "Kimi Code: Insert Current File",
+        "icon": "$(mention)"
+      },
+      {
+        "command": "kimi.newConversation",
+        "title": "Kimi Code: New Conversation",
+        "icon": "$(add)"
+      },
+      {
+        "command": "kimi.showLogs",
+        "title": "Kimi Code: Show Logs",
+        "icon": "$(output)"
+      },
+      {
+        "command": "kimi.resetKimi",
+        "title": "Kimi Code: Reset Kimi (in case of any issues/no response)",
+        "icon": "$(refresh)"
+      },
+      {
+        "command": "kimi.logout",
+        "title": "Kimi Code: Logout",
+        "icon": "$(sign-out)"
+      },
+      {
+        "command": "kimi.migrateLegacyData",
+        "title": "Kimi Code: Migrate Legacy Data"
+      }
+    ],
+    "keybindings": [
+      {
+        "command": "kimi.focusInput",
+        "key": "ctrl+shift+k",
+        "mac": "cmd+shift+k"
+      },
+      {
+        "command": "kimi.insertMention",
+        "key": "alt+k",
+        "mac": "alt+k",
+        "when": "editorTextFocus"
+      }
+    ],
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "kimi-sidebar",
+          "title": "Kimi Code",
+          "icon": "resources/kimi-icon.svg"
+        }
+      ]
+    },
+    "views": {
+      "kimi-sidebar": [
+        {
+          "type": "webview",
+          "id": "kimi.webview",
+          "name": "Kimi Code"
+        }
+      ]
+    },
+    "menus": {
+      "view/title": [
+        {
+          "command": "kimi.openInTab",
+          "when": "view == kimi.webview",
+          "group": "navigation"
+        },
+        {
+          "command": "kimi.newConversation",
+          "when": "view == kimi.webview",
+          "group": "navigation"
+        }
+      ],
+      "commandPalette": [
+        {
+          "command": "kimi.clearAllState",
+          "when": "isDevelopment"
+        },
+        {
+          "command": "kimi.openInTab",
+          "when": "true"
+        },
+        {
+          "command": "kimi.openInSideBar",
+          "when": "true"
+        },
+        {
+          "command": "kimi.focusInput",
+          "when": "true"
+        },
+        {
+          "command": "kimi.insertMention",
+          "when": "true"
+        },
+        {
+          "command": "kimi.newConversation",
+          "when": "true"
+        },
+        {
+          "command": "kimi.showLogs",
+          "when": "true"
+        },
+        {
+          "command": "kimi.resetKimi",
+          "when": "true"
+        },
+        {
+          "command": "kimi.logout",
+          "when": "kimi.isLoggedIn"
+        },
+        {
+          "command": "kimi.migrateLegacyData",
+          "when": "true"
+        }
+      ],
+      "editor/context": [
+        {
+          "command": "kimi.insertMention",
+          "group": "moonshot-ai",
+          "when": "editorTextFocus"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "vscode:prepublish": "pnpm run build",
+    "dev": "pnpm run dev:prepare && pnpm run \"/^dev:(extension|webview)$/\"",
+    "dev:prepare": "node scripts/prepare-dev.mjs",
+    "dev:extension": "node scripts/watch-extension.mjs",
+    "dev:webview": "vite build --config webview-ui/vite.config.ts --watch --sourcemap",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p webview-ui/tsconfig.json --noEmit",
+    "build": "pnpm run build:extension && pnpm run build:webview",
+    "build:webview": "vite build --config webview-ui/vite.config.ts",
+    "build:extension": "tsdown --config tsdown.config.ts",
+    "test": "vitest run --config vitest.config.ts",
+    "test:extension-host": "node scripts/extension-host-smoke.mjs",
+    "package:platform": "node scripts/vsix-package.mjs",
+    "package:verify": "node scripts/vsix-verify.mjs",
+    "publish:vsix": "node scripts/vsix-publish.mjs",
+    "publish:ovsx": "node scripts/ovsx-publish.mjs"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.1.4",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.3",
+    "@testing-library/user-event": "^14.6.6",
+    "@types/diff": "^8.0.0",
+    "@types/katex": "^0.16.8",
+    "@types/node": "^22.15.3",
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.2",
+    "@types/react-scroll-to-bottom": "^4.2.5",
+    "@types/react-syntax-highlighter": "^15.5.13",
+    "@types/vscode": "1.100.0",
+    "@vitejs/plugin-react": "^4.4.1",
+    "@vscode/test-cli": "^0.0.11",
+    "@vscode/test-electron": "^2.5.2",
+    "@vscode/vsce": "3.9.2",
+    "acorn": "8.17.0",
+    "jsdom": "^30.0.1",
+    "ovsx": "1.0.2",
+    "tailwindcss": "^4.1.4",
+    "vite": "^6.3.3",
+    "vite-plugin-css-injected-by-js": "^3.5.2",
+    "vitest": "4.1.4"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.0.0",
+    "@fontsource-variable/inter": "5.2.8",
+    "@moonshot-ai/kimi-code-oauth": "workspace:^",
+    "@moonshot-ai/kimi-code-sdk": "workspace:^",
+    "@moonshot-ai/migration-legacy": "workspace:^",
+    "@radix-ui/react-accordion": "^1.2.12",
+    "@tabler/icons-react": "^3.36.0",
+    "@tanstack/react-query": "^5.74.4",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "diff": "^8.0.2",
+    "fuse.js": "^7.1.0",
+    "heic-to": "^1.0.2",
+    "immer": "^11.1.0",
+    "katex": "^0.17.0",
+    "next-themes": "^0.4.6",
+    "radix-ui": "^1.4.3",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-markdown": "^10.1.0",
+    "react-scroll-to-bottom": "^4.2.0",
+    "react-syntax-highlighter": "^16.1.0",
+    "rehype-katex": "^7.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
+    "shadcn": "^3.6.2",
+    "sonner": "^2.0.7",
+    "tailwind-merge": "^3.4.0",
+    "tw-animate-css": "^1.4.0",
+    "zustand": "^5"
+  }
+}

apps/vscode/scripts/extension-host-smoke.d.mts

@@ -0,0 +1,16 @@
+export interface ExtensionHostSmokeOptions {
+  version?: string;
+  vsixPath?: string;
+  cachePath?: string;
+}
+
+export interface ExtensionHostSmokeResult {
+  version: string;
+  vscodeVersion: string;
+  vsixPath: string;
+  cachePath: string;
+}
+
+export function runExtensionHostSmoke(
+  options?: ExtensionHostSmokeOptions,
+): Promise<ExtensionHostSmokeResult>;

apps/vscode/scripts/local-cli.mjs

@@ -0,0 +1,47 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+export function resolveLocalCli(packageName, executableName) {
+  let packageJsonPath;
+  try {
+    packageJsonPath = require.resolve(`${packageName}/package.json`);
+  } catch (error) {
+    throw new Error(
+      `Local CLI dependency ${packageName} is not installed. Run pnpm install; runtime CLI downloads are disabled.`,
+      { cause: error },
+    );
+  }
+
+  const manifest = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  const relativeBin = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.[executableName];
+  if (typeof relativeBin !== 'string') {
+    throw new Error(`${packageName} does not declare the expected "${executableName}" binary.`);
+  }
+  return resolve(dirname(packageJsonPath), relativeBin);
+}
+
+export function runLocalCli(packageName, executableName, args, options = {}) {
+  const cliPath = resolveLocalCli(packageName, executableName);
+  const result = spawnSync(process.execPath, [cliPath, ...args], {
+    cwd: options.cwd,
+    env: options.env ?? process.env,
+    encoding: options.encoding,
+    stdio: options.stdio ?? 'inherit',
+  });
+  if (result.error !== undefined) {
+    throw new Error(`Unable to start local ${executableName}: ${result.error.message}`, {
+      cause: result.error,
+    });
+  }
+  if (result.status !== 0) {
+    const output = [result.stdout, result.stderr].filter(Boolean).join('');
+    throw new Error(
+      `Local ${executableName} exited with code ${result.status ?? 'unknown'}${output ? `:\n${output}` : ''}`,
+    );
+  }
+  return result;
+}

apps/vscode/scripts/ovsx-publish.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+
+import { runLocalCli } from './local-cli.mjs';
+import { parsePublishArguments, publishUsage } from './publish-args.mjs';
+import { extensionRoot, isMainModule } from './vsix-targets.mjs';
+import { verifyVsix } from './vsix-verify.mjs';
+
+async function main() {
+  const options = parsePublishArguments(process.argv.slice(2));
+  if (options.help) {
+    console.log(publishUsage('Open VSX'));
+    return;
+  }
+  if (!process.env.OVSX_PAT) throw new Error('OVSX_PAT is required to publish.');
+
+  await verifyInputs(options);
+  for (const file of options.files) {
+    console.log(`Publishing verified package ${file}...`);
+    try {
+      runLocalCli('ovsx', 'ovsx', ['publish', file], {
+        cwd: extensionRoot,
+        encoding: 'utf8',
+        stdio: 'pipe',
+      });
+    } catch (error) {
+      if (/already exists/i.test(error instanceof Error ? error.message : String(error))) {
+        console.log(`Package already exists: ${file}`);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+async function verifyInputs(options) {
+  for (let index = 0; index < options.targets.length; index += 1) {
+    const file = options.files[index];
+    if (!existsSync(file)) {
+      throw new Error(`Missing VSIX ${file}. Run pnpm run package:platform first.`);
+    }
+    await verifyVsix(file, options.targets[index], { sourceRoot: extensionRoot });
+  }
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`Open VSX publish failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  });
+}

apps/vscode/scripts/prepare-dev.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, parse, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { isMainModule } from './vsix-targets.mjs';
+
+const SAFE_DIRECTORY_NAME = 'vscode-extension-dev';
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const monorepoRoot = resolve(scriptDir, '../../..');
+const defaultBaseDir = join(monorepoRoot, '.tmp', SAFE_DIRECTORY_NAME);
+
+export async function prepareDevEnvironment(baseDir = defaultBaseDir) {
+  const root = resolve(baseDir);
+  assertSafeRoot(root);
+  await rm(root, { recursive: true, force: true });
+
+  const paths = {
+    root,
+    userData: join(root, 'user-data'),
+    extensions: join(root, 'extensions'),
+    kimiHome: join(root, 'kimi-home'),
+    workspace: join(root, 'workspace'),
+  };
+  await Promise.all(
+    Object.values(paths)
+      .filter((path) => path !== root)
+      .map((path) => mkdir(path, { recursive: true })),
+  );
+  await writeFile(
+    join(paths.workspace, 'README.md'),
+    '# Isolated Kimi Code extension development workspace\n',
+  );
+  return paths;
+}
+
+function assertSafeRoot(root) {
+  const parsed = parse(root);
+  if (root === parsed.root || basename(root) !== SAFE_DIRECTORY_NAME) {
+    throw new Error(
+      `Refusing to reset unsafe development directory "${root}"; it must end in ${SAFE_DIRECTORY_NAME}.`,
+    );
+  }
+}
+
+function parseArguments(argv) {
+  let baseDir = defaultBaseDir;
+  let help = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--') {
+      continue;
+    } else if (argument === '--help' || argument === '-h') {
+      help = true;
+    } else if (argument === '--base-dir') {
+      const value = argv[++index];
+      if (value === undefined || value.startsWith('-')) throw new Error('--base-dir requires a value.');
+      baseDir = value;
+    } else {
+      throw new Error(`Unknown option: ${argument}`);
+    }
+  }
+  return { baseDir, help };
+}
+
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.help) {
+    console.log('Usage: node scripts/prepare-dev.mjs [--base-dir <.../vscode-extension-dev>]');
+    return;
+  }
+  const paths = await prepareDevEnvironment(options.baseDir);
+  console.log(`Prepared isolated VS Code profile: ${paths.root}`);
+  console.log(`KIMI_CODE_HOME=${paths.kimiHome}`);
+  console.log(`Workspace=${paths.workspace}`);
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`Development environment setup failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  });
+}

apps/vscode/scripts/publish-args.mjs

@@ -0,0 +1,54 @@
+import { join, resolve } from 'node:path';
+
+import {
+  defaultVsixOutputDir,
+  normalizeVsixTargets,
+  vsixFileName,
+} from './vsix-targets.mjs';
+
+export function parsePublishArguments(argv) {
+  const targets = [];
+  let outputDir = defaultVsixOutputDir;
+  let help = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--') {
+      continue;
+    } else if (argument === '--help' || argument === '-h') {
+      help = true;
+    } else if (argument === '--out-dir') {
+      outputDir = requireOptionValue(argv, ++index, '--out-dir');
+    } else if (argument === '--target') {
+      targets.push(requireOptionValue(argv, ++index, '--target'));
+    } else if (argument.startsWith('-')) {
+      throw new Error(`Unknown option: ${argument}`);
+    } else {
+      targets.push(argument);
+    }
+  }
+
+  const normalizedTargets = normalizeVsixTargets(targets);
+  const resolvedOutputDir = resolve(outputDir);
+  return {
+    help,
+    targets: normalizedTargets,
+    outputDir: resolvedOutputDir,
+    files: normalizedTargets.map((target) => join(resolvedOutputDir, vsixFileName(target))),
+  };
+}
+
+function requireOptionValue(argv, index, option) {
+  const value = argv[index];
+  if (value !== undefined && !value.startsWith('-')) return value;
+  throw new Error(`${option} requires a value.`);
+}
+
+export function publishUsage(marketplace) {
+  return [
+    `Usage: node scripts/${marketplace === 'Open VSX' ? 'ovsx' : 'vsix'}-publish.mjs [targets...] [--out-dir <directory>]`,
+    '',
+    `Publishes already-built, re-verified VSIX files to ${marketplace}.`,
+    'This command never builds or downloads a CLI.',
+  ].join('\n');
+}

apps/vscode/scripts/vsix-package.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { mkdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+
+import { runLocalCli } from './local-cli.mjs';
+import {
+  defaultVsixOutputDir,
+  extensionRoot,
+  isMainModule,
+  normalizeVsixTargets,
+  vsixFileName,
+} from './vsix-targets.mjs';
+import { verifyVsix } from './vsix-verify.mjs';
+
+const require = createRequire(import.meta.url);
+
+function parseArguments(argv) {
+  const targets = [];
+  let outputDir = defaultVsixOutputDir;
+  let dryRun = false;
+  let help = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--') {
+      continue;
+    } else if (argument === '--help' || argument === '-h') {
+      help = true;
+    } else if (argument === '--dry-run') {
+      dryRun = true;
+    } else if (argument === '--out-dir') {
+      outputDir = requireOptionValue(argv, ++index, '--out-dir');
+    } else if (argument === '--target') {
+      targets.push(requireOptionValue(argv, ++index, '--target'));
+    } else if (argument.startsWith('-')) {
+      throw new Error(`Unknown option: ${argument}`);
+    } else {
+      targets.push(argument);
+    }
+  }
+
+  return {
+    targets: normalizeVsixTargets(targets),
+    outputDir: resolve(outputDir),
+    dryRun,
+    help,
+  };
+}
+
+function requireOptionValue(argv, index, option) {
+  const value = argv[index];
+  if (value !== undefined && !value.startsWith('-')) return value;
+  throw new Error(`${option} requires a value.`);
+}
+
+function usage() {
+  return [
+    'Usage: node scripts/vsix-package.mjs [targets...] [--out-dir <directory>]',
+    '       node scripts/vsix-package.mjs --target win32-x64 --dry-run',
+    '',
+    'With no targets, all six supported VSIX targets are built and audited.',
+    'This command never publishes an extension.',
+  ].join('\n');
+}
+
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.help) {
+    console.log(usage());
+    return;
+  }
+
+  await mkdir(options.outputDir, { recursive: true });
+  console.log(`VSIX targets: ${options.targets.join(', ')}`);
+  console.log(`Output directory: ${options.outputDir}`);
+
+  if (!options.dryRun) {
+    console.log('Building the extension once before packaging all targets...');
+    buildExtension();
+  }
+
+  const packVsix = options.dryRun ? undefined : loadVscePack();
+
+  for (const target of options.targets) {
+    const outputPath = join(options.outputDir, vsixFileName(target));
+    if (options.dryRun) {
+      console.log(`Would package ${target} -> ${outputPath}`);
+      continue;
+    }
+
+    console.log(`\nPackaging ${target} with the workspace @vscode/vsce...`);
+    await packVsix({
+      cwd: extensionRoot,
+      dependencies: false,
+      packagePath: outputPath,
+      target,
+    });
+    const result = await verifyVsix(outputPath, target, { sourceRoot: extensionRoot });
+    console.log(
+      `Verified ${target}: ${result.files} files, ${result.bytes} unpacked bytes; package/static checks passed.`,
+    );
+  }
+
+  if (!options.dryRun) {
+    console.log(
+      '\nVSIX packaging complete. These are package-only results until each target runs in its matching extension host.',
+    );
+  }
+}
+
+function buildExtension() {
+  runLocalCli('tsdown', 'tsdown', ['--config', 'tsdown.config.ts'], { cwd: extensionRoot });
+  runLocalCli('vite', 'vite', ['build', '--config', 'webview-ui/vite.config.ts'], {
+    cwd: extensionRoot,
+  });
+}
+
+function loadVscePack() {
+  try {
+    // VSCE's public API always runs vscode:prepublish. We build once above and pin VSCE,
+    // so use its package phase directly instead of rebuilding for every target.
+    const module = require('@vscode/vsce/out/package.js');
+    if (typeof module.pack !== 'function') {
+      throw new TypeError('the installed package does not expose pack()');
+    }
+    return module.pack;
+  } catch (error) {
+    throw new Error(
+      'The workspace @vscode/vsce package API is unavailable. Run pnpm install; runtime CLI downloads are disabled.',
+      { cause: error },
+    );
+  }
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`VSIX packaging failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  });
+}

apps/vscode/scripts/vsix-publish.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+
+import { runLocalCli } from './local-cli.mjs';
+import { parsePublishArguments, publishUsage } from './publish-args.mjs';
+import { extensionRoot, isMainModule } from './vsix-targets.mjs';
+import { verifyVsix } from './vsix-verify.mjs';
+
+async function main() {
+  const options = parsePublishArguments(process.argv.slice(2));
+  if (options.help) {
+    console.log(publishUsage('Visual Studio Marketplace'));
+    return;
+  }
+  if (!process.env.VSCE_PAT) throw new Error('VSCE_PAT is required to publish.');
+
+  await verifyInputs(options);
+  for (const file of options.files) {
+    console.log(`Publishing verified package ${file}...`);
+    runLocalCli(
+      '@vscode/vsce',
+      'vsce',
+      ['publish', '--packagePath', file, '--skip-duplicate'],
+      { cwd: extensionRoot },
+    );
+  }
+}
+
+async function verifyInputs(options) {
+  for (let index = 0; index < options.targets.length; index += 1) {
+    const file = options.files[index];
+    if (!existsSync(file)) {
+      throw new Error(`Missing VSIX ${file}. Run pnpm run package:platform first.`);
+    }
+    await verifyVsix(file, options.targets[index], { sourceRoot: extensionRoot });
+  }
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`Marketplace publish failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  });
+}

apps/vscode/scripts/vsix-targets.mjs

@@ -0,0 +1,45 @@
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+export const VSIX_TARGETS = Object.freeze([
+  'darwin-x64',
+  'darwin-arm64',
+  'linux-x64',
+  'linux-arm64',
+  'win32-x64',
+  'win32-arm64',
+]);
+
+export const extensionRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+export const defaultVsixOutputDir = join(extensionRoot, 'artifacts', 'vsix');
+
+export function vsixFileName(target) {
+  assertVsixTarget(target);
+  return `kimi-code-${target}.vsix`;
+}
+
+export function normalizeVsixTargets(values) {
+  const requested = values.length === 0 || values.includes('all') ? VSIX_TARGETS : values;
+  if (values.includes('all') && values.length > 1) {
+    throw new Error('Target "all" cannot be combined with an explicit VSIX target.');
+  }
+
+  const targets = [];
+  for (const target of requested) {
+    assertVsixTarget(target);
+    if (!targets.includes(target)) targets.push(target);
+  }
+  return targets;
+}
+
+export function assertVsixTarget(target) {
+  if (VSIX_TARGETS.includes(target)) return;
+  throw new Error(
+    `Unknown VSIX target "${target}". Expected one of: ${VSIX_TARGETS.join(', ')}`,
+  );
+}
+
+export function isMainModule(metaUrl) {
+  const argvPath = process.argv[1];
+  return argvPath !== undefined && pathToFileURL(resolve(argvPath)).href === metaUrl;
+}

apps/vscode/scripts/vsix-verify.mjs

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+import { builtinModules } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import {
+  mkdtemp,
+  mkdir,
+  readFile,
+  readdir,
+  rm,
+  stat,
+  writeFile,
+} from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, extname, join, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isDeepStrictEqual } from 'node:util';
+import { parse } from 'acorn';
+
+import { extractZip } from './zip.mjs';
+import {
+  defaultVsixOutputDir,
+  extensionRoot,
+  isMainModule,
+  normalizeVsixTargets,
+  vsixFileName,
+} from './vsix-targets.mjs';
+
+const REQUIRED_WEBVIEW_FILES = [
+  'dist/webview.js',
+  'dist/kimi-banner-dark.svg',
+  'dist/kimi-banner-light.svg',
+  'dist/kimi-logo.png',
+];
+const FORBIDDEN_PATH_SEGMENTS = new Set([
+  '.kimi',
+  '.kimi-code',
+  '.vscode',
+  '__tests__',
+  'cache',
+  'caches',
+  'credentials',
+  'logs',
+  'node_modules',
+  'profile',
+  'profiles',
+  'runtime',
+  'scripts',
+  'session',
+  'sessions',
+  'src',
+  'state',
+  'states',
+  'test',
+  'tests',
+  'tokens',
+  'webview-ui',
+]);
+const FORBIDDEN_EXTENSIONS = new Set(['.jsonl', '.log', '.map', '.py', '.pyc', '.ts', '.tsx']);
+const TEXT_EXTENSIONS = new Set([
+  '.cjs',
+  '.css',
+  '.html',
+  '.js',
+  '.json',
+  '.md',
+  '.mjs',
+  '.svg',
+  '.txt',
+  '.xml',
+]);
+const BUILTIN_IMPORTS = new Set(
+  builtinModules.flatMap((name) => [name, name.startsWith('node:') ? name.slice(5) : `node:${name}`]),
+);
+// `ws` probes these native accelerators inside try/catch and immediately uses
+// its bundled JavaScript fallback when they are absent. They are not required
+// runtime dependencies and must not be shipped as cross-platform native code.
+const OPTIONAL_FALLBACK_IMPORTS = new Set(['bufferutil', 'canvas', 'utf-8-validate']);
+const MANIFEST_FIELDS = [
+  'name',
+  'publisher',
+  'displayName',
+  'version',
+  'engines',
+  'extensionKind',
+  'capabilities',
+  'activationEvents',
+  'main',
+  'icon',
+];
+const CONTRIBUTE_FIELDS = [
+  'commands',
+  'configuration',
+  'keybindings',
+  'menus',
+  'views',
+  'viewsContainers',
+];
+
+export async function verifyVsix(vsixPath, target, options = {}) {
+  const extractionRoot = await mkdtemp(join(tmpdir(), 'kimi-vsix-audit-'));
+  try {
+    await extractZip(vsixPath, extractionRoot);
+    return await auditExtractedVsix(extractionRoot, target, options);
+  } finally {
+    await rm(extractionRoot, { recursive: true, force: true });
+  }
+}
+
+export async function auditExtractedVsix(extractionRoot, target, options = {}) {
+  const sourceRoot = options.sourceRoot ?? extensionRoot;
+  const extensionDir = join(extractionRoot, 'extension');
+  const files = await listFiles(extractionRoot);
+  const fileSet = new Set(files);
+
+  requireFile(fileSet, 'extension.vsixmanifest');
+  requireFile(fileSet, '[Content_Types].xml');
+  requireFile(fileSet, 'extension/package.json');
+  const packagedManifest = await readJson(join(extensionDir, 'package.json'), 'package.json');
+  const sourceManifest = await readJson(join(sourceRoot, 'package.json'), 'source package.json');
+
+  await verifyTargetManifest(extractionRoot, target);
+  verifyPackageManifest(packagedManifest, sourceManifest);
+  verifyRequiredFiles(fileSet, packagedManifest);
+  verifyForbiddenFiles(files);
+  await verifyNoSensitiveContent(extractionRoot, files, sourceRoot, options.forbiddenText ?? []);
+  await verifyRuntimeImports(extensionDir, files);
+  await verifyEntryImport(extensionDir, packagedManifest.main);
+
+  const bytes = await totalSize(extractionRoot, files);
+  return { target, files: files.length, bytes };
+}
+
+async function verifyTargetManifest(extractionRoot, target) {
+  const xml = await readFile(join(extractionRoot, 'extension.vsixmanifest'), 'utf8');
+  const actual = xml.match(/\bTargetPlatform="([^"]+)"/)?.[1];
+  if (actual !== target) {
+    throw new Error(
+      `VSIX manifest target is ${actual ?? 'missing'}, expected ${target}.`,
+    );
+  }
+}
+
+function verifyPackageManifest(packaged, source) {
+  if (typeof packaged.main !== 'string' || !packaged.main.endsWith('.js')) {
+    throw new Error(`Packaged extension main must be a .js entry, got ${String(packaged.main)}.`);
+  }
+  if (packaged.main !== './dist/extension.js') {
+    throw new Error(`Packaged extension main is ${packaged.main}, expected ./dist/extension.js.`);
+  }
+
+  for (const field of MANIFEST_FIELDS) {
+    if (!isDeepStrictEqual(packaged[field], source[field])) {
+      throw new Error(`Packaged package.json field "${field}" does not match the source manifest.`);
+    }
+  }
+  for (const field of CONTRIBUTE_FIELDS) {
+    if (!isDeepStrictEqual(packaged.contributes?.[field], source.contributes?.[field])) {
+      throw new Error(
+        `Packaged package.json contributes.${field} does not match the source manifest.`,
+      );
+    }
+  }
+}
+
+function verifyRequiredFiles(fileSet, manifest) {
+  const required = [
+    'extension/LICENSE.txt',
+    `extension/${stripLeadingDotSlash(manifest.main)}`,
+    ...REQUIRED_WEBVIEW_FILES.map((file) => `extension/${file}`),
+  ];
+  requireOneOf(fileSet, ['extension/README.md', 'extension/readme.md'], 'marketplace README');
+  if (typeof manifest.icon === 'string') required.push(`extension/${manifest.icon}`);
+
+  for (const container of Object.values(manifest.contributes?.viewsContainers ?? {})) {
+    if (!Array.isArray(container)) continue;
+    for (const view of container) {
+      if (typeof view?.icon === 'string') required.push(`extension/${view.icon}`);
+    }
+  }
+  for (const file of required) requireFile(fileSet, file);
+}
+
+function verifyForbiddenFiles(files) {
+  for (const file of files) {
+    const normalized = file.replaceAll('\\', '/');
+    const lower = normalized.toLowerCase();
+    const extensionRelative = lower.startsWith('extension/') ? lower.slice('extension/'.length) : lower;
+    const segments = extensionRelative.split('/');
+    const forbiddenSegment = segments.find((segment) => FORBIDDEN_PATH_SEGMENTS.has(segment));
+    if (forbiddenSegment !== undefined) {
+      throw new Error(`Forbidden package path segment "${forbiddenSegment}" in ${normalized}.`);
+    }
+    if (FORBIDDEN_EXTENSIONS.has(extname(lower))) {
+      throw new Error(`Forbidden package file type in ${normalized}.`);
+    }
+    if (
+      lower.includes('kimi-agent-sdk') ||
+      lower.includes('download-cli') ||
+      lower.includes('/bin/kimi/') ||
+      /(^|\/)uv(?:\.exe)?$/.test(lower)
+    ) {
+      throw new Error(`Legacy CLI/runtime artifact found in ${normalized}.`);
+    }
+  }
+}
+
+async function verifyNoSensitiveContent(extractionRoot, files, sourceRoot, extraForbiddenText) {
+  const secretValues = [process.env.VSCE_PAT, process.env.OVSX_PAT]
+    .filter((value) => typeof value === 'string' && value.length >= 8);
+  const forbidden = [sourceRoot, homedir(), ...extraForbiddenText, ...secretValues]
+    .filter((value) => typeof value === 'string' && value.length >= 4)
+    .flatMap((value) => [value, value.replaceAll('\\', '/'), value.replaceAll('/', '\\')]);
+
+  for (const file of files) {
+    if (!TEXT_EXTENSIONS.has(extname(file).toLowerCase())) continue;
+    const content = await readFile(join(extractionRoot, file), 'utf8');
+    const match = forbidden.find((value) => content.includes(value));
+    if (match === undefined) continue;
+    const label = secretValues.includes(match) ? 'a marketplace token' : 'a local filesystem path';
+    throw new Error(`Packaged text file ${file} contains ${label}.`);
+  }
+}
+
+async function verifyRuntimeImports(extensionDir, files) {
+  const distFiles = files.filter(
+    (file) => file.startsWith('extension/dist/') && ['.cjs', '.js', '.mjs'].includes(extname(file)),
+  );
+  if (distFiles.length === 0) throw new Error('No JavaScript extension bundle files were packaged.');
+
+  for (const archivePath of distFiles) {
+    const localPath = join(dirname(extensionDir), archivePath);
+    const source = await readFile(localPath, 'utf8');
+    for (const specifier of collectLiteralImports(source)) {
+      if (specifier === 'vscode' || BUILTIN_IMPORTS.has(specifier)) continue;
+      if (OPTIONAL_FALLBACK_IMPORTS.has(specifier)) continue;
+      if (specifier.startsWith('node:')) continue;
+      if (specifier.startsWith('.') || specifier.startsWith('/')) {
+        if (specifier.startsWith('/')) {
+          throw new Error(`Absolute runtime import "${specifier}" in ${archivePath}.`);
+        }
+        const dependencyPath = resolve(dirname(localPath), stripImportSuffix(specifier));
+        if (!runtimeImportExists(dependencyPath)) {
+          throw new Error(`Missing relative runtime import "${specifier}" in ${archivePath}.`);
+        }
+        continue;
+      }
+      if (specifier.startsWith('data:') || specifier.startsWith('file:')) continue;
+      throw new Error(`Bare runtime dependency "${specifier}" remains in ${archivePath}.`);
+    }
+  }
+}
+
+function collectLiteralImports(source) {
+  const imports = new Set();
+  const program = parse(source, {
+    allowHashBang: true,
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+  });
+  walkSyntax(program, (node) => {
+    if (
+      node.type === 'ImportDeclaration' ||
+      node.type === 'ExportAllDeclaration' ||
+      node.type === 'ExportNamedDeclaration'
+    ) {
+      const specifier = literalString(node.source);
+      if (specifier !== undefined) imports.add(specifier);
+      return;
+    }
+    if (node.type === 'ImportExpression') {
+      const specifier = literalString(node.source);
+      if (specifier !== undefined) imports.add(specifier);
+      return;
+    }
+    if (node.type === 'CallExpression' && isRuntimeRequire(node.callee)) {
+      const specifier = literalString(node.arguments?.[0]);
+      if (specifier !== undefined) imports.add(specifier);
+    }
+  });
+  return imports;
+}
+
+function walkSyntax(value, visit) {
+  if (Array.isArray(value)) {
+    for (const item of value) walkSyntax(item, visit);
+    return;
+  }
+  if (typeof value !== 'object' || value === null) return;
+  if (typeof value.type === 'string') visit(value);
+  for (const [key, child] of Object.entries(value)) {
+    if (key === 'start' || key === 'end' || key === 'loc' || key === 'range') continue;
+    walkSyntax(child, visit);
+  }
+}
+
+function isRuntimeRequire(callee) {
+  if (callee?.type === 'Identifier') return /^(?:__)?require\d*$/.test(callee.name);
+  if (callee?.type !== 'MemberExpression' || callee.computed === true) return false;
+  // `this.require(...)` is an ordinary class method call (e.g. a private field
+  // accessor in bundled sources), never a CommonJS require of a bare specifier.
+  if (callee.object?.type === 'ThisExpression') return false;
+  return callee.property?.type === 'Identifier' && callee.property.name === 'require';
+}
+
+function literalString(node) {
+  if (node?.type === 'Literal' && typeof node.value === 'string') return node.value;
+  if (node?.type === 'TemplateLiteral' && node.expressions?.length === 0) {
+    return node.quasis?.[0]?.value?.cooked;
+  }
+  return undefined;
+}
+
+async function verifyEntryImport(extensionDir, main) {
+  const mainPath = join(extensionDir, stripLeadingDotSlash(main));
+  const stubDir = join(extensionDir, 'node_modules', 'vscode');
+  await mkdir(stubDir, { recursive: true });
+  await writeFile(
+    join(stubDir, 'package.json'),
+    `${JSON.stringify({ name: 'vscode', version: '0.0.0-test', type: 'module', exports: './index.js' }, null, 2)}\n`,
+  );
+  await writeFile(join(stubDir, 'index.js'), 'export {};\n');
+
+  const script = [
+    `const extension = await import(${JSON.stringify(pathToFileURL(mainPath).href)});`,
+    'if (typeof extension.activate !== "function") {',
+    '  throw new Error("extension bundle does not export activate");',
+    '}',
+  ].join('\n');
+  const env = { ...process.env };
+  delete env.NODE_PATH;
+  const result = spawnSync(process.execPath, ['--input-type=module', '--eval', script], {
+    cwd: dirname(extensionDir),
+    env,
+    encoding: 'utf8',
+    timeout: 30_000,
+  });
+  await rm(join(extensionDir, 'node_modules'), { recursive: true, force: true });
+  if (result.error !== undefined) {
+    throw new Error(`Unable to import the unpacked extension entry: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const detail = conciseProcessError(result.stderr || result.stdout);
+    throw new Error(`Unpacked extension entry import failed: ${detail}`);
+  }
+}
+
+async function readJson(path, label) {
+  try {
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch (error) {
+    throw new Error(`${label} is not valid JSON: ${describeError(error)}`, { cause: error });
+  }
+}
+
+async function listFiles(root) {
+  const output = [];
+  async function visit(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const localPath = join(directory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(localPath);
+      } else if (entry.isFile()) {
+        output.push(relative(root, localPath).split(sep).join('/'));
+      } else {
+        throw new Error(`Unsupported non-file entry in unpacked VSIX: ${localPath}`);
+      }
+    }
+  }
+  await visit(root);
+  return output.sort();
+}
+
+async function totalSize(root, files) {
+  let bytes = 0;
+  for (const file of files) bytes += (await stat(join(root, file))).size;
+  return bytes;
+}
+
+function requireFile(fileSet, file) {
+  if (fileSet.has(file)) return;
+  throw new Error(`Required VSIX resource is missing: ${file}`);
+}
+
+function requireOneOf(fileSet, files, label) {
+  if (files.some((file) => fileSet.has(file))) return;
+  throw new Error(`Required VSIX resource is missing: ${label} (${files.join(' or ')}).`);
+}
+
+function runtimeImportExists(path) {
+  return [path, `${path}.js`, `${path}.mjs`, `${path}.cjs`, join(path, 'index.js')].some(existsSync);
+}
+
+function stripImportSuffix(specifier) {
+  return specifier.split(/[?#]/, 1)[0];
+}
+
+function stripLeadingDotSlash(value) {
+  return String(value).replace(/^\.\//, '');
+}
+
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function conciseProcessError(output) {
+  const lines = String(output).trim().split(/\r?\n/).filter(Boolean);
+  return lines.slice(-4).join('\n') || 'process exited without an error message';
+}
+
+function parseArguments(argv) {
+  const targets = [];
+  let outputDir = defaultVsixOutputDir;
+  let file;
+  let directory;
+  let help = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--') {
+      continue;
+    } else if (argument === '--help' || argument === '-h') {
+      help = true;
+    } else if (argument === '--out-dir') {
+      outputDir = requireOptionValue(argv, ++index, '--out-dir');
+    } else if (argument === '--target') {
+      targets.push(requireOptionValue(argv, ++index, '--target'));
+    } else if (argument === '--file') {
+      file = requireOptionValue(argv, ++index, '--file');
+    } else if (argument === '--directory') {
+      directory = requireOptionValue(argv, ++index, '--directory');
+    } else if (argument.startsWith('-')) {
+      throw new Error(`Unknown option: ${argument}`);
+    } else {
+      targets.push(argument);
+    }
+  }
+
+  if (file !== undefined && directory !== undefined) {
+    throw new Error('--file and --directory cannot be used together.');
+  }
+  const normalizedTargets = normalizeVsixTargets(targets);
+  if ((file !== undefined || directory !== undefined) && normalizedTargets.length !== 1) {
+    throw new Error('--file and --directory require exactly one target.');
+  }
+  return { targets: normalizedTargets, outputDir: resolve(outputDir), file, directory, help };
+}
+
+function requireOptionValue(argv, index, option) {
+  const value = argv[index];
+  if (value !== undefined && !value.startsWith('-')) return value;
+  throw new Error(`${option} requires a value.`);
+}
+
+function usage() {
+  return [
+    'Usage: node scripts/vsix-verify.mjs [targets...] [--out-dir <directory>]',
+    '       node scripts/vsix-verify.mjs --target <target> --file <file.vsix>',
+    '       node scripts/vsix-verify.mjs --target <target> --directory <unpacked-vsix>',
+    '',
+    'The verifier performs a package-content audit and an entry import smoke only.',
+    'It does not claim that a target passed a real operating-system E2E run.',
+  ].join('\n');
+}
+
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.help) {
+    console.log(usage());
+    return;
+  }
+
+  for (const target of options.targets) {
+    const input = options.directory ?? options.file ?? join(options.outputDir, vsixFileName(target));
+    const result = options.directory === undefined
+      ? await verifyVsix(resolve(input), target, { sourceRoot: extensionRoot })
+      : await auditExtractedVsix(resolve(input), target, { sourceRoot: extensionRoot });
+    console.log(
+      `Verified ${target}: ${result.files} files, ${result.bytes} unpacked bytes; static audit and entry import smoke passed (package-only).`,
+    );
+  }
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`VSIX verification failed: ${describeError(error)}`);
+    process.exitCode = 1;
+  });
+}

apps/vscode/scripts/watch-extension.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { extname, join, resolve } from 'node:path';
+
+import { runLocalCli } from './local-cli.mjs';
+import { extensionRoot, isMainModule } from './vsix-targets.mjs';
+
+const sourceDirectories = [
+  join(extensionRoot, 'src'),
+  join(extensionRoot, 'shared'),
+  ...[
+    'kaos',
+    'kosong',
+    'migration-legacy',
+    'node-sdk',
+    'oauth',
+    'protocol',
+    'telemetry',
+  ].map((name) => resolve(extensionRoot, `../../packages/${name}/src`)),
+].filter(existsSync);
+const rootConfigFiles = ['package.json', 'tsconfig.json', 'tsdown.config.ts'].map((name) =>
+  join(extensionRoot, name),
+);
+const watchedExtensions = new Set(['.cts', '.js', '.json', '.md', '.mjs', '.mts', '.ts', '.tsx']);
+const pollIntervalMs = 1_500;
+
+function buildExtension() {
+  runLocalCli(
+    'tsdown',
+    'tsdown',
+    ['--config', join(extensionRoot, 'tsdown.config.ts'), '--sourcemap'],
+    { cwd: extensionRoot },
+  );
+}
+
+async function main() {
+  buildExtension();
+  let snapshot = await sourceSnapshot();
+  let checking = false;
+  const poll = async () => {
+    if (checking) return;
+    checking = true;
+    try {
+      const nextSnapshot = await sourceSnapshot();
+      if (nextSnapshot === snapshot) return;
+      snapshot = nextSnapshot;
+      console.log('\nExtension source changed; rebuilding with sourcemaps...');
+      buildExtension();
+      console.log('Extension rebuild complete.');
+    } catch (error) {
+      console.error(`Extension watch check failed: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      checking = false;
+    }
+  };
+  const interval = setInterval(() => void poll(), pollIntervalMs);
+
+  const close = () => {
+    clearInterval(interval);
+    process.exit(0);
+  };
+  process.once('SIGINT', close);
+  process.once('SIGTERM', close);
+  console.log('Extension dev build complete; watching for changes.');
+}
+
+async function sourceSnapshot() {
+  const records = [];
+  for (const directory of sourceDirectories) await collectSourceRecords(directory, records);
+  for (const file of rootConfigFiles) await addFileRecord(file, records);
+  return records.sort().join('\n');
+}
+
+async function collectSourceRecords(directory, records) {
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      await collectSourceRecords(path, records);
+    } else if (entry.isFile() && watchedExtensions.has(extname(entry.name))) {
+      await addFileRecord(path, records);
+    }
+  }
+}
+
+async function addFileRecord(path, records) {
+  const info = await stat(path);
+  records.push(`${path}:${info.size}:${info.mtimeMs}`);
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`Extension watch failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  });
+}

apps/vscode/scripts/zip.mjs

@@ -0,0 +1,122 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve, sep } from 'node:path';
+import { inflateRawSync } from 'node:zlib';
+
+const END_OF_CENTRAL_DIRECTORY = 0x06054b50;
+const CENTRAL_DIRECTORY_ENTRY = 0x02014b50;
+const LOCAL_FILE_HEADER = 0x04034b50;
+const MAX_END_RECORD_SEARCH = 65_535 + 22;
+
+export async function extractZip(archivePath, destination) {
+  const archive = await readFile(archivePath);
+  const entries = readCentralDirectory(archive);
+
+  for (const entry of entries) {
+    const relativePath = safeArchivePath(entry.name);
+    if (relativePath === '') continue;
+    const outputPath = resolve(destination, relativePath);
+    assertInside(destination, outputPath, entry.name);
+
+    if (entry.name.endsWith('/')) {
+      await mkdir(outputPath, { recursive: true });
+      continue;
+    }
+
+    const content = readEntry(archive, entry);
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, content);
+  }
+
+  return entries.map((entry) => entry.name);
+}
+
+function readCentralDirectory(archive) {
+  const endOffset = findEndRecord(archive);
+  const entryCount = archive.readUInt16LE(endOffset + 10);
+  const directorySize = archive.readUInt32LE(endOffset + 12);
+  const directoryOffset = archive.readUInt32LE(endOffset + 16);
+
+  if (entryCount === 0xffff || directorySize === 0xffffffff || directoryOffset === 0xffffffff) {
+    throw new Error('ZIP64 VSIX archives are not supported by the verifier.');
+  }
+  if (directoryOffset + directorySize > archive.length) {
+    throw new Error('VSIX central directory points outside the archive.');
+  }
+
+  const entries = [];
+  let offset = directoryOffset;
+  for (let index = 0; index < entryCount; index += 1) {
+    if (archive.readUInt32LE(offset) !== CENTRAL_DIRECTORY_ENTRY) {
+      throw new Error(`Invalid VSIX central-directory entry at byte ${offset}.`);
+    }
+    const flags = archive.readUInt16LE(offset + 8);
+    if ((flags & 0x1) !== 0) throw new Error('Encrypted VSIX entries are not supported.');
+
+    const compression = archive.readUInt16LE(offset + 10);
+    const compressedSize = archive.readUInt32LE(offset + 20);
+    const uncompressedSize = archive.readUInt32LE(offset + 24);
+    const nameLength = archive.readUInt16LE(offset + 28);
+    const extraLength = archive.readUInt16LE(offset + 30);
+    const commentLength = archive.readUInt16LE(offset + 32);
+    const localOffset = archive.readUInt32LE(offset + 42);
+    const nameStart = offset + 46;
+    const name = archive.subarray(nameStart, nameStart + nameLength).toString('utf8');
+    entries.push({ name, compression, compressedSize, uncompressedSize, localOffset });
+    offset = nameStart + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+
+function findEndRecord(archive) {
+  const lowerBound = Math.max(0, archive.length - MAX_END_RECORD_SEARCH);
+  for (let offset = archive.length - 22; offset >= lowerBound; offset -= 1) {
+    if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY) return offset;
+  }
+  throw new Error('VSIX is not a readable ZIP archive: end record is missing.');
+}
+
+function readEntry(archive, entry) {
+  if (archive.readUInt32LE(entry.localOffset) !== LOCAL_FILE_HEADER) {
+    throw new Error(`Invalid local header for VSIX entry ${entry.name}.`);
+  }
+  const nameLength = archive.readUInt16LE(entry.localOffset + 26);
+  const extraLength = archive.readUInt16LE(entry.localOffset + 28);
+  const dataStart = entry.localOffset + 30 + nameLength + extraLength;
+  const dataEnd = dataStart + entry.compressedSize;
+  if (dataEnd > archive.length) throw new Error(`Truncated VSIX entry ${entry.name}.`);
+
+  const compressed = archive.subarray(dataStart, dataEnd);
+  let content;
+  if (entry.compression === 0) {
+    content = compressed;
+  } else if (entry.compression === 8) {
+    content = inflateRawSync(compressed);
+  } else {
+    throw new Error(`Unsupported compression method ${entry.compression} for ${entry.name}.`);
+  }
+  if (content.length !== entry.uncompressedSize) {
+    throw new Error(
+      `Unexpected uncompressed size for ${entry.name}: ${content.length}, expected ${entry.uncompressedSize}.`,
+    );
+  }
+  return content;
+}
+
+function safeArchivePath(name) {
+  const normalized = name.replaceAll('\\', '/');
+  const segments = normalized.split('/').filter((segment) => segment !== '');
+  if (
+    normalized.startsWith('/') ||
+    /^[A-Za-z]:/.test(normalized) ||
+    segments.some((segment) => segment === '..')
+  ) {
+    throw new Error(`Unsafe path in VSIX archive: ${name}`);
+  }
+  return segments.join(sep);
+}
+
+function assertInside(destination, outputPath, archiveName) {
+  const root = resolve(destination);
+  if (outputPath === root || outputPath.startsWith(`${root}${sep}`)) return;
+  throw new Error(`Unsafe path in VSIX archive: ${archiveName}`);
+}

apps/vscode/shared/bridge.ts

@@ -0,0 +1,325 @@
+/**
+ * Bridge Protocol - Communication between VS Code extension and webview.
+ *
+ * Architecture:
+ * - Webview calls Methods via RPC (request/response)
+ * - Extension broadcasts Events to webview (one-way notifications)
+ *
+ * RPC flow: webview.call(method, params) -> extension.dispatch -> webview.resolve(result)
+ * Event flow: extension.broadcast(event, data) -> webview.on(event, handler)
+ */
+
+export const Methods = {
+  CheckWorkspace: "checkWorkspace",
+  GetInputHistory: "getInputHistory",
+  AddInputHistory: "addInputHistory",
+
+  GetSlashCommands: "getSlashCommands",
+  CheckLoginStatus: "checkLoginStatus",
+  Login: "login",
+  Logout: "logout",
+  SaveConfig: "saveConfig",
+  GetExtensionConfig: "getExtensionConfig",
+  OpenSettings: "openSettings",
+  OpenFolder: "openFolder",
+  GetModels: "getModels",
+
+  GetMCPServers: "getMCPServers",
+  AddMCPServer: "addMCPServer",
+  UpdateMCPServer: "updateMCPServer",
+  RemoveMCPServer: "removeMCPServer",
+  AuthMCP: "authMCP",
+  ResetAuthMCP: "resetAuthMCP",
+  TestMCP: "testMCP",
+
+  StreamChat: "streamChat",
+  AbortChat: "abortChat",
+  ResetSession: "resetSession",
+  SetPlanMode: "setPlanMode",
+  SteerChat: "steerChat",
+  RespondApproval: "respondApproval",
+
+  GetKimiSessions: "getKimiSessions",
+  GetAllKimiSessions: "getAllKimiSessions",
+  GetRegisteredWorkDirs: "getRegisteredWorkDirs",
+  SetWorkDir: "setWorkDir",
+  BrowseWorkDir: "browseWorkDir",
+  LoadKimiSessionHistory: "loadKimiSessionHistory",
+  DeleteKimiSession: "deleteKimiSession",
+  ForkKimiSession: "forkKimiSession",
+  GetProjectFiles: "getProjectFiles",
+  PickMedia: "pickMedia",
+  OpenFile: "openFile",
+  CheckFileExists: "checkFileExists",
+  CheckFilesExist: "checkFilesExist",
+  OpenFileDiff: "openFileDiff",
+  TrackFiles: "trackFiles",
+  ClearTrackedFiles: "clearTrackedFiles",
+  RevertFiles: "revertFiles",
+  KeepChanges: "keepChanges",
+  GetImageDataUri: "getImageDataUri",
+  ShowLogs: "showLogs",
+  ReloadWebview: "reloadWebview",
+  RespondQuestion: "respondQuestion",
+} as const;
+
+export type RpcMethod = (typeof Methods)[keyof typeof Methods];
+
+export interface RpcMessage {
+  readonly id: string;
+  readonly method: RpcMethod;
+  readonly params?: unknown;
+}
+
+export interface RpcResult {
+  readonly id: string;
+  readonly result?: unknown;
+  readonly error?: string;
+}
+
+export type RpcMessageValidation =
+  | { readonly ok: true; readonly message: RpcMessage }
+  | {
+      readonly ok: false;
+      readonly id: string;
+      readonly method: string;
+      readonly error: string;
+    };
+
+export const Events = {
+  ExtensionConfigChanged: "extensionConfigChanged",
+  MCPServersChanged: "mcpServersChanged",
+  StreamEvent: "streamEvent",
+  FocusInput: "focusInput",
+  InsertMention: "insertMention",
+  NewConversation: "newConversation",
+  FileChangesUpdated: "fileChangesUpdated",
+  RollbackInput: "rollbackInput",
+  LoginUrl: "loginUrl",
+} as const;
+
+const rpcMethods = new Set<string>(Object.values(Methods));
+
+/** Validates the untrusted Webview message before any host-side handler runs. */
+export function validateRpcMessage(value: unknown): RpcMessageValidation {
+  if (!isPlainObject(value)) {
+    return invalidMessage("", "<invalid>", "Invalid bridge request: expected a plain object.");
+  }
+
+  const id = value["id"];
+  if (!Object.hasOwn(value, "id") || typeof id !== "string" || id.trim().length === 0) {
+    return invalidMessage("", safeMethod(value["method"]), "Invalid bridge request: id must be a non-empty string.");
+  }
+
+  const method = value["method"];
+  if (!Object.hasOwn(value, "method") || typeof method !== "string" || method.trim().length === 0) {
+    return invalidMessage(id, "<invalid>", "Invalid bridge request: method must be a non-empty string.");
+  }
+  if (!rpcMethods.has(method)) {
+    return invalidMessage(id, method, `Unknown bridge method: ${method}`);
+  }
+  const params = Object.hasOwn(value, "params") ? value["params"] : undefined;
+  if (!validateParams(method as RpcMethod, params)) {
+    return invalidMessage(id, method, `Invalid bridge params for method: ${method}`);
+  }
+
+  return { ok: true, message: { id, method: method as RpcMethod, params } };
+}
+
+function validateParams(method: RpcMethod, params: unknown): boolean {
+  switch (method) {
+    case Methods.CheckWorkspace:
+    case Methods.GetInputHistory:
+    case Methods.GetSlashCommands:
+    case Methods.CheckLoginStatus:
+    case Methods.Login:
+    case Methods.Logout:
+    case Methods.GetExtensionConfig:
+    case Methods.OpenSettings:
+    case Methods.OpenFolder:
+    case Methods.GetModels:
+    case Methods.GetMCPServers:
+    case Methods.AbortChat:
+    case Methods.ResetSession:
+    case Methods.GetKimiSessions:
+    case Methods.GetAllKimiSessions:
+    case Methods.GetRegisteredWorkDirs:
+    case Methods.BrowseWorkDir:
+    case Methods.ClearTrackedFiles:
+    case Methods.ShowLogs:
+    case Methods.ReloadWebview:
+      return params === undefined;
+
+    case Methods.AddInputHistory:
+      return hasString(params, "text");
+    case Methods.SaveConfig:
+      return isPlainObject(params)
+        && typeof params["model"] === "string"
+        && isOptionalType(params["thinking"], "boolean")
+        && isOptionalType(params["effort"], "string")
+        && isOptionalType(params["effortChanged"], "boolean");
+    case Methods.AddMCPServer:
+      return isMcpServerConfig(params);
+    case Methods.UpdateMCPServer:
+      return isMcpUpdate(params);
+    case Methods.RemoveMCPServer:
+    case Methods.AuthMCP:
+    case Methods.ResetAuthMCP:
+    case Methods.TestMCP:
+      return hasNonEmptyString(params, "name");
+    case Methods.StreamChat:
+      return isStreamChatParams(params);
+    case Methods.RespondApproval:
+      return isPlainObject(params)
+        && isNonEmptyString(params["requestId"])
+        && (params["response"] === "approve"
+          || params["response"] === "approve_for_session"
+          || params["response"] === "reject");
+    case Methods.RespondQuestion:
+      return isPlainObject(params)
+        && isNonEmptyString(params["rpcRequestId"])
+        && isNonEmptyString(params["questionRequestId"])
+        && isStringRecord(params["answers"]);
+    case Methods.SetPlanMode:
+      return hasBoolean(params, "enabled");
+    case Methods.SteerChat:
+      return isPlainObject(params) && isContent(params["content"]);
+    case Methods.GetProjectFiles:
+      return params === undefined || (
+        isPlainObject(params)
+        && isOptionalType(params["query"], "string")
+        && isOptionalType(params["directory"], "string")
+      );
+    case Methods.SetWorkDir:
+      return isPlainObject(params) && (params["workDir"] === null || typeof params["workDir"] === "string");
+    case Methods.LoadKimiSessionHistory:
+      return hasNonEmptyString(params, "kimiSessionId");
+    case Methods.DeleteKimiSession:
+      return hasNonEmptyString(params, "sessionId");
+    case Methods.ForkKimiSession:
+      return isPlainObject(params)
+        && isNonEmptyString(params["sessionId"])
+        && Number.isInteger(params["turnIndex"])
+        && (params["turnIndex"] as number) >= 0;
+    case Methods.PickMedia:
+      return isPlainObject(params)
+        && (params["maxCount"] === undefined
+          || (Number.isInteger(params["maxCount"]) && (params["maxCount"] as number) >= 0))
+        && isOptionalType(params["includeVideo"], "boolean");
+    case Methods.OpenFile:
+    case Methods.OpenFileDiff:
+    case Methods.CheckFileExists:
+    case Methods.GetImageDataUri:
+      return hasString(params, "filePath");
+    case Methods.CheckFilesExist:
+    case Methods.TrackFiles:
+      return hasStringArray(params, "paths");
+    case Methods.RevertFiles:
+    case Methods.KeepChanges:
+      return isPlainObject(params) && isOptionalType(params["filePath"], "string");
+  }
+}
+
+function isStreamChatParams(value: unknown): boolean {
+  return isPlainObject(value)
+    && isContent(value["content"])
+    && typeof value["model"] === "string"
+    && isOptionalType(value["effort"], "string")
+    && isOptionalType(value["thinking"], "boolean")
+    && isOptionalType(value["planMode"], "boolean")
+    && isOptionalType(value["sessionId"], "string");
+}
+
+function isContent(value: unknown): boolean {
+  return typeof value === "string" || (Array.isArray(value) && value.every(isContentPart));
+}
+
+function isContentPart(value: unknown): boolean {
+  if (!isPlainObject(value) || typeof value["type"] !== "string") return false;
+  switch (value["type"]) {
+    case "text":
+      return typeof value["text"] === "string";
+    case "think":
+      return typeof value["think"] === "string"
+        && (value["encrypted"] === undefined
+          || value["encrypted"] === null
+          || typeof value["encrypted"] === "string");
+    case "image_url":
+    case "audio_url":
+    case "video_url": {
+      const media = value[value["type"]];
+      return isPlainObject(media)
+        && typeof media["url"] === "string"
+        && (media["id"] === undefined || media["id"] === null || typeof media["id"] === "string");
+    }
+    default:
+      return false;
+  }
+}
+
+function isMcpUpdate(value: unknown): boolean {
+  if (!isPlainObject(value)) return false;
+  if (Object.hasOwn(value, "server")) {
+    return isNonEmptyString(value["originalName"]) && isMcpServerConfig(value["server"]);
+  }
+  return isMcpServerConfig(value);
+}
+
+function isMcpServerConfig(value: unknown): boolean {
+  return isPlainObject(value)
+    && isNonEmptyString(value["name"])
+    && (value["transport"] === "stdio" || value["transport"] === "http")
+    && isOptionalType(value["url"], "string")
+    && isOptionalType(value["command"], "string")
+    && (value["args"] === undefined || isStringArray(value["args"]))
+    && (value["env"] === undefined || isStringRecord(value["env"]))
+    && (value["headers"] === undefined || isStringRecord(value["headers"]))
+    && (value["auth"] === undefined || value["auth"] === "oauth")
+    && isOptionalType(value["bearerTokenEnvVar"], "string");
+}
+
+function hasString(value: unknown, key: string): boolean {
+  return isPlainObject(value) && typeof value[key] === "string";
+}
+
+function hasNonEmptyString(value: unknown, key: string): boolean {
+  return isPlainObject(value) && isNonEmptyString(value[key]);
+}
+
+function hasBoolean(value: unknown, key: string): boolean {
+  return isPlainObject(value) && typeof value[key] === "boolean";
+}
+
+function hasStringArray(value: unknown, key: string): boolean {
+  return isPlainObject(value) && isStringArray(value[key]);
+}
+
+function isStringArray(value: unknown): boolean {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isStringRecord(value: unknown): boolean {
+  return isPlainObject(value) && Object.values(value).every((item) => typeof item === "string");
+}
+
+function isOptionalType(value: unknown, type: "string" | "boolean"): boolean {
+  return value === undefined || typeof value === type;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function invalidMessage(id: string, method: string, error: string): RpcMessageValidation {
+  return { ok: false, id, method, error };
+}
+
+function safeMethod(value: unknown): string {
+  return typeof value === "string" && value.length > 0 ? value : "<invalid>";
+}

apps/vscode/shared/errors.ts

@@ -0,0 +1,106 @@
+import type { ErrorPhase } from "./types";
+
+// Keep the released Webview's error contract local. The upper-case values are
+// accepted for sessions restored from the legacy extension; the dotted values
+// are emitted by the in-process v1 core.
+const LEGACY = {
+  CLI_NOT_FOUND: "CLI_NOT_FOUND",
+  SPAWN_FAILED: "SPAWN_FAILED",
+  ALREADY_STARTED: "ALREADY_STARTED",
+  STDIN_NOT_WRITABLE: "STDIN_NOT_WRITABLE",
+  HANDSHAKE_TIMEOUT: "HANDSHAKE_TIMEOUT",
+  PROCESS_CRASHED: "PROCESS_CRASHED",
+  LLM_NOT_SET: "LLM_NOT_SET",
+  LLM_NOT_SUPPORTED: "LLM_NOT_SUPPORTED",
+  INVALID_STATE: "INVALID_STATE",
+  CHAT_PROVIDER_ERROR: "CHAT_PROVIDER_ERROR",
+  SESSION_BUSY: "SESSION_BUSY",
+  SESSION_CLOSED: "SESSION_CLOSED",
+  TURN_INTERRUPTED: "TURN_INTERRUPTED",
+  INVALID_JSON: "INVALID_JSON",
+  INVALID_REQUEST: "INVALID_REQUEST",
+  INVALID_PARAMS: "INVALID_PARAMS",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+} as const;
+
+// Pre-flight: task didn't start at all or was blocked by "gatekeeper"
+export const PREFLIGHT_CODES = new Set<string>([
+  LEGACY.CLI_NOT_FOUND,
+  LEGACY.SPAWN_FAILED,
+  LEGACY.ALREADY_STARTED,
+  LEGACY.STDIN_NOT_WRITABLE,
+  LEGACY.PROCESS_CRASHED,
+  LEGACY.LLM_NOT_SET,
+  LEGACY.LLM_NOT_SUPPORTED,
+  LEGACY.INVALID_STATE,
+  LEGACY.SESSION_BUSY,
+  "config.invalid",
+  "model.not_configured",
+  "auth.login_required",
+  "session.not_found",
+  "session.state_not_found",
+  "session.state_invalid",
+  "session.init_failed",
+  "shell.git_bash_not_found",
+]);
+
+// User-friendly error messages
+export const ERROR_MESSAGES: Record<string, string> = {
+  // Pre-flight
+  [LEGACY.CLI_NOT_FOUND]: "Kimi Code CLI not found.",
+  [LEGACY.SPAWN_FAILED]: "Failed to start Kimi Code CLI.",
+  [LEGACY.ALREADY_STARTED]: "A session is already running.",
+  [LEGACY.STDIN_NOT_WRITABLE]: "Failed to communicate with Kimi Code CLI.",
+  [LEGACY.HANDSHAKE_TIMEOUT]: "Connection timed out.",
+  [LEGACY.PROCESS_CRASHED]: "Process connection lost.",
+
+  // CLI errors
+  [LEGACY.LLM_NOT_SET]: "Authentication failed. Please sign in.",
+  [LEGACY.LLM_NOT_SUPPORTED]: "This model is not supported.",
+  [LEGACY.INVALID_STATE]: "Please wait for the current operation.",
+  [LEGACY.CHAT_PROVIDER_ERROR]: "Service temporarily unavailable.",
+
+  // Session errors
+  [LEGACY.SESSION_BUSY]: "A message is being sent. Please wait.",
+  [LEGACY.SESSION_CLOSED]: "Session was closed.",
+  [LEGACY.TURN_INTERRUPTED]: "Stopped by user.",
+
+  // Protocol errors
+  [LEGACY.INVALID_JSON]: "Communication format error.",
+  [LEGACY.INVALID_REQUEST]: "Invalid request.",
+  [LEGACY.INVALID_PARAMS]: "Invalid parameters.",
+  [LEGACY.INTERNAL_ERROR]: "Internal error occurred.",
+
+  "config.invalid": "Kimi Code configuration is invalid.",
+  "model.not_configured": "No model is configured. Please sign in or configure a provider.",
+  "auth.login_required": "Authentication failed. Please sign in.",
+  "session.not_found": "Session was not found.",
+  "session.state_not_found": "Session data is missing.",
+  "session.state_invalid": "Session data is invalid.",
+  "session.init_failed": "Failed to initialize the session.",
+  "session.closed": "Session was closed.",
+  "session.fork_active_turn": "Wait for the current response before forking.",
+  "turn.agent_busy": "A message is being sent. Please wait.",
+  "provider.api_error": "Service temporarily unavailable.",
+  "provider.rate_limit": "Too many requests. Please try again later.",
+  "provider.auth_error": "Authentication failed. Please sign in again.",
+  "provider.connection_error": "Could not connect to the model provider.",
+  "request.prompt_input_empty": "Prompt cannot be empty.",
+  internal: "Internal error occurred.",
+};
+
+export function classifyError(code: string): ErrorPhase {
+  return PREFLIGHT_CODES.has(code) ? "preflight" : "runtime";
+}
+
+export function getUserMessage(code: string, fallback?: string): string {
+  return ERROR_MESSAGES[code] || fallback || "An unknown error occurred.";
+}
+
+export function isPreflightError(code: string): boolean {
+  return PREFLIGHT_CODES.has(code);
+}
+
+export function isUserInterrupt(code: string): boolean {
+  return code === LEGACY.TURN_INTERRUPTED || code === "turn.cancelled";
+}

apps/vscode/shared/fork-turn-index.ts

@@ -0,0 +1,43 @@
+interface ForkTurnItem {
+  readonly type: string;
+}
+
+interface ForkTurnMessage {
+  readonly role: "user" | "assistant";
+  readonly forkable?: boolean;
+  readonly steps?: readonly {
+    readonly items: readonly ForkTurnItem[];
+  }[];
+}
+
+/** Return the core's zero-based user-visible turn index for an assistant bubble. */
+export function getForkTurnIndex(
+  messages: readonly ForkTurnMessage[],
+  messageIndex: number,
+): number | undefined {
+  const target = messages[messageIndex];
+  if (target?.role !== "assistant" || target.forkable === false) return undefined;
+
+  let visibleTurns = 0;
+  for (let index = 0; index <= messageIndex; index += 1) {
+    const message = messages[index];
+    if (message === undefined) continue;
+    if (message.role === "user" && message.forkable !== false) {
+      visibleTurns += 1;
+      continue;
+    }
+    if (message.role === "assistant") {
+      visibleTurns += countSteers(message);
+    }
+  }
+  return visibleTurns - 1;
+}
+
+function countSteers(message: ForkTurnMessage): number {
+  return (
+    message.steps?.reduce(
+      (count, step) => count + step.items.filter((item) => item.type === "steer").length,
+      0,
+    ) ?? 0
+  );
+}

apps/vscode/shared/legacy-sdk.ts

@@ -0,0 +1,233 @@
+/**
+ * UI-facing compatibility types for the released Webview.
+ *
+ * The extension host adapts v1 Node SDK events into this shape while the UI is
+ * migrated without a visual rewrite. This file contains no legacy SDK runtime.
+ */
+
+export type ApprovalResponse = 'approve' | 'approve_for_session' | 'reject';
+
+export type ContentPart =
+  | { type: 'text'; text: string }
+  | { type: 'think'; think: string; encrypted?: string | null }
+  | { type: 'image_url'; image_url: { url: string; id?: string | null } }
+  | { type: 'audio_url'; audio_url: { url: string; id?: string | null } }
+  | { type: 'video_url'; video_url: { url: string; id?: string | null } };
+
+export interface BriefBlock {
+  type: 'brief';
+  text: string;
+}
+
+export interface DiffBlock {
+  type: 'diff';
+  path: string;
+  old_text: string;
+  new_text: string;
+}
+
+export interface TodoBlock {
+  type: 'todo';
+  items: Array<{ title: string; status: 'pending' | 'in_progress' | 'done' }>;
+}
+
+export interface ShellBlock {
+  type: 'shell';
+  language: string;
+  command: string;
+}
+
+export interface UnknownBlock {
+  type: string;
+  data?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export type DisplayBlock = BriefBlock | DiffBlock | TodoBlock | ShellBlock | UnknownBlock;
+
+export interface ToolCall {
+  type: 'function';
+  id: string;
+  function: { name: string; arguments?: string | null };
+  extras?: Record<string, unknown> | null;
+}
+
+export interface ToolReturnValue {
+  is_error: boolean;
+  output: string | ContentPart[];
+  message: string;
+  display: DisplayBlock[];
+  extras?: Record<string, unknown> | null;
+}
+
+export interface ToolResult {
+  tool_call_id: string;
+  return_value: ToolReturnValue;
+}
+
+export interface TurnBegin {
+  user_input: string | ContentPart[];
+}
+
+export interface TokenUsage {
+  input_other: number;
+  output: number;
+  input_cache_read: number;
+  input_cache_creation: number;
+}
+
+export interface StatusUpdate {
+  context_usage?: number | null;
+  token_usage?: TokenUsage | null;
+  message_id?: string | null;
+  plan_mode?: boolean | null;
+  model?: string | null;
+  thinking_effort?: string | null;
+  retrying?: {
+    next_attempt: number;
+    max_attempts: number;
+    delay_ms: number;
+    message: string;
+  } | null;
+}
+
+export interface ApprovalRequestPayload {
+  id: string;
+  tool_call_id: string;
+  sender: string;
+  action: string;
+  description: string;
+  display?: DisplayBlock[];
+}
+
+export interface QuestionOption {
+  label: string;
+  description?: string;
+}
+
+export interface QuestionItem {
+  question: string;
+  header?: string;
+  options: QuestionOption[];
+  multi_select?: boolean;
+}
+
+export interface QuestionRequest {
+  id: string;
+  tool_call_id: string;
+  questions: QuestionItem[];
+}
+
+export interface QuestionResponse {
+  request_id: string;
+  answers: Record<string, string>;
+}
+
+export interface SubagentEvent {
+  parent_tool_call_id: string;
+  event: LegacyWireEvent;
+}
+
+export type LegacyWireEvent =
+  | { type: 'TurnBegin'; payload: TurnBegin & { forkable?: boolean } }
+  | { type: 'TurnEnd'; payload: Record<string, never> }
+  | { type: 'StepBegin'; payload: { n: number } }
+  | { type: 'StepInterrupted'; payload: Record<string, never> }
+  | { type: 'CompactionBegin'; payload: Record<string, never> }
+  | { type: 'CompactionEnd'; payload: Record<string, never> }
+  | { type: 'StatusUpdate'; payload: StatusUpdate }
+  | { type: 'ContentPart'; payload: ContentPart }
+  | { type: 'ToolCall'; payload: ToolCall }
+  | { type: 'ToolCallPart'; payload: { tool_call_id?: string; arguments_part?: string | null } }
+  | { type: 'ToolResult'; payload: ToolResult }
+  | { type: 'SteerInput'; payload: { user_input: string | ContentPart[] } }
+  | { type: 'SubagentEvent'; payload: SubagentEvent }
+  | { type: string; payload: unknown };
+
+export type StreamEvent =
+  | LegacyWireEvent
+  | { type: 'ApprovalRequest'; payload: ApprovalRequestPayload }
+  | { type: 'QuestionRequest'; payload: QuestionRequest }
+  | { type: 'error'; code: string; message: string; raw?: string };
+
+export interface RunResult {
+  status: 'finished' | 'cancelled' | 'max_steps_reached';
+  steps?: number;
+}
+
+export interface SlashCommandInfo {
+  name: string;
+  description: string;
+  aliases: string[];
+}
+
+export interface ModelConfig {
+  id: string;
+  name: string;
+  provider: string;
+  capabilities: string[];
+  adaptive_thinking?: boolean;
+  support_efforts?: string[];
+  default_effort?: string;
+}
+
+export interface KimiConfig {
+  defaultModel: string | null;
+  defaultThinking: boolean;
+  defaultThinkingEffort?: string;
+  models: ModelConfig[];
+}
+
+/** Placeholder returned to the Webview instead of a stored MCP credential. */
+export const MCP_SECRET_MASK = '••••••••';
+
+export interface MCPServerConfig {
+  name: string;
+  transport: 'http' | 'stdio';
+  url?: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  headers?: Record<string, string>;
+  auth?: 'oauth';
+  bearerTokenEnvVar?: string;
+  /** Unified management view tags; absent on cores predating the management plane. */
+  source?: 'global' | 'plugin' | 'caller';
+  /** global: defining file path; plugin: plugin id. */
+  origin?: string;
+  /** false for plugin / project-layer entries — the panel hides mutating actions for them. */
+  mutable?: boolean;
+}
+
+export interface UpdateMCPServerRequest {
+  originalName: string;
+  server: MCPServerConfig;
+}
+
+export interface SessionInfo {
+  id: string;
+  workDir: string;
+  updatedAt: number;
+  brief: string;
+}
+
+export type ThinkingMode = 'none' | 'switch' | 'always' | 'effort';
+
+export interface MCPTestResult {
+  success: boolean;
+  output: string;
+}
+
+export interface LoginResult {
+  success: boolean;
+  error?: string;
+}
+
+export function formatContentOutput(output: string | ContentPart[]): string {
+  if (typeof output === 'string') return output;
+  if (!Array.isArray(output)) return JSON.stringify(output);
+  return output
+    .map((item) => item.type === 'text' ? item.text : `[${item.type}]`)
+    .filter(Boolean)
+    .join('\n');
+}

apps/vscode/shared/types.ts

@@ -0,0 +1,73 @@
+import type { RunResult, StreamEvent } from "./legacy-sdk";
+
+export interface SessionConfig {
+  model: string;
+  thinking?: boolean;
+  effort?: string;
+  /**
+   * Whether the user explicitly changed the effort. Re-confirming the effort
+   * already shown is not an explicit choice: the model is persisted but the
+   * stored effort preference is left alone (mirrors the TUI's
+   * persistModelSelection). Treated as true when omitted.
+   */
+  effortChanged?: boolean;
+}
+
+export interface ProjectFile {
+  path: string;
+  name: string;
+  isDirectory: boolean;
+  /** Matched-character offsets into `path`, for mention-style highlighting. */
+  matchPositions?: number[];
+}
+
+export interface FileChange {
+  path: string;
+  status: "Modified" | "Added" | "Deleted";
+  additions: number;
+  deletions: number;
+}
+
+export interface ExtensionConfig {
+  yoloMode: boolean;
+  autosave: boolean;
+  useCtrlEnterToSend: boolean;
+  enableNewConversationShortcut: boolean;
+  showThinkingContent: boolean;
+  showThinkingExpanded: boolean;
+  version: string;
+}
+
+export interface WorkspaceStatus {
+  hasWorkspace: boolean;
+  path?: string;
+  workspaceRoot?: string;
+}
+
+export type ErrorPhase = "preflight" | "runtime";
+
+export interface StreamError {
+  type: "error";
+  code: string;
+  message: string;
+  detail?: string; // 原始服务器错误信息
+  phase: ErrorPhase;
+  /**
+   * `false` marks a mid-turn warning: the turn is still running, so UIs must
+   * not treat it as turn-ending. Do not unlock the composer, offer Retry, or
+   * flush the queued messages for non-terminal errors.
+   */
+  terminal?: boolean;
+}
+
+export type UIStreamEvent =
+  | { type: "session_start"; sessionId: string; model?: string; _sessionId?: string }
+  | { type: "stream_complete"; result: RunResult; _sessionId?: string }
+  | (StreamError & { _sessionId?: string })
+  | (StreamEvent & { _sessionId?: string });
+
+export interface LoginStatus {
+  loggedIn: boolean;
+}
+
+export type { QuestionRequest, QuestionItem, QuestionOption, QuestionResponse } from "./legacy-sdk";

apps/vscode/shared/utils.ts

@@ -0,0 +1,3 @@
+export function cleanSystemTags(text: string): string {
+  return text.replace(/<system>.*?<\/system>\s*/gs, "").trim();
+}

apps/vscode/test/app-init.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Scenario: App-level view routing after init, across login state transitions.
+ * Responsibilities: the sign-in screen must stay reachable from every state — in
+ * particular the no-models state (a managed OAuth token exists but config.toml
+ * has no models, e.g. a first login whose model provisioning failed after the
+ * device flow already persisted the token), where Reload alone can never change
+ * the on-disk state and the user would otherwise be stranded.
+ * Wiring: resolveAppView is pure; the bridge and toast boundaries are mocked away.
+ * Run: pnpm exec vitest run --config apps/vscode/vitest.config.ts test/app-init.test.ts
+ */
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/services", () => ({
+  bridge: {},
+  Events: {},
+}));
+vi.mock("@/components/ui/sonner", () => ({
+  toast: { error: vi.fn(), warning: vi.fn() },
+}));
+
+import { resolveAppView, type AppStatus } from "../webview-ui/src/hooks/useAppInit";
+
+function resolve(
+  status: AppStatus,
+  options: { modelsCount?: number; skippedLogin?: boolean; showLogin?: boolean } = {},
+) {
+  return resolveAppView({
+    status,
+    modelsCount: options.modelsCount ?? 0,
+    skippedLogin: options.skippedLogin ?? false,
+    showLogin: options.showLogin ?? false,
+  });
+}
+
+describe("resolveAppView", () => {
+  it("routes a brand-new user (no token, no models) to the login screen", () => {
+    expect(resolve("not-logged-in")).toEqual({ view: "login" });
+  });
+
+  it("routes a skipped login without models to no-models with a sign-in path", () => {
+    expect(resolve("not-logged-in", { skippedLogin: true })).toEqual({
+      view: "status",
+      status: "no-models",
+      canGoToLogin: true,
+    });
+  });
+
+  it("routes a skipped login with models to the main view", () => {
+    expect(resolve("not-logged-in", { skippedLogin: true, modelsCount: 2 })).toEqual({
+      view: "main",
+    });
+  });
+
+  it("keeps a sign-in path in the no-models trap (token without model config)", () => {
+    // Regression: this state previously rendered "Model setup required" with only
+    // a Reload button, making the login screen unreachable for affected users.
+    expect(resolve("no-models")).toEqual({
+      view: "status",
+      status: "no-models",
+      canGoToLogin: true,
+    });
+  });
+
+  it("routes to the login screen when the user asks for it from any state", () => {
+    expect(resolve("no-models", { showLogin: true })).toEqual({ view: "login" });
+    expect(resolve("ready", { showLogin: true, modelsCount: 1 })).toEqual({ view: "login" });
+  });
+
+  it("routes a no-models user who skips again back to no-models with a sign-in path", () => {
+    expect(resolve("no-models", { skippedLogin: true })).toEqual({
+      view: "status",
+      status: "no-models",
+      canGoToLogin: true,
+    });
+  });
+
+  it("routes ready to the main view", () => {
+    expect(resolve("ready", { modelsCount: 1 })).toEqual({ view: "main" });
+  });
+
+  it("routes non-login error statuses to status screens without a sign-in path", () => {
+    for (const status of ["loading", "no-workspace", "runtime-error"] as const) {
+      expect(resolve(status)).toEqual({ view: "status", status, canGoToLogin: false });
+    }
+  });
+});

apps/vscode/test/baseline.manager.test.ts

@@ -0,0 +1,412 @@
+/**
+ * Scenario: VSCode-owned file baselines for new, migrated, and forked sessions.
+ * Responsibilities: capture originals, show changes, keep/undo, persist legacy tombstones, and reject unsafe paths.
+ * Wiring: real temporary workspace/global-storage/legacy files; no stubbed collaborators.
+ * Run: pnpm --filter kimi-code test -- baseline.manager.test.ts
+ */
+import { existsSync, writeFileSync } from 'node:fs';
+import { chmod, mkdir, mkdtemp, readFile, rm, symlink, unlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  BaselineManager,
+  type BaselineSession,
+} from '../src/managers/baseline.manager';
+
+let root: string;
+let workDir: string;
+let storageRoot: string;
+let manager: BaselineManager;
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'vscode-baseline-'));
+  workDir = join(root, 'workspace');
+  storageRoot = join(root, 'global-storage');
+  await mkdir(workDir, { recursive: true });
+  manager = new BaselineManager(storageRoot);
+});
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true });
+});
+
+describe('file baselines (capture, compare, keep, and undo)', () => {
+  it('keeps the first original when overlapping captures race', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'src', 'app.ts');
+    await mkdir(join(workDir, 'src'), { recursive: true });
+    writeFileSync(filePath, 'original\n', 'utf-8');
+
+    const firstCapture = manager.capture(session, filePath);
+    writeFileSync(filePath, 'after first edit\n', 'utf-8');
+    const secondCapture = manager.capture(session, filePath);
+    await Promise.all([firstCapture, secondCapture]);
+
+    expect(await manager.getContent(session, filePath)).toBe('original\n');
+  });
+
+  it('returns the captured original after the manager is recreated', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'app.ts');
+    await writeFile(filePath, 'persisted original\n', 'utf-8');
+    await manager.capture(session, filePath);
+
+    const reloadedManager = new BaselineManager(storageRoot);
+
+    await expect(reloadedManager.getContent(session, filePath)).resolves.toBe(
+      'persisted original\n',
+    );
+  });
+
+  it('isolates the same session id between different Kimi homes', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'app.ts');
+    const firstHome = new BaselineManager(storageRoot, join(root, 'home-a'));
+    const secondHome = new BaselineManager(storageRoot, join(root, 'home-b'));
+    await writeFile(filePath, 'home A original\n', 'utf-8');
+    await firstHome.capture(session, filePath);
+    await writeFile(filePath, 'home B original\n', 'utf-8');
+    await secondHome.capture(session, filePath);
+
+    await expect(firstHome.getContent(session, filePath)).resolves.toBe('home A original\n');
+    await expect(secondHome.getContent(session, filePath)).resolves.toBe('home B original\n');
+  });
+
+  it('reports a modified file when current content differs from its original', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'app.ts');
+    await writeFile(filePath, 'before\n', 'utf-8');
+    await manager.capture(session, filePath);
+    await writeFile(filePath, 'after\n', 'utf-8');
+
+    await expect(manager.getChanges(session)).resolves.toEqual([
+      { path: 'app.ts', status: 'Modified', additions: 1, deletions: 1 },
+    ]);
+  });
+
+  it('reports an added file when it did not exist at capture time', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'new.ts');
+    await manager.capture(session, filePath);
+    await writeFile(filePath, 'new content\n', 'utf-8');
+
+    await expect(manager.getChanges(session)).resolves.toEqual([
+      { path: 'new.ts', status: 'Added', additions: 2, deletions: 0 },
+    ]);
+  });
+
+  it('reports a deleted file when an existing original is removed', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'old.ts');
+    await writeFile(filePath, 'line one\nline two', 'utf-8');
+    await manager.capture(session, filePath);
+    await unlink(filePath);
+
+    await expect(manager.getChanges(session)).resolves.toEqual([
+      { path: 'old.ts', status: 'Deleted', additions: 0, deletions: 2 },
+    ]);
+  });
+
+  it('removes a newly created file when undo restores its missing original', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'new.ts');
+    await manager.capture(session, filePath);
+    await writeFile(filePath, 'created\n', 'utf-8');
+
+    await manager.undo(session, filePath);
+
+    expect(existsSync(filePath)).toBe(false);
+  });
+
+  it('restores an existing empty file without deleting it when undo runs', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'empty.ts');
+    await writeFile(filePath, '', 'utf-8');
+    await manager.capture(session, filePath);
+    await writeFile(filePath, 'changed', 'utf-8');
+
+    await manager.undo(session, filePath);
+
+    expect(existsSync(filePath)).toBe(true);
+    await expect(readFile(filePath, 'utf-8')).resolves.toBe('');
+  });
+
+  it('preserves CRLF bytes when undo restores the original file', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'windows.txt');
+    await writeFile(filePath, 'first\r\nsecond\r\n', 'utf-8');
+    await manager.capture(session, filePath);
+    await writeFile(filePath, 'changed\n', 'utf-8');
+
+    await manager.undo(session, filePath);
+
+    await expect(readFile(filePath, 'utf-8')).resolves.toBe('first\r\nsecond\r\n');
+  });
+
+  it('captures a new original after keep accepts the previous changes', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'app.ts');
+    await writeFile(filePath, 'first\n', 'utf-8');
+    await manager.capture(session, filePath);
+    await writeFile(filePath, 'accepted\n', 'utf-8');
+    await manager.keep(session, filePath);
+
+    await manager.capture(session, filePath);
+    await writeFile(filePath, 'next edit\n', 'utf-8');
+
+    expect(await manager.getContent(session, filePath)).toBe('accepted\n');
+  });
+
+  it('restores every tracked original when undo all runs', async () => {
+    const session = createSession();
+    await writeFile(join(workDir, 'one.ts'), 'one before', 'utf-8');
+    await writeFile(join(workDir, 'two.ts'), 'two before', 'utf-8');
+    await manager.capture(session, 'one.ts');
+    await manager.capture(session, 'two.ts');
+    await writeFile(join(workDir, 'one.ts'), 'one after', 'utf-8');
+    await writeFile(join(workDir, 'two.ts'), 'two after', 'utf-8');
+
+    await manager.undoAll(session);
+
+    await expect(readFile(join(workDir, 'one.ts'), 'utf-8')).resolves.toBe('one before');
+    await expect(readFile(join(workDir, 'two.ts'), 'utf-8')).resolves.toBe('two before');
+  });
+
+  it('refuses undo all when a tracked directory now links outside the workspace', async () => {
+    const session = createSession();
+    const trackedDir = join(workDir, 'src');
+    const outsideDir = join(root, 'outside');
+    await mkdir(trackedDir);
+    await mkdir(outsideDir);
+    await writeFile(join(trackedDir, 'app.ts'), 'original');
+    await manager.capture(session, 'src/app.ts');
+    await rm(trackedDir, { recursive: true });
+    await writeFile(join(outsideDir, 'app.ts'), 'outside');
+    await symlink(outsideDir, trackedDir, process.platform === 'win32' ? 'junction' : 'dir');
+
+    await expect(manager.undoAll(session)).rejects.toThrow('outside the session workspace');
+    await expect(readFile(join(outsideDir, 'app.ts'), 'utf-8')).resolves.toBe('outside');
+  });
+
+  it('removes every visible change when keep all runs', async () => {
+    const session = createSession();
+    await writeFile(join(workDir, 'one.ts'), 'one before', 'utf-8');
+    await writeFile(join(workDir, 'two.ts'), 'two before', 'utf-8');
+    await manager.capture(session, 'one.ts');
+    await manager.capture(session, 'two.ts');
+    await writeFile(join(workDir, 'one.ts'), 'one after', 'utf-8');
+    await writeFile(join(workDir, 'two.ts'), 'two after', 'utf-8');
+
+    await manager.keepAll(session);
+
+    await expect(manager.getChanges(session)).resolves.toEqual([]);
+  });
+});
+
+describe('legacy baselines (fallback, tombstones, and fork isolation)', () => {
+  it('returns the legacy original when no local baseline exists', async () => {
+    const { session } = await createLegacySession('legacy original\n');
+    await writeFile(join(workDir, 'app.ts'), 'current content\n', 'utf-8');
+
+    await expect(manager.getContent(session, 'app.ts')).resolves.toBe('legacy original\n');
+  });
+
+  it('reports a legacy file when current content differs from its original', async () => {
+    const { session } = await createLegacySession('legacy original\n');
+    await writeFile(join(workDir, 'app.ts'), 'current content\n', 'utf-8');
+
+    await expect(manager.getChanges(session)).resolves.toEqual([
+      { path: 'app.ts', status: 'Modified', additions: 1, deletions: 1 },
+    ]);
+  });
+
+  it('restores a legacy original without mutating its snapshot when undo runs', async () => {
+    const { session, baselinePath } = await createLegacySession('legacy original\n');
+    await writeFile(join(workDir, 'app.ts'), 'current content\n', 'utf-8');
+
+    await manager.undo(session, 'app.ts');
+
+    await expect(readFile(join(workDir, 'app.ts'), 'utf-8')).resolves.toBe('legacy original\n');
+    await expect(readFile(baselinePath, 'utf-8')).resolves.toBe('legacy original\n');
+  });
+
+  it('persists a keep tombstone for legacy content without deleting the old snapshot', async () => {
+    const { session, baselinePath } = await createLegacySession('legacy original\n');
+    await writeFile(join(workDir, 'app.ts'), 'accepted content\n', 'utf-8');
+    await manager.keep(session, 'app.ts');
+
+    const reloadedManager = new BaselineManager(storageRoot);
+
+    await expect(reloadedManager.getChanges(session)).resolves.toEqual([]);
+    await expect(readFile(baselinePath, 'utf-8')).resolves.toBe('legacy original\n');
+  });
+
+  it('uses a materialized local original before the fork target legacy fallback', async () => {
+    const source = createSession('ses-source');
+    const filePath = join(workDir, 'app.ts');
+    await writeFile(filePath, 'local original\n', 'utf-8');
+    await manager.capture(source, filePath);
+    const { session: target } = await createLegacySession('legacy original\n', 'ses-target');
+
+    await manager.materializeToFork(source, target);
+
+    await expect(manager.getContent(target, 'app.ts')).resolves.toBe('local original\n');
+  });
+
+  it('keeps a fork baseline readable when the legacy source is later deleted', async () => {
+    const { session: source, legacySessionDir } = await createLegacySession(
+      'legacy original\n',
+      'ses-source',
+    );
+    const target = createSession('ses-target', source.metadata);
+    await manager.materializeToFork(source, target);
+    await rm(legacySessionDir, { recursive: true, force: true });
+
+    await expect(manager.getContent(target, 'app.ts')).resolves.toBe('legacy original\n');
+  });
+
+  it('keeps the source baseline visible when the fork accepts its own copy', async () => {
+    const { session: source } = await createLegacySession('legacy original\n', 'ses-source');
+    const target = createSession('ses-target', source.metadata);
+    await manager.materializeToFork(source, target);
+
+    await manager.keep(target, 'app.ts');
+
+    await expect(manager.getContent(source, 'app.ts')).resolves.toBe('legacy original\n');
+  });
+
+  it('preserves accepted legacy paths when a fork is materialized', async () => {
+    const { session: source } = await createLegacySession('legacy original\n', 'ses-source');
+    const target = createSession('ses-target', source.metadata);
+    await manager.keep(source, 'app.ts');
+
+    await manager.materializeToFork(source, target);
+
+    await expect(manager.getContent(target, 'app.ts')).rejects.toThrow('No baseline exists');
+  });
+});
+
+describe('baseline boundaries (errors, cleanup, and platform paths)', () => {
+  it.skipIf(process.platform === 'win32')(
+    'rejects an unreadable original without recording an empty baseline',
+    async () => {
+      const session = createSession();
+      const filePath = join(workDir, 'unreadable.ts');
+      await writeFile(filePath, 'original', 'utf-8');
+      await chmod(filePath, 0o000);
+
+      try {
+        await expect(manager.capture(session, filePath)).rejects.toThrow(
+          'Unable to capture original file',
+        );
+        await expect(manager.getContent(session, filePath)).rejects.toThrow(
+          'No baseline exists',
+        );
+      } finally {
+        await chmod(filePath, 0o600);
+      }
+    },
+  );
+
+  it('rejects a directory path without recording an empty baseline', async () => {
+    const session = createSession();
+    const directoryPath = join(workDir, 'not-a-file');
+    await mkdir(directoryPath);
+
+    await expect(manager.capture(session, directoryPath)).rejects.toThrow(
+      'is not a regular file',
+    );
+    await expect(manager.getContent(session, directoryPath)).rejects.toThrow(
+      'No baseline exists',
+    );
+  });
+
+  it('throws a clear error when requested baseline content does not exist', async () => {
+    await expect(manager.getContent(createSession(), 'missing.ts')).rejects.toThrow(
+      'No baseline exists for "missing.ts"',
+    );
+  });
+
+  it('rejects a relative path that escapes the workspace', async () => {
+    await expect(manager.capture(createSession(), '../outside.ts')).rejects.toThrow(
+      'is outside workspace',
+    );
+  });
+
+  it('normalizes Windows drive case for an in-workspace baseline', async () => {
+    const session: BaselineSession = { id: 'ses-windows', workDir: 'C:\\Workspace' };
+    await manager.capture(session, 'C:\\Workspace\\src\\new.ts');
+
+    await expect(
+      manager.getContent(session, 'c:\\WORKSPACE\\SRC\\NEW.ts'),
+    ).resolves.toBe('');
+  });
+
+  it('rejects a Windows path on another drive', async () => {
+    const session: BaselineSession = { id: 'ses-windows', workDir: 'C:\\Workspace' };
+
+    await expect(manager.capture(session, 'D:\\Workspace\\file.ts')).rejects.toThrow(
+      'is outside workspace',
+    );
+  });
+
+  it('normalizes case differences in an in-workspace UNC path', async () => {
+    const session: BaselineSession = {
+      id: 'ses-unc',
+      workDir: '\\\\Server\\Share\\Workspace',
+    };
+    await manager.capture(session, '\\\\server\\share\\workspace\\src\\new.ts');
+
+    await expect(manager.getContent(session, 'src\\new.ts')).resolves.toBe('');
+  });
+
+  it('rejects a UNC path from another share', async () => {
+    const session: BaselineSession = {
+      id: 'ses-unc',
+      workDir: '\\\\Server\\Share\\Workspace',
+    };
+
+    await expect(
+      manager.capture(session, '\\\\Server\\OtherShare\\Workspace\\file.ts'),
+    ).rejects.toThrow('is outside workspace');
+  });
+
+  it('removes persisted originals when the session baseline is deleted', async () => {
+    const session = createSession();
+    const filePath = join(workDir, 'app.ts');
+    await writeFile(filePath, 'original', 'utf-8');
+    await manager.capture(session, filePath);
+
+    await manager.deleteSession(session.id);
+
+    await expect(manager.getContent(session, filePath)).rejects.toThrow('No baseline exists');
+  });
+});
+
+function createSession(
+  id = 'ses-local',
+  metadata?: Readonly<Record<string, unknown>>,
+): BaselineSession {
+  return { id, workDir, metadata };
+}
+
+async function createLegacySession(
+  content: string,
+  id = 'ses-legacy',
+): Promise<{
+  session: BaselineSession;
+  legacySessionDir: string;
+  baselinePath: string;
+}> {
+  const legacySessionDir = join(root, `legacy-${id}`);
+  const baselinePath = join(legacySessionDir, 'baseline', 'app.ts');
+  await mkdir(join(legacySessionDir, 'baseline'), { recursive: true });
+  await writeFile(baselinePath, content, 'utf-8');
+  return {
+    session: createSession(id, { kimi_cli_source_path: legacySessionDir }),
+    legacySessionDir,
+    baselinePath,
+  };
+}

apps/vscode/test/bridge-handler.test.ts

@@ -0,0 +1,695 @@
+/**
+ * Scenario: untrusted Webview RPC messages cross into the VS Code extension host.
+ * Responsibilities: validate requests, preserve public model metadata, omit private paths, and recover visibly from persisted state errors.
+ * Wiring: the real BridgeHandler and handlers; VS Code and the public Node SDK harness boundary are replaced.
+ * Run: pnpm --filter kimi-code exec vitest run --config vitest.config.ts test/bridge-handler.test.ts
+ */
+import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from "vitest";
+import type * as vscode from "vscode";
+
+import { Methods } from "../shared/bridge";
+import { BridgeHandler } from "../src/bridge-handler";
+
+const host = vi.hoisted(() => {
+  const watcher = {
+    onDidChange: vi.fn(),
+    onDidCreate: vi.fn(),
+    onDidDelete: vi.fn(),
+    dispose: vi.fn(),
+  };
+  const harness = {
+    homeDir: "/tmp/kimi-code-test-home",
+    close: vi.fn(async () => undefined),
+    getConfig: vi.fn(),
+    setConfig: vi.fn(async () => undefined),
+    listSessions: vi.fn(async () => []),
+    resumeSession: vi.fn(),
+    forkSession: vi.fn(),
+    deleteSession: vi.fn(async () => undefined),
+  };
+  const showWarningMessage = vi.fn(async () => undefined as string | undefined);
+
+  class Uri {
+    readonly scheme = "file";
+    readonly authority = "";
+    readonly path: string;
+
+    constructor(readonly fsPath: string) {
+      this.path = fsPath;
+    }
+
+    static joinPath(base: Uri, ...segments: string[]): Uri {
+      return new Uri(join(base.fsPath, ...segments));
+    }
+
+    toString(): string {
+      return `file://${this.path}`;
+    }
+  }
+
+  return {
+    Uri,
+    watcher,
+    harness,
+    createKimiHarness: vi.fn(() => harness),
+    showWarningMessage,
+    workspaceFolders: [] as Array<{ uri: Uri }>,
+  };
+});
+
+vi.mock("vscode", () => ({
+  Uri: host.Uri,
+  workspace: {
+    get workspaceFolders() {
+      return host.workspaceFolders;
+    },
+    getConfiguration: () => ({ get: (_key: string, fallback: unknown) => fallback }),
+    createFileSystemWatcher: () => host.watcher,
+    textDocuments: [],
+  },
+  window: { showWarningMessage: host.showWarningMessage },
+}));
+
+vi.mock("@moonshot-ai/kimi-code-sdk", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@moonshot-ai/kimi-code-sdk")>();
+  return {
+    ...original,
+    createKimiHarness: () => host.createKimiHarness(),
+  };
+});
+
+let bridge: BridgeHandler;
+let root: string;
+let showLogs: Mock<() => void>;
+let writeLog: Mock<(message: string) => void>;
+let workspaceState: { get: ReturnType<typeof vi.fn>; update: ReturnType<typeof vi.fn> };
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), "kimi-vscode-bridge-"));
+  host.workspaceFolders.splice(0, host.workspaceFolders.length, { uri: new host.Uri(root) });
+  showLogs = vi.fn();
+  writeLog = vi.fn();
+  host.harness.resumeSession.mockReset();
+  host.harness.getConfig.mockReset();
+  host.harness.getConfig.mockResolvedValue({ models: {} });
+  host.createKimiHarness.mockImplementation(() => host.harness);
+  host.showWarningMessage.mockReset();
+  host.showWarningMessage.mockResolvedValue(undefined);
+  workspaceState = { get: vi.fn((_key, fallback) => fallback), update: vi.fn() };
+  bridge = new BridgeHandler(
+    vi.fn(),
+    workspaceState as unknown as vscode.Memento,
+    join(root, "global-storage"),
+    vi.fn(),
+    showLogs,
+    writeLog,
+  );
+});
+
+afterEach(async () => {
+  await bridge.dispose();
+  vi.clearAllMocks();
+  vi.unstubAllEnvs();
+  await rm(root, { recursive: true, force: true });
+});
+
+describe("Engine startup", () => {
+  function constructBridge(): void {
+    new BridgeHandler(
+      vi.fn(),
+      workspaceState as unknown as vscode.Memento,
+      join(root, "global-storage-2"),
+      vi.fn(),
+      showLogs,
+      writeLog,
+    );
+  }
+
+  it("surfaces the failure when the engine cannot start", () => {
+    host.createKimiHarness.mockImplementationOnce(() => {
+      throw new Error("engine boom");
+    });
+
+    expect(constructBridge).toThrow(/^Failed to start the Kimi engine: engine boom\.$/);
+  });
+});
+
+describe("Webview RPC boundary (validates requests before host dispatch)", () => {
+  it("returns a readable error when the envelope is not a plain object", async () => {
+    const result = await bridge.handle([], "view-1");
+
+    expect(result).toEqual({
+      id: "",
+      error: "Invalid bridge request: expected a plain object.",
+    });
+  });
+
+  it("does not execute a known handler when the request id is blank", async () => {
+    const result = await bridge.handle({ id: " ", method: Methods.ShowLogs }, "view-1");
+
+    expect(result).toEqual({
+      id: "",
+      error: "Invalid bridge request: id must be a non-empty string.",
+    });
+    expect(showLogs).not.toHaveBeenCalled();
+  });
+
+  it("reports aborted: false when the view has no runtime to cancel", async () => {
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.AbortChat }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", result: { aborted: false } });
+  });
+
+  it("cancels the view's runtime when aborting a chat", async () => {
+    const cancel = vi.fn(async () => undefined);
+    vi.spyOn(bridge.runtime, "getSessionForView").mockReturnValue({ cancel } as never);
+
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.AbortChat }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", result: { aborted: true } });
+    expect(cancel).toHaveBeenCalledOnce();
+  });
+
+  it.each(["missingMethod", "toString", "constructor", "__proto__"])(
+    "does not dispatch the unknown or prototype method %s",
+    async (method) => {
+      const result = await bridge.handle({ id: "rpc-1", method }, "view-1");
+
+      expect(result).toEqual({ id: "rpc-1", error: `Unknown bridge method: ${method}` });
+      expect(showLogs).not.toHaveBeenCalled();
+    },
+  );
+
+  it("does not execute a no-params handler when a payload is supplied", async () => {
+    const result = await bridge.handle(
+      { id: "rpc-1", method: Methods.ShowLogs, params: {} },
+      "view-1",
+    );
+
+    expect(result).toEqual({
+      id: "rpc-1",
+      error: "Invalid bridge params for method: showLogs",
+    });
+    expect(showLogs).not.toHaveBeenCalled();
+  });
+
+  it("does not execute an object-payload handler when a required field has the wrong type", async () => {
+    const result = await bridge.handle(
+      { id: "rpc-1", method: Methods.AddInputHistory, params: { text: 42 } },
+      "view-1",
+    );
+
+    expect(result).toEqual({
+      id: "rpc-1",
+      error: "Invalid bridge params for method: addInputHistory",
+    });
+    expect(workspaceState.update).not.toHaveBeenCalled();
+  });
+
+  it("dispatches a valid request through the existing bridge surface", async () => {
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.ShowLogs }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", result: { ok: true } });
+    expect(showLogs).toHaveBeenCalledOnce();
+  });
+
+  it("keeps provider identity when configured models share a display name", async () => {
+    host.harness.getConfig.mockResolvedValueOnce({
+      defaultModel: "openai/shared",
+      models: {
+        "openai/shared": {
+          provider: "openai",
+          model: "shared",
+          displayName: "Shared",
+          maxContextSize: 128_000,
+        },
+        "proxy/shared": {
+          provider: "company-proxy",
+          model: "shared",
+          displayName: "Shared",
+          maxContextSize: 128_000,
+        },
+      },
+    });
+
+    const result = await bridge.handle({ id: "rpc-models", method: Methods.GetModels }, "view-1");
+
+    expect(result).toMatchObject({
+      id: "rpc-models",
+      result: {
+        defaultModel: "openai/shared",
+        models: [
+          { id: "openai/shared", name: "Shared", provider: "openai" },
+          { id: "proxy/shared", name: "Shared", provider: "company-proxy" },
+        ],
+      },
+    });
+  });
+
+  it("preserves adaptive thinking metadata in the Webview model list", async () => {
+    host.harness.getConfig.mockResolvedValueOnce({
+      defaultModel: "anthropic/claude",
+      models: {
+        "anthropic/claude": {
+          provider: "anthropic",
+          model: "claude-sonnet",
+          maxContextSize: 200_000,
+          adaptiveThinking: true,
+        },
+      },
+    });
+
+    const result = await bridge.handle({ id: "rpc-models", method: Methods.GetModels }, "view-1");
+
+    expect(result).toMatchObject({
+      result: {
+        models: [{
+          id: "anthropic/claude",
+          name: "claude-sonnet",
+          provider: "anthropic",
+          adaptive_thinking: true,
+        }],
+      },
+    });
+  });
+
+  it("resolves the fallback-profile default effort with the provider type", async () => {
+    // claude-latest declares efforts but no default; the Anthropic fallback
+    // profile only matches when the provider type joins the resolution.
+    host.harness.getConfig.mockResolvedValueOnce({
+      defaultModel: "custom/claude",
+      providers: {
+        custom: { type: "anthropic", apiKey: "test-key" },
+      },
+      models: {
+        "custom/claude": {
+          provider: "custom",
+          model: "claude-latest",
+          supportEfforts: ["low", "medium", "high", "xhigh", "max"],
+        },
+      },
+    });
+
+    const result = await bridge.handle({ id: "rpc-models", method: Methods.GetModels }, "view-1");
+
+    expect(result).toMatchObject({
+      result: {
+        models: [{
+          id: "custom/claude",
+          support_efforts: ["low", "medium", "high", "xhigh", "max"],
+          default_effort: "high",
+        }],
+      },
+    });
+  });
+
+  it("does not expose the session storage path when listing sessions", async () => {
+    host.harness.listSessions.mockResolvedValueOnce([
+      {
+        id: "session-1",
+        workDir: root,
+        sessionDir: "/private/kimi/sessions/session-1",
+        updatedAt: 123,
+        title: "Visible title",
+      },
+    ] as never);
+
+    const result = await bridge.handle(
+      { id: "rpc-1", method: Methods.GetKimiSessions },
+      "view-1",
+    );
+
+    expect(result).toEqual({
+      id: "rpc-1",
+      result: [{ id: "session-1", workDir: root, updatedAt: 123, brief: "Visible title" }],
+    });
+    expect(JSON.stringify(result)).not.toContain("/private/kimi/sessions");
+  });
+
+  it("does not expose the session storage path when forking a session", async () => {
+    const source = {
+      id: "session-1",
+      workDir: root,
+      sessionDir: "/private/kimi/sessions/session-1",
+      updatedAt: 123,
+    };
+    const target = {
+      id: "session-2",
+      workDir: root,
+      sessionDir: "/private/kimi/sessions/session-2",
+      updatedAt: 124,
+    };
+    host.harness.listSessions.mockResolvedValueOnce([source] as never);
+    host.harness.forkSession.mockResolvedValueOnce({ summary: target, close: vi.fn() });
+
+    const result = await bridge.handle(
+      {
+        id: "rpc-1",
+        method: Methods.ForkKimiSession,
+        params: { sessionId: "session-1", turnIndex: 0 },
+      },
+      "view-1",
+    );
+
+    expect(result).toEqual({ id: "rpc-1", result: { sessionId: "session-2" } });
+    expect(JSON.stringify(result)).not.toContain("/private/kimi/sessions");
+  });
+
+  it("runs a fork through the active session cancellation boundary", async () => {
+    const source = {
+      id: "session-1",
+      workDir: root,
+      sessionDir: "/private/kimi/sessions/session-1",
+      updatedAt: 123,
+    };
+    const target = {
+      id: "session-2",
+      workDir: root,
+      sessionDir: "/private/kimi/sessions/session-2",
+      updatedAt: 124,
+    };
+    const runExclusiveAfterCancelling = vi.fn(async <T>(action: () => Promise<T>) => action());
+    vi.spyOn(bridge.runtime, "getSession").mockReturnValue({
+      runExclusiveAfterCancelling,
+    } as never);
+    host.harness.listSessions.mockResolvedValueOnce([source] as never);
+    host.harness.forkSession.mockResolvedValueOnce({ summary: target, close: vi.fn() });
+
+    const result = await bridge.handle(
+      {
+        id: "rpc-1",
+        method: Methods.ForkKimiSession,
+        params: { sessionId: "session-1", turnIndex: 0 },
+      },
+      "view-1",
+    );
+
+    expect(result).toEqual({ id: "rpc-1", result: { sessionId: "session-2" } });
+    expect(runExclusiveAfterCancelling).toHaveBeenCalledOnce();
+    expect(host.harness.forkSession).toHaveBeenCalledOnce();
+  });
+
+  it("closes and removes a fork when its baseline cannot be materialized", async () => {
+    const source = { id: "session-1", workDir: root, updatedAt: 123 };
+    const target = { id: "session-2", workDir: root, updatedAt: 124 };
+    const close = vi.fn(async () => undefined);
+    host.harness.listSessions.mockResolvedValueOnce([source] as never);
+    host.harness.forkSession.mockResolvedValueOnce({ summary: target, close });
+    vi.spyOn(bridge.baselineManager, "materializeToFork").mockRejectedValueOnce(
+      new Error("baseline unavailable"),
+    );
+    const deleteBaseline = vi.spyOn(bridge.baselineManager, "deleteSession");
+
+    const result = await bridge.handle(
+      {
+        id: "rpc-1",
+        method: Methods.ForkKimiSession,
+        params: { sessionId: "session-1", turnIndex: 0 },
+      },
+      "view-1",
+    );
+
+    expect(result).toEqual({ id: "rpc-1", error: "baseline unavailable" });
+    expect(close).toHaveBeenCalledOnce();
+    expect(host.harness.deleteSession).toHaveBeenCalledWith("session-2");
+    expect(deleteBaseline).toHaveBeenCalledWith("session-2");
+  });
+
+  it("keeps conversation history available when its baseline snapshot disappears", async () => {
+    const session = createResumedSession("session-1", root);
+    host.harness.resumeSession.mockResolvedValueOnce(session as never);
+    host.showWarningMessage.mockResolvedValueOnce("Show Logs");
+    const sourcePath = join(root, "app.ts");
+    await writeFile(sourcePath, "original\n", "utf-8");
+    await bridge.baselineManager.capture(session.summary, sourcePath);
+    const baselinesRoot = join(root, "global-storage", "baselines");
+    const [homeDirectory] = await readdir(baselinesRoot);
+    const [sessionDirectory] = await readdir(join(baselinesRoot, homeDirectory!));
+    const snapshotsDirectory = join(
+      baselinesRoot,
+      homeDirectory!,
+      sessionDirectory!,
+      "snapshots",
+    );
+    const [snapshot] = await readdir(snapshotsDirectory);
+    await rm(join(snapshotsDirectory, snapshot!));
+
+    const result = await bridge.handle(
+      {
+        id: "rpc-1",
+        method: Methods.LoadKimiSessionHistory,
+        params: { kimiSessionId: "session-1" },
+      },
+      "view-1",
+    );
+
+    expect(result).toEqual({
+      id: "rpc-1",
+      result: expect.arrayContaining([
+        expect.objectContaining({ type: "StatusUpdate", _sessionId: "session-1" }),
+      ]),
+    });
+    expect(writeLog).toHaveBeenCalledWith(
+      expect.stringMatching(/Unable to restore session file changes.*Unable to read baseline snapshot/),
+    );
+    await vi.waitFor(() => expect(showLogs).toHaveBeenCalledOnce());
+  });
+
+  it("returns a readable error when persisted session state is corrupt without wedging the bridge", async () => {
+    host.harness.resumeSession.mockRejectedValueOnce(
+      new Error("Session state is invalid JSON at line 4"),
+    );
+
+    const failed = await bridge.handle(
+      {
+        id: "rpc-1",
+        method: Methods.LoadKimiSessionHistory,
+        params: { kimiSessionId: "session-1" },
+      },
+      "view-1",
+    );
+    const next = await bridge.handle({ id: "rpc-2", method: Methods.ShowLogs }, "view-1");
+
+    expect(failed).toEqual({
+      id: "rpc-1",
+      error: "Session state is invalid JSON at line 4",
+    });
+    expect(writeLog).toHaveBeenCalledWith(
+      expect.stringContaining("Session state is invalid JSON at line 4"),
+    );
+    expect(next).toEqual({ id: "rpc-2", result: { ok: true } });
+  });
+});
+
+describe("Registered working directories", () => {
+  it("lists the workspace root when there is no session history", async () => {
+    host.harness.listSessions.mockResolvedValueOnce([] as never);
+
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.GetRegisteredWorkDirs }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", result: [root] });
+  });
+
+  it("keeps the selected working directory visible without session history", async () => {
+    const sub = join(root, "packages", "demo");
+    await mkdir(sub, { recursive: true });
+    host.harness.listSessions.mockResolvedValue([] as never);
+
+    await bridge.handle({ id: "rpc-1", method: Methods.SetWorkDir, params: { workDir: sub } }, "view-1");
+    const result = await bridge.handle({ id: "rpc-2", method: Methods.GetRegisteredWorkDirs }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-2", result: [root, sub].toSorted() });
+  });
+
+  it("merges session-history directories and hides directories outside the workspace", async () => {
+    const inside = join(root, "nested");
+    host.harness.listSessions.mockResolvedValueOnce([
+      { id: "s-1", workDir: inside },
+      { id: "s-2", workDir: "/private/outside" },
+      { id: "s-3", workDir: root },
+    ] as never);
+
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.GetRegisteredWorkDirs }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", result: [inside, root].toSorted() });
+    expect(JSON.stringify(result)).not.toContain("/private/outside");
+  });
+});
+
+describe("Webview config saves (thinking effort persistence parity with the TUI)", () => {
+  const effortModel = {
+    provider: "managed:kimi-code",
+    model: "reasoning",
+    supportEfforts: ["low", "high", "max"],
+    defaultEffort: "high",
+  };
+
+  function mockConfig(thinking?: { enabled: boolean; effort?: string }) {
+    host.harness.getConfig.mockResolvedValue({
+      defaultModel: "kimi/reasoning",
+      thinking,
+      models: { "kimi/reasoning": effortModel },
+    } as never);
+  }
+
+  it("persists a non-top effort as the global default", async () => {
+    mockConfig();
+
+    const result = await bridge.handle(
+      { id: "rpc-1", method: Methods.SaveConfig, params: { model: "kimi/reasoning", thinking: true, effort: "high" } },
+      "view-1",
+    );
+
+    expect(result).toEqual({ id: "rpc-1", result: { ok: true } });
+    expect(host.harness.setConfig).toHaveBeenCalledWith({
+      defaultModel: "kimi/reasoning",
+      thinking: { enabled: true, effort: "high" },
+    });
+  });
+
+  it("keeps a pick above the model's delivered default session-only", async () => {
+    mockConfig();
+
+    await bridge.handle(
+      { id: "rpc-1", method: Methods.SaveConfig, params: { model: "kimi/reasoning", thinking: true, effort: "max" } },
+      "view-1",
+    );
+
+    expect(host.harness.setConfig).toHaveBeenCalledWith({
+      defaultModel: "kimi/reasoning",
+      thinking: { enabled: true },
+    });
+  });
+
+  it("persists the top tier when the model's delivered default is the top tier", async () => {
+    host.harness.getConfig.mockResolvedValue({
+      defaultModel: "kimi/reasoning",
+      models: { "kimi/reasoning": { ...effortModel, defaultEffort: "max" } },
+    } as never);
+
+    await bridge.handle(
+      { id: "rpc-1", method: Methods.SaveConfig, params: { model: "kimi/reasoning", thinking: true, effort: "max" } },
+      "view-1",
+    );
+
+    expect(host.harness.setConfig).toHaveBeenCalledWith({
+      defaultModel: "kimi/reasoning",
+      thinking: { enabled: true, effort: "max" },
+    });
+  });
+
+  it("keeps an xhigh pick session-only when the default comes from the Anthropic profile inference", async () => {
+    // claude-opus-4-7 declares no efforts; the profile inference supplies
+    // [low, medium, high, xhigh, max] and resolves the default to "high".
+    host.harness.getConfig.mockResolvedValue({
+      defaultModel: "custom/claude",
+      models: { "custom/claude": { provider: "custom", model: "claude-opus-4-7" } },
+    } as never);
+
+    await bridge.handle(
+      { id: "rpc-1", method: Methods.SaveConfig, params: { model: "custom/claude", thinking: true, effort: "xhigh" } },
+      "view-1",
+    );
+
+    expect(host.harness.setConfig).toHaveBeenCalledWith({
+      defaultModel: "custom/claude",
+      thinking: { enabled: true },
+    });
+  });
+
+  it("persists the concrete effort when the model's levels are unknown", async () => {
+    host.harness.getConfig.mockResolvedValue({ defaultModel: "other/model", models: {} });
+
+    await bridge.handle(
+      { id: "rpc-1", method: Methods.SaveConfig, params: { model: "custom/model", thinking: true, effort: "max" } },
+      "view-1",
+    );
+
+    expect(host.harness.setConfig).toHaveBeenCalledWith({
+      defaultModel: "custom/model",
+      thinking: { enabled: true, effort: "max" },
+    });
+  });
+
+  it("leaves the stored effort alone when the pick re-confirms the active effort", async () => {
+    mockConfig({ enabled: false, effort: "low" });
+
+    await bridge.handle(
+      { id: "rpc-1", method: Methods.SaveConfig, params: { model: "kimi/reasoning", thinking: true, effort: "high", effortChanged: false } },
+      "view-1",
+    );
+
+    expect(host.harness.setConfig).toHaveBeenCalledWith({
+      defaultModel: "kimi/reasoning",
+      thinking: { enabled: true },
+    });
+  });
+
+  it("skips the config write entirely when nothing changed", async () => {
+    mockConfig({ enabled: true, effort: "high" });
+
+    await bridge.handle(
+      { id: "rpc-1", method: Methods.SaveConfig, params: { model: "kimi/reasoning", thinking: true, effort: "high" } },
+      "view-1",
+    );
+
+    expect(host.harness.setConfig).not.toHaveBeenCalled();
+  });
+});
+
+function createResumedSession(id: string, workDir: string) {
+  const close = vi.fn(async () => undefined);
+  const summary = {
+    id,
+    workDir,
+    sessionDir: join("/private/kimi/sessions", id),
+    createdAt: 1,
+    updatedAt: 2,
+    metadata: { vscode_legacy_approval: { yolo: false, afk: false } },
+  };
+  return {
+    id,
+    workDir,
+    summary,
+    close,
+    getResumeState: () => ({
+      sessionMetadata: { agents: {} },
+      agents: {
+        main: {
+          type: "main",
+          config: {
+            cwd: workDir,
+            modelAlias: "test-model",
+            modelCapabilities: {
+              image_in: false,
+              video_in: false,
+              audio_in: false,
+              thinking: false,
+              tool_use: true,
+              max_context_tokens: 128_000,
+            },
+            thinkingEffort: "off",
+            systemPrompt: "",
+          },
+          context: { history: [], tokenCount: 0 },
+          replay: [],
+          permission: { mode: "manual", rules: [] },
+          plan: null,
+          usage: {},
+          tools: [],
+          background: [],
+        },
+      },
+    }),
+    getStatus: async () => ({ permission: "manual" }),
+    setPermission: async () => undefined,
+    updateMetadata: async () => undefined,
+    setApprovalHandler: () => undefined,
+    setQuestionHandler: () => undefined,
+    onEvent: () => () => undefined,
+  };
+}