diff --git a/.agents/skills/agent-core-dev/errors.md b/.agents/skills/agent-core-dev/errors.md
index 254cec98d..e0af433ce 100644
--- a/.agents/skills/agent-core-dev/errors.md
+++ b/.agents/skills/agent-core-dev/errors.md
@@ -7,7 +7,7 @@ Base classes and serialization are **centralized** in `_base/errors`; error **co
 ## Where things live
 
 - `src/_base/errors/errors.ts`: base classes — `Error2`, `ExpectedError`, `ErrorNoTelemetry`, `BugIndicatingError`, `NotImplementedError`, plus `isError2` and `unwrapErrorCause`.
-- `src/_base/errors/codes.ts`: the `ErrorDomain` contract, the `ErrorCode` type (aliased to the protocol's `KimiErrorCode`), the registry (`registerErrorDomain` / `errorInfo` / `isErrorCode`), and `CoreErrors` (`internal`, `not_implemented`).
+- `src/_base/errors/codes.ts`: the `ErrorDomain` contract, the registry (`registerErrorDomain` / `errorInfo` / `isErrorCode`), and `CoreErrors` (`internal`, `not_implemented`). The `ErrorCode` union type is derived by `#/errors` from the aggregated domain definitions.
 - `src/_base/errors/serialize.ts`: `ErrorPayload`, `isCodedError`, `toErrorPayload`, `fromErrorPayload`. Wire-facing names (`KimiErrorPayload`, `toKimiErrorPayload`) mirror the protocol and are kept as-is.
 - `src/_base/errors/unexpectedError.ts`: `onUnexpectedError` / `setUnexpectedErrorHandler` (global handler).
 - `src/<domain>/errors.ts`: the domain's `XxxErrors` descriptor (codes + retryable list + per-code info overrides), self-registered on import.
@@ -17,7 +17,7 @@ Base classes and serialization are **centralized** in `_base/errors`; error **co
 
 - **Throw a coded error, not a bare string.** `throw new Error2(ErrorCodes.X, …)`. Bare `new Error` only for unreachable guards; `BugIndicatingError` for caller bugs; `NotImplementedError('feature')` for stubs.
 - **Define codes in the owning domain**, in `<domain>/errors.ts` as an `XxxErrors` descriptor (`satisfies ErrorDomain` + `registerErrorDomain`), then wire it into the facade. Never add domain codes to `_base/errors`.
-- **One `code` per failure mode.** Codes read `domain.reason`. The valid code strings are fixed by the protocol (`KimiErrorCode` in `packages/protocol/src/events.ts`): **add new codes to the protocol first**. Renaming/removing a code is a major.
+- **One `code` per failure mode.** Codes read `domain.reason`. The valid code strings are derived from the aggregated domain definitions (`ErrorCode` in `#/errors` is computed from the `ErrorCodes` aggregate): **add new codes to the owning domain's `errors.ts`** — registration throws on cross-domain collisions. Renaming/removing a code is a major.
 - **Translate foreign errors at the boundary.** Provider/HTTP, fs, MCP errors are re-thrown as the owning domain's coded error. `_base/errors` never imports a business domain.
 - **Translation is idempotent and cause-preserving.** Translators (`toHostFsError`, `toStorageIoError`) pass through an already-translated error and always keep the original as `cause`.
 - **`details` is structured and JSON-serializable; `message` is a short human sentence.** Paths/errnos/scope/key go into `details`, not the message.
@@ -35,6 +35,6 @@ Base classes and serialization are **centralized** in `_base/errors`; error **co
 ## Red lines (this topic)
 
 - Throw a coded error with a `code`, not a bare string (except unreachable guards / `BugIndicatingError` / `NotImplementedError`).
-- Codes live in the owning domain's `errors.ts` and self-register; new codes land in the protocol first.
+- Codes live in the owning domain's `errors.ts` and self-register; new codes land in the owning domain first.
 - Translate foreign errors at the owning domain's boundary, idempotently, with `cause` and structured `details`; `_base/errors` never imports a business domain.
 - Branch on `code` across the wire, never `instanceof`.
diff --git a/.agents/skills/agent-core-dev/server-align.md b/.agents/skills/agent-core-dev/server-align.md
index f347005b4..82b9188f1 100644
--- a/.agents/skills/agent-core-dev/server-align.md
+++ b/.agents/skills/agent-core-dev/server-align.md
@@ -38,20 +38,20 @@ Pick surface → Read the v1 route (if any) → Reuse / add the protocol schema
 
 Apply the decision above. For a v1-matched endpoint, the **spec** is the protocol schema plus the existing mirror routes:
 
-- `packages/protocol/src/rest/<resource>.ts` — the wire schema you must match.
+- `packages/kap-server/src/protocol/rest-<resource>.ts` — the wire schema you must match.
 - `packages/kap-server/src/routes/<resource>.ts` — the file you are writing (create it if missing); sibling route files show the conventions.
 
 The protocol schema is the source of truth. Do not re-derive the wire shape from memory or from the v2 domain model.
 
 ### 2. Reuse (or add) the protocol schema
 
-The wire schema lives in **`@moonshot-ai/protocol`** under `packages/protocol/src/rest/<resource>.ts` (e.g. `promptSubmissionSchema`, `promptListResponseSchema`, `configResponseSchema`). Every `/api/v1` route in `packages/kap-server` imports from it — that single import is what guarantees the server speaks the same shape released clients expect.
+The wire schema lives in **`packages/kap-server/src/protocol`** under `rest-<resource>.ts` (e.g. `promptSubmissionSchema`, `promptListResponseSchema`, `configResponseSchema`) — or in the owning `agent-core-v2` domain contract when the engine's service speaks the shape. Every `/api/v1` route in `packages/kap-server` imports from it — that single import is what guarantees the server speaks the same shape released clients expect.
 
 Actions:
 
 - **Schema already in protocol** → import it in the server-v2 route and use it in `defineRoute` (`body`, `success.data`, error `dataSchema` / `detailsSchema`). Do **not** re-declare the schema inline in server-v2.
-- **Schema missing in protocol** → add it to `packages/protocol/src/rest/<resource>.ts` first, with a `rest-<resource>.test.ts`, then consume it from the route. The protocol package is the source of truth; server-v2 never owns a v1 wire schema locally.
-- **Schema exists but only v1 uses it** → move/keep it in protocol and import it into server-v2; do not fork a copy.
+- **Schema missing** → add it to `packages/kap-server/src/protocol/rest-<resource>.ts` first (or to the owning v2 domain contract if its service speaks the shape), then consume it from the route. The shared schema is the source of truth; server-v2 never re-declares a v1 wire schema inline.
+- **Schema exists but only v1 uses it** → keep it in `packages/kap-server/src/protocol` and import it into server-v2; do not fork a copy.
 
 #### Schema-fidelity rule (the hard rule)
 
@@ -59,7 +59,7 @@ For a `/api/v1` endpoint, the request and response schemas **must be the establi
 
 - ✅ **Adding** an optional field is allowed (`field: z.string().optional()`). Old clients ignore it; new clients may send it.
 - ❌ **Renaming** a field, **changing** its type, **tightening** its validation, or **changing its meaning** is a wire break — do not do it in a mirror route. If the v2 domain genuinely needs a different shape, that shape belongs on `/api/v2`, not on the `/api/v1` mirror.
-- ❌ Re-declaring the schema inline in server-v2 (even if it "looks identical") is forbidden — it drifts. One schema, one home: `packages/protocol`.
+- ❌ Re-declaring the schema inline in server-v2 (even if it "looks identical") is forbidden — it drifts. One schema, one home: the owning `agent-core-v2` domain contract or `packages/kap-server/src/protocol`.
 
 Self-check: "would a released v1 client get a byte-identical envelope from `packages/kap-server` for this request?" If you cannot answer yes from the shared schema, the route is wrong.
 
@@ -94,8 +94,8 @@ packages/agent-core-v2/src/<domain>Legacy/
 Skeleton (matches `prompt/`):
 
 ```ts
-// prompt.ts — contract shaped by @moonshot-ai/protocol
-import type { PromptSubmitResult, PromptSubmission } from '@moonshot-ai/protocol';
+// prompt.ts — contract shaped by the v1 wire schema (kap-server/src/protocol)
+import type { PromptSubmitResult, PromptSubmission } from '../../protocol/rest-prompt';
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 
 export interface IAgentPromptService {
@@ -128,7 +128,7 @@ Conventions:
 - **Header comment** must say it is an `L7 edge adapter` and name both the v1 contract it implements and the native v2 Service it leaves untouched (see `prompt.ts`).
 - **Scope** = the lifetime of the *legacy* state it holds (the `prompt` queue is per-agent → `LifecycleScope.Agent`). Apply [orient.md](orient.md) / [design.md](design.md) normally — a LegacyService is not exempt from scope rules.
 - **Delegate, do not duplicate** business logic. The LegacyService translates the v1 contract into native-Service calls and translates results back; the real work stays in the native Service.
-- **Contract types come from `@moonshot-ai/protocol`**, so the interface cannot drift from the wire shape.
+- **Contract types come from the v1 wire schema homes** (the owning v2 domain contract or `kap-server/src/protocol`), so the interface cannot drift from the wire shape.
 
 ### 4. Wire the route / actionMap entry
 
@@ -139,9 +139,9 @@ const route = defineRoute(
   {
     method: 'POST',
     path: '/sessions/{session_id}/prompts',
-    body: promptSubmissionSchema,                 // ← from @moonshot-ai/protocol
+    body: promptSubmissionSchema,                 // ← from kap-server/src/protocol
     params: sessionIdParamSchema,
-    success: { data: promptSubmitResultSchema },  // ← from @moonshot-ai/protocol
+    success: { data: promptSubmitResultSchema },  // ← from kap-server/src/protocol
     errors: {
       [ErrorCode.SESSION_NOT_FOUND]: {},
       [ErrorCode.SESSION_BUSY]: {},
@@ -169,7 +169,7 @@ app.post(route.path, route.options, route.handler);
 The route translates domain `KimiError` codes into protocol `ErrorCode` numbers. Two registries must stay in sync:
 
 - **Domain code** — register in `agent-core-v2/src/errors.ts` (`ErrorCodes`) and throw from the Service (errors.md). Co-located domain errors go in `<domain>Legacy/errors.ts` (e.g. `prompt.not_found`, `session.busy`).
-- **Wire code** — register the matching number in `packages/protocol/src/error-codes.ts` and reference it in the route's `errors` map and `sendMappedError`.
+- **Wire code** — register the matching number in `packages/kap-server/src/protocol/error-codes.ts` and reference it in the route's `errors` map and `sendMappedError`.
 
 ```ts
 function sendMappedError(reply, requestId, err) {
@@ -202,10 +202,10 @@ Where the route mirrors v1, the test is the regression guard for the schema-fide
 ### 7. Verify
 
 - `pnpm -C packages/kap-server test` — server routes green.
-- `pnpm -C packages/protocol test` — schema tests green (incl. any new `rest-*.test.ts`).
+- `pnpm -C packages/kap-server test` — server routes green (incl. any wire-schema guards).
 - `pnpm -C packages/agent-core-v2 test` — native + Legacy Service tests green.
 - `pnpm -C packages/agent-core-v2 run lint:domain` — a LegacyService is still inside the domain layers (edge adapter, L7); it must not pull business code into the edge or invert scope direction.
-- `pnpm -C packages/server-e2e ...` when a v1 parity scenario exists.
+- `pnpm -C packages/klient test` (optionally with `KIMI_SERVER_URL` for the live legacy suites) when a v1 parity scenario exists.
 
 ## Worked example — porting v1 `/sessions/:sid/prompts`
 
@@ -218,9 +218,9 @@ This is the reference alignment (commits `feat(server-v2): port v1 /sessions/:si
 - `/api/v2` keeps the native shape — `prompts:submit` / `steer` / `undo` / `clear` / `cancel` map to `IAgentRPCService` (a wire facade over the v2 turn driver) in `actionMap`. The native `IAgentPromptService` is untouched.
 - `/api/v1` gets an `AgentPromptLegacyService` (`prompt/`, `LifecycleScope.Agent`) that re-implements the v1 scheduler — queue, `prompt_id`, steer/abort, auto-start-next — **on top of** the native `IAgentPromptService`. The `/api/v1` routes consume the LegacyService.
 
-**The schema.** Both surfaces import `promptSubmissionSchema` / `promptSubmitResultSchema` / `promptListResponseSchema` / `promptSteerRequestSchema` / `promptSteerResultSchema` / `promptAbortResponseSchema` from `@moonshot-ai/protocol`. The `/api/v1` and `/api/v2` routes are therefore compatible with released clients by construction; the LegacyService projects v2 turn results back into those protocol shapes.
+**The schema.** Both surfaces import `promptSubmissionSchema` / `promptSubmitResultSchema` / `promptListResponseSchema` / `promptSteerRequestSchema` / `promptSteerResultSchema` / `promptAbortResponseSchema` from the shared v1 wire schemas (see `packages/kap-server/src/protocol`). The `/api/v1` and `/api/v2` routes are therefore compatible with released clients by construction; the LegacyService projects v2 turn results back into those protocol shapes.
 
-**The errors.** v1 codes (`prompt.not_found`, `session.busy`, `prompt.already_completed`) are registered in `agent-core-v2` (`prompt/errors.ts`) and in `packages/protocol` (`error-codes.ts`), then mapped in the route's `sendMappedError` — including the idempotent `prompt.already_completed` → `40903 { data: { aborted: false } }`.
+**The errors.** v1 codes (`prompt.not_found`, `session.busy`, `prompt.already_completed`) are registered in `agent-core-v2` (`prompt/errors.ts`) and in `packages/kap-server/src/protocol` (`error-codes.ts`), then mapped in the route's `sendMappedError` — including the idempotent `prompt.already_completed` → `40903 { data: { aborted: false } }`.
 
 **The lesson.** When the v1 contract and the v2 domain disagree, add an adapter (LegacyService) at the edge; do not let the wire contract leak into the native domain. The two surfaces share the protocol schema but not the Service.
 
@@ -230,21 +230,21 @@ Before submitting a server-align change:
 
 - [ ] Surface chosen deliberately: `/api/v1` mirror for a v1-matched endpoint, `/api/v2` for a new native capability (both if needed).
 - [ ] For a `/api/v1` mirror, the route matches the established v1 contract (protocol schema + sibling routes) path-for-path, verb-for-verb, action-for-action.
-- [ ] Request and response schemas come from `@moonshot-ai/protocol` (`packages/protocol/src/rest/<resource>.ts`); no inline re-declaration in server-v2.
+- [ ] Request and response schemas come from their owning home (the `agent-core-v2` domain contract or `packages/kap-server/src/protocol`); no inline re-declaration in server-v2.
 - [ ] Existing schema fields are unchanged in name, type, and semantics; only optional fields added (if any).
 - [ ] Native v2 Service left clean; v1-only behavior isolated in a `<domain>Legacy` / `I<Domain>LegacyService` edge adapter when the semantics diverge.
 - [ ] LegacyService registered with the correct `LifecycleScope` and a header comment naming it an L7 edge adapter + the native Service it preserves.
-- [ ] Domain error codes registered in `agent-core-v2`; wire codes registered in `packages/protocol`; route maps them in `sendMappedError`, matching v1's status codes and idempotent envelopes.
+- [ ] Domain error codes registered in `agent-core-v2`; wire codes registered in `packages/kap-server/src/protocol`; route maps them in `sendMappedError`, matching v1's status codes and idempotent envelopes.
 - [ ] Route resolves the scope from the URL by `accessor.get(IX)`; no cached scope; finishes before disposal.
-- [ ] Tests assert the wire envelope + protocol shape; schema tests in `packages/protocol` added/updated.
+- [ ] Tests assert the wire envelope + protocol shape; wire-shape guards added/updated where the route mirrors v1.
 - [ ] `lint:domain` passes; the LegacyService did not invert scope or domain direction.
 
 ## Red lines (this subskill)
 
-- One wire schema, one home: `packages/protocol`. Never re-declare a v1 wire schema inline in server-v2.
+- One wire schema, one home: the owning `agent-core-v2` domain contract or `packages/kap-server/src/protocol`. Never re-declare a v1 wire schema inline in server-v2.
 - A `/api/v1` mirror route must keep every existing schema field's name, type, and semantics; only optional additions are allowed. A different shape belongs on `/api/v2`, not on the mirror.
 - Do not distort the native v2 Service to satisfy a v1 quirk — add a `<domain>Legacy` edge adapter instead. The native Service serves the v2 architecture; the LegacyService serves the wire contract.
 - A LegacyService is still a v2 Service: it follows scope, domain-direction, and DI rules. "Edge adapter" describes its role, not an exemption.
-- The protocol schema (`packages/protocol/src/rest/<resource>.ts`) plus the existing mirror routes are the spec for a `/api/v1` route — match them; do not re-derive the wire shape from the v2 domain model or from memory.
-- Register every new error code in **both** `agent-core-v2` and `packages/protocol`; an unmapped code is a wire break.
+- The established wire schema (in its owning home — the `agent-core-v2` domain contract or `packages/kap-server/src/protocol`) plus the existing mirror routes are the spec for a `/api/v1` route — match them; do not re-derive the wire shape from the v2 domain model or from memory.
+- Register every new error code in **both** `agent-core-v2` and `packages/kap-server/src/protocol/error-codes.ts`; an unmapped code is a wire break.
 - Events stream over WS (`listen`), never over the REST mirror; do not invent REST polling for something v1 pushed as an event.
diff --git a/.changeset/README.md b/.changeset/README.md
index d20552ded..3afeb3bdf 100644
--- a/.changeset/README.md
+++ b/.changeset/README.md
@@ -24,7 +24,6 @@ All other workspace packages are private internal packages, are not published to
 - `@moonshot-ai/kosong`
 - `@moonshot-ai/migration-legacy`
 - `@moonshot-ai/protocol`
-- `@moonshot-ai/server-e2e`
 - `@moonshot-ai/vis`
 - `@moonshot-ai/vis-server`
 - `@moonshot-ai/vis-web`
diff --git a/.changeset/config.json b/.changeset/config.json
index 2320f45e3..0f9da8d75 100644
--- a/.changeset/config.json
+++ b/.changeset/config.json
@@ -7,7 +7,6 @@
   "baseBranch": "main",
   "updateInternalDependencies": "patch",
   "ignore": [
-    "@moonshot-ai/server-e2e",
     "@moonshot-ai/vis",
     "@moonshot-ai/vis-server",
     "@moonshot-ai/vis-web"
diff --git a/.changeset/debug-zip-timestamped-filename.md b/.changeset/debug-zip-timestamped-filename.md
new file mode 100644
index 000000000..3ddb2f955
--- /dev/null
+++ b/.changeset/debug-zip-timestamped-filename.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix `/export-debug-zip` and `kimi export` overwriting the previous ZIP archive when run repeatedly on the same session; the default export filename now includes a timestamp.
diff --git a/.changeset/record-unexecuted-tool-calls.md b/.changeset/record-unexecuted-tool-calls.md
new file mode 100644
index 000000000..b23bf49d3
--- /dev/null
+++ b/.changeset/record-unexecuted-tool-calls.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix repeated request rejections after an interrupted model response by recording tool calls that never ran and closing them with an interrupted result.
diff --git a/.changeset/secure-fetch-url-ssrf.md b/.changeset/secure-fetch-url-ssrf.md
new file mode 100644
index 000000000..eba3c7622
--- /dev/null
+++ b/.changeset/secure-fetch-url-ssrf.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix the built-in URL fetch tool's network safeguards: crafted domains and redirect chains can no longer reach loopback or internal network services.
diff --git a/.changeset/web-drop-workspace-git-badges.md b/.changeset/web-drop-workspace-git-badges.md
new file mode 100644
index 000000000..49c42059d
--- /dev/null
+++ b/.changeset/web-drop-workspace-git-badges.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+web: Remove per-workspace git repo badges and branch labels; branch, PR, and diff status remain shown for the active session.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 99d74a539..3ff91c303 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,6 +28,48 @@ jobs:
       - name: Smoke test CLI bundle
         run: pnpm -C apps/kimi-code run smoke
 
+  vscode-vsix-package:
+    name: VSIX package audit (${{ matrix.target }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: all
+          - os: macos-latest
+            target: darwin-arm64
+          - os: windows-latest
+            target: win32-x64
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version-file: .nvmrc
+          cache: pnpm
+
+      - run: pnpm install --frozen-lockfile
+      - name: Build and audit target VSIX
+        run: pnpm --filter kimi-code run package:platform -- --target "${{ matrix.target }}"
+      - name: Run installed VSIX Extension Host smoke (Linux)
+        if: runner.os == 'Linux'
+        run: xvfb-run -a pnpm --filter kimi-code run test:extension-host -- --version 1.100.0
+      - name: Run installed VSIX Extension Host smoke on stable (Linux)
+        if: runner.os == 'Linux'
+        run: xvfb-run -a pnpm --filter kimi-code run test:extension-host -- --version stable
+      - name: Run installed VSIX Extension Host smoke
+        if: runner.os != 'Linux'
+        run: pnpm --filter kimi-code run test:extension-host -- --version 1.100.0
+      - uses: actions/upload-artifact@v4
+        with:
+          name: vscode-vsix-${{ matrix.target }}
+          path: apps/vscode/artifacts/vsix/*.vsix
+          if-no-files-found: error
+
   test:
     runs-on: ubuntu-latest
     strategy:
@@ -125,6 +167,8 @@ jobs:
             echo "Typechecking ${config}"
             pnpm dlx --package @typescript/native-preview@beta tsgo -p "${config}" --noEmit
           done
+      - name: Typecheck VS Code extension
+        run: pnpm --filter kimi-code run typecheck
       - name: Typecheck kimi-web (vue-tsc)
         run: pnpm --filter @moonshot-ai/kimi-web run typecheck
       - name: Typecheck vis-server
diff --git a/.gitignore b/.gitignore
index 8d73a08af..1c3bc6f22 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,6 +20,9 @@ plugins/cdn/
 .kimi-code/local.toml
 .kimi-sandbox/
 .vscode/
+!apps/vscode/.vscode/
+!apps/vscode/.vscode/*.json
+apps/vscode/artifacts/
 
 Dockerfile
 docker-compose.yml
diff --git a/AGENTS.md b/AGENTS.md
index 2a822e51f..da149b954 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,7 +24,7 @@ This is a TypeScript monorepo built for agent-assisted development. Keep the roo
 - `packages/oauth`: Kimi OAuth and managed auth utilities.
 - `packages/telemetry`: shared client-side telemetry infrastructure.
 - `packages/kap-server`: the Kimi Code server, backed by the DI × Scope agent engine (`@moonshot-ai/agent-core-v2`). Exposes sessions over REST + WebSocket (`/api/v1` and the native `/api/v2` RPC surface); bootstrapped from `src/start.ts` and consumed by `apps/kimi-code`.
-- `packages/server-e2e`: live e2e tests and scenarios against a running server (`KIMI_SERVER_URL`, default `http://127.0.0.1:58627`). See `packages/server-e2e/AGENTS.md`.
+- `packages/klient`: the client SDK — a contract-driven facade over agent-core-v2 with aggregated `global.*` / `session(id).*` / `agent(id).*` methods, zod validation on every call, and klient-level typed event forwarding. Transport is chosen once at creation via subpath entry (`@moonshot-ai/klient/http|ipc|memory`); all three return the same `Klient`. The package also hosts the e2e suites: dual-backend session/agent suites (`test/e2e/dual/`, in-memory + in-process server), `/api/v2` wire tests (`test/e2e/v2/`), the legacy `/api/v1` live suites (`test/e2e/legacy/`), and the docker e2e runner (`pnpm --filter @moonshot-ai/klient docker:e2e`). See `packages/klient/AGENTS.md`.
 
 ## Environment Requirements
 
diff --git a/apps/kimi-code/CHANGELOG.md b/apps/kimi-code/CHANGELOG.md
index 8361900a6..b54a7b4e0 100644
--- a/apps/kimi-code/CHANGELOG.md
+++ b/apps/kimi-code/CHANGELOG.md
@@ -1,5 +1,151 @@
 # @moonshot-ai/kimi-code
 
+## 0.26.0
+
+### Minor Changes
+
+- [#1776](https://github.com/MoonshotAI/kimi-code/pull/1776) [`ffaf0b9`](https://github.com/MoonshotAI/kimi-code/commit/ffaf0b98ca76bb90ba9c989256441dceb468d85f) Thanks [@sailist](https://github.com/sailist)! - Expand the coder subagent tool set to include background tasks, todo lists, plan mode, skill invocation, and nested agents, mirroring the main agent's capabilities; a subagent run also waits for its background tasks to settle before reporting completion. Applies automatically to coder subagents launched through the Agent tool.
+
+### Patch Changes
+
+- [#1771](https://github.com/MoonshotAI/kimi-code/pull/1771) [`b513975`](https://github.com/MoonshotAI/kimi-code/commit/b5139757e2df1b5b8723d4bab5137266f5eb0f01) Thanks [@liruifengv](https://github.com/liruifengv)! - Optimize the unit formatting of the context usage display.
+
+- [#1765](https://github.com/MoonshotAI/kimi-code/pull/1765) [`d531398`](https://github.com/MoonshotAI/kimi-code/commit/d531398d0143cd3b0a2f4a099ff537894c9245e9) Thanks [@RealKai42](https://github.com/RealKai42)! - Fix Kimi-provider models routed through the Anthropic protocol incorrectly showing reasoning effort options. Effort choices now come only from the model's declared metadata, and the inferred fallback profile applies solely to non-Kimi Anthropic-compatible providers.
+
+- [#1774](https://github.com/MoonshotAI/kimi-code/pull/1774) [`3d5d630`](https://github.com/MoonshotAI/kimi-code/commit/3d5d630c12ea71fb7066e8018dfa2cb6d42da3e8) Thanks [@RealKai42](https://github.com/RealKai42)! - Honor an explicit thinking "off" on OpenAI-compatible (chat completions) providers: it used to be indistinguishable from "never configured", so the history-based auto `reasoning_effort` injection kept the model reasoning (and could leak the field to models that reject it). The provider now also reports the actual current thinking effort ("on"/"off") instead of recording "off" for both.
+
+- [#1766](https://github.com/MoonshotAI/kimi-code/pull/1766) [`7042af3`](https://github.com/MoonshotAI/kimi-code/commit/7042af3571dbfbf5600535a56692434b84afb4ce) Thanks [@kermanx](https://github.com/kermanx)! - web: Fix the sidebar resize handle being covered by the chat composer background.
+
+- [#1769](https://github.com/MoonshotAI/kimi-code/pull/1769) [`d1ca65e`](https://github.com/MoonshotAI/kimi-code/commit/d1ca65e1de189617e9edbc54010e62d472a1de3d) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Keep legacy migrations idempotent across multiple Kimi homes and report damaged or unmapped sessions instead of silently skipping them.
+
+- [#1763](https://github.com/MoonshotAI/kimi-code/pull/1763) [`81414b6`](https://github.com/MoonshotAI/kimi-code/commit/81414b6ad5eddb64bbd959a8754ffb6c20b4f6fe) Thanks [@liruifengv](https://github.com/liruifengv)! - Warn in the /model and /effort pickers that switching invalidates the existing prompt cache, and hint to use /new to avoid extra token costs.
+
+- [#1773](https://github.com/MoonshotAI/kimi-code/pull/1773) [`1169a6d`](https://github.com/MoonshotAI/kimi-code/commit/1169a6d5fdafca4c1455c3ac4889586ef42f4435) Thanks [@RealKai42](https://github.com/RealKai42)! - Replay empty thinking content verbatim instead of substituting a placeholder space on Anthropic-compatible and Kimi preserved-thinking endpoints.
+
+- [#1781](https://github.com/MoonshotAI/kimi-code/pull/1781) [`09e8554`](https://github.com/MoonshotAI/kimi-code/commit/09e855401be62431b967dcb3b7caf1bcc9705df5) Thanks [@kermanx](https://github.com/kermanx)! - Report when users stop tasks and preserve other stop reasons in model context.
+
+- [#1784](https://github.com/MoonshotAI/kimi-code/pull/1784) [`d465591`](https://github.com/MoonshotAI/kimi-code/commit/d465591eb3fdb30c0c0348d6edb6f4d3d2f72698) Thanks [@sailist](https://github.com/sailist)! - Fix a resumed session being marked as just updated and jumping to the top of the session list without any new activity.
+
+- [#1759](https://github.com/MoonshotAI/kimi-code/pull/1759) [`9e3e670`](https://github.com/MoonshotAI/kimi-code/commit/9e3e6700f9276f4ab60219897b297fc96be2355a) Thanks [@sailist](https://github.com/sailist)! - Fix a race where resuming a background subagent right after it was manually stopped could fail with an "already running" error.
+
+- [#1782](https://github.com/MoonshotAI/kimi-code/pull/1782) [`072eed4`](https://github.com/MoonshotAI/kimi-code/commit/072eed476b5fe7599d994783649a21083320df58) Thanks [@sailist](https://github.com/sailist)! - Fix the context size indicator under-reporting the model's actual context usage.
+
+- [#1769](https://github.com/MoonshotAI/kimi-code/pull/1769) [`d1ca65e`](https://github.com/MoonshotAI/kimi-code/commit/d1ca65e1de189617e9edbc54010e62d472a1de3d) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Support in-process editor hosts with session lifecycle, context, MCP configuration, and cross-platform session storage APIs.
+
+- [#1772](https://github.com/MoonshotAI/kimi-code/pull/1772) [`78967e2`](https://github.com/MoonshotAI/kimi-code/commit/78967e283d28238337e6437b4824f67b2c3cea7d) Thanks [@sailist](https://github.com/sailist)! - web: Refresh the model catalog for all providers when opening the model picker, so newly available models always show up.
+
+## 0.25.0
+
+### Minor Changes
+
+- [#1731](https://github.com/MoonshotAI/kimi-code/pull/1731) [`0b790cd`](https://github.com/MoonshotAI/kimi-code/commit/0b790cdc056475593abd572f657d010504caf752) Thanks [@sailist](https://github.com/sailist)! - web: Allow attaching any file type in chat; files the model cannot consume inline (documents, SVG images, archives, …) are uploaded to the server and given to the model as a file path it can read on demand.
+
+### Patch Changes
+
+- [#1746](https://github.com/MoonshotAI/kimi-code/pull/1746) [`918c135`](https://github.com/MoonshotAI/kimi-code/commit/918c1354d9ff4a7dc66a02ede3a504d19e1f53d1) Thanks [@RealKai42](https://github.com/RealKai42)! - Honor adaptive_thinking = false on Anthropic-compatible models by limiting thinking efforts to the legacy budget set and omitting the effort parameter from requests.
+
+- [#1746](https://github.com/MoonshotAI/kimi-code/pull/1746) [`918c135`](https://github.com/MoonshotAI/kimi-code/commit/918c1354d9ff4a7dc66a02ede3a504d19e1f53d1) Thanks [@RealKai42](https://github.com/RealKai42)! - Apply official Anthropic effort profiles and a 128k output fallback for unknown models. Preserve compatible-provider thinking history across session resumes and model switches, normalize incomplete stream events, and warn on unlisted efforts.
+
+- [#1746](https://github.com/MoonshotAI/kimi-code/pull/1746) [`918c135`](https://github.com/MoonshotAI/kimi-code/commit/918c1354d9ff4a7dc66a02ede3a504d19e1f53d1) Thanks [@RealKai42](https://github.com/RealKai42)! - Fix custom-named models on Anthropic-compatible providers starting new sessions with thinking effort off instead of the model default, and not showing the thinking control in ACP clients.
+
+- [#1757](https://github.com/MoonshotAI/kimi-code/pull/1757) [`f0c8a10`](https://github.com/MoonshotAI/kimi-code/commit/f0c8a103c620b4a66761c0f34c1a8cc7ece9b86c) Thanks [@RealKai42](https://github.com/RealKai42)! - Fix the diagnostic log missing the actual error when the CLI exits unexpectedly.
+
+- [#1731](https://github.com/MoonshotAI/kimi-code/pull/1731) [`0b790cd`](https://github.com/MoonshotAI/kimi-code/commit/0b790cdc056475593abd572f657d010504caf752) Thanks [@sailist](https://github.com/sailist)! - Fix the Content-Security-Policy on non-loopback server binds blocking the web UI's theme bootstrap script and bundled fonts, and tighten the policy with explicit form-action, base-uri, and frame-ancestors directives.
+
+- [#1758](https://github.com/MoonshotAI/kimi-code/pull/1758) [`1d7c205`](https://github.com/MoonshotAI/kimi-code/commit/1d7c205e8397983d3d79e59704db3f67a0c72937) Thanks [@RealKai42](https://github.com/RealKai42)! - Fix the CLI exiting unexpectedly when reading an image from the clipboard fails; it now falls back to pasting text.
+
+- [#1753](https://github.com/MoonshotAI/kimi-code/pull/1753) [`d8ddabb`](https://github.com/MoonshotAI/kimi-code/commit/d8ddabb605c1f6fdcfa9fade8cc09b5f8c93651f) Thanks [@sailist](https://github.com/sailist)! - Fix the web server bearer-token check being bypassed by percent-encoded API paths (e.g. `/%61pi/v1/…`), which allowed unauthenticated access to every API route.
+
+- [#1758](https://github.com/MoonshotAI/kimi-code/pull/1758) [`1d7c205`](https://github.com/MoonshotAI/kimi-code/commit/1d7c205e8397983d3d79e59704db3f67a0c72937) Thanks [@RealKai42](https://github.com/RealKai42)! - Report crash telemetry for unhandled promise rejections, so exits they cause are no longer invisible.
+
+- [#1753](https://github.com/MoonshotAI/kimi-code/pull/1753) [`d8ddabb`](https://github.com/MoonshotAI/kimi-code/commit/d8ddabb605c1f6fdcfa9fade8cc09b5f8c93651f) Thanks [@sailist](https://github.com/sailist)! - Fix the session filesystem API following symlinks that point outside the workspace, which allowed reading, listing, creating, and downloading host files beyond the session directory through a planted symlink.
+
+- [#1753](https://github.com/MoonshotAI/kimi-code/pull/1753) [`d8ddabb`](https://github.com/MoonshotAI/kimi-code/commit/d8ddabb605c1f6fdcfa9fade8cc09b5f8c93651f) Thanks [@sailist](https://github.com/sailist)! - Fix sessions failing to be created when the workspace directory is given through a symlink, which the v2 engine rejected as "not a directory".
+
+- [#1754](https://github.com/MoonshotAI/kimi-code/pull/1754) [`1186686`](https://github.com/MoonshotAI/kimi-code/commit/11866865544b8ec88330372b8582e97a35113308) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Fix completed background subagents losing their final output after a session reload, and retry the output backfill when a transient fetch failure occurs.
+
+- [#1755](https://github.com/MoonshotAI/kimi-code/pull/1755) [`4f99114`](https://github.com/MoonshotAI/kimi-code/commit/4f99114342da11ebf7a403e3af6e0cf2c8cca431) Thanks [@kermanx](https://github.com/kermanx)! - Move the server's v1 wire schema definitions into the engine domains and the server package, removing the shared schema package from the v2 server stack with no behavior change.
+
+- [#1731](https://github.com/MoonshotAI/kimi-code/pull/1731) [`0b790cd`](https://github.com/MoonshotAI/kimi-code/commit/0b790cdc056475593abd572f657d010504caf752) Thanks [@sailist](https://github.com/sailist)! - web: Show every attachment a user sends — files, images, and videos — as chips in the message bubble, and let files be attached by dropping them anywhere in the window.
+
+- [#1744](https://github.com/MoonshotAI/kimi-code/pull/1744) [`b89d385`](https://github.com/MoonshotAI/kimi-code/commit/b89d385fa56915f067d656160086bc3c3126f8a3) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Fix Enter not confirming modal confirmation dialogs in dev builds, and keep the dialog open with a loading state until the confirmed action (such as archiving a session) completes.
+
+- [#1756](https://github.com/MoonshotAI/kimi-code/pull/1756) [`e885aec`](https://github.com/MoonshotAI/kimi-code/commit/e885aec7ffa9ee62d122908b68837c5e010d5d04) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Show full diagnostics for model request failures — a semantic title, the provider's raw message, and expandable details (error code, HTTP status, request ID) with copy support — instead of a bare "Connection error" toast.
+
+- [#1751](https://github.com/MoonshotAI/kimi-code/pull/1751) [`df75a0f`](https://github.com/MoonshotAI/kimi-code/commit/df75a0f5c2f2e2dd3291c8adaba96a832ee1f179) Thanks [@kermanx](https://github.com/kermanx)! - web: Keep session activity indicators in sync with agent work, prevent duplicate streamed content after session activation races or LLM retries, and flush durable session events promptly.
+
+- [#1754](https://github.com/MoonshotAI/kimi-code/pull/1754) [`1186686`](https://github.com/MoonshotAI/kimi-code/commit/11866865544b8ec88330372b8582e97a35113308) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Fix a background subagent showing up as two identical rows in the agents dock panel during streaming.
+
+## 0.24.2
+
+### Patch Changes
+
+- [#1704](https://github.com/MoonshotAI/kimi-code/pull/1704) [`38a2363`](https://github.com/MoonshotAI/kimi-code/commit/38a2363a006d8ed32ff6100ccff2dc7d1a70b2b0) Thanks [@sailist](https://github.com/sailist)! - Align the print-mode run lifecycle across engines: `print_background_mode` and `print_max_turns` now take effect for `kimi -p` on the experimental engine, with the same exit / drain / steer semantics and defaults as the default engine, and `kimi -p "/goal ..."` now stays alive until the goal reaches a terminal state instead of exiting after the first turn.
+
+- [#1704](https://github.com/MoonshotAI/kimi-code/pull/1704) [`38a2363`](https://github.com/MoonshotAI/kimi-code/commit/38a2363a006d8ed32ff6100ccff2dc7d1a70b2b0) Thanks [@sailist](https://github.com/sailist)! - Align the subagent timeout across engines: a fixed 2-hour default, overridable with `[subagent] timeout_ms` in config.toml or the KIMI_SUBAGENT_TIMEOUT_MS environment variable.
+
+- [#1727](https://github.com/MoonshotAI/kimi-code/pull/1727) [`286d3e7`](https://github.com/MoonshotAI/kimi-code/commit/286d3e7aca40a778cc4136eb377e14f14c70141c) Thanks [@liruifengv](https://github.com/liruifengv)! - Add a builtin `check-kimi-code-docs` skill that answers Kimi Code product questions (CLI usage, configuration, membership, error codes) against the official documentation with source links. It triggers automatically on product questions, or run `/check-kimi-code-docs`.
+
+- [#1707](https://github.com/MoonshotAI/kimi-code/pull/1707) [`8490c3e`](https://github.com/MoonshotAI/kimi-code/commit/8490c3e36b6a6cc3ba5c0f15d93b87347ce23878) Thanks [@sailist](https://github.com/sailist)! - Add the number of messages dropped during compaction retries to the session wire log's LLM request traces.
+
+- [#1740](https://github.com/MoonshotAI/kimi-code/pull/1740) [`a74ab44`](https://github.com/MoonshotAI/kimi-code/commit/a74ab44ac7d5656e2dd9cf93b8e484936b05a0c8) Thanks [@sailist](https://github.com/sailist)! - Increase the default per-step LLM retry budget from 3 to 10 attempts, so transient provider failures (429 / overload) are retried with exponential backoff for a few minutes before the turn fails. Tune with `loop_control.max_retries_per_step` in config.toml.
+
+- [#1707](https://github.com/MoonshotAI/kimi-code/pull/1707) [`8490c3e`](https://github.com/MoonshotAI/kimi-code/commit/8490c3e36b6a6cc3ba5c0f15d93b87347ce23878) Thanks [@sailist](https://github.com/sailist)! - Rename the dynamic tool loading model capability from `select_tools` to `dynamically_loaded_tools`, matching the model catalog vocabulary; the `select_tools` tool and the `tool-select` flag are unchanged.
+
+- [#1698](https://github.com/MoonshotAI/kimi-code/pull/1698) [`722694a`](https://github.com/MoonshotAI/kimi-code/commit/722694adf99c53dc608d417ea6d8c90a5712c33f) Thanks [@chengluyu](https://github.com/chengluyu)! - Enforce goal wall-clock budgets while model or tool work is still running.
+
+- [#1730](https://github.com/MoonshotAI/kimi-code/pull/1730) [`72f425e`](https://github.com/MoonshotAI/kimi-code/commit/72f425e18d0264010e1442af67ee8d9acf5f0659) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Fix tool call id collisions across turns for Gemini-protocol models, which merged separate swarm runs into a single card in the web UI.
+
+- [#1695](https://github.com/MoonshotAI/kimi-code/pull/1695) [`5c0f17c`](https://github.com/MoonshotAI/kimi-code/commit/5c0f17cfcf99c27eb697be11ae9b61243d993e4a) Thanks [@chengluyu](https://github.com/chengluyu)! - Preserve active goal elapsed time across crash recovery.
+
+- [#1743](https://github.com/MoonshotAI/kimi-code/pull/1743) [`481b28b`](https://github.com/MoonshotAI/kimi-code/commit/481b28b8f4d527c43c640c4d742c52aa006c3bb0) Thanks [@chengluyu](https://github.com/chengluyu)! - Correct the guidance text shown when a goal cannot be paused or resumed.
+
+- [#1692](https://github.com/MoonshotAI/kimi-code/pull/1692) [`e53cd79`](https://github.com/MoonshotAI/kimi-code/commit/e53cd799572db6b2c73f6938703d586b83013cec) Thanks [@chengluyu](https://github.com/chengluyu)! - Allow goals to use every configured turn before the turn budget stops further work.
+
+- [#1719](https://github.com/MoonshotAI/kimi-code/pull/1719) [`b24a347`](https://github.com/MoonshotAI/kimi-code/commit/b24a347e20a3efa7bba948316784a76439ed7cf5) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Restore the AgentSwarm member list after a page refresh on the v2 backend.
+
+- [#1704](https://github.com/MoonshotAI/kimi-code/pull/1704) [`38a2363`](https://github.com/MoonshotAI/kimi-code/commit/38a2363a006d8ed32ff6100ccff2dc7d1a70b2b0) Thanks [@sailist](https://github.com/sailist)! - Fix sessions created by newer builds failing to open in older CLI builds on the same machine; new sessions are written in a compatible layout, and existing sessions are healed on first open.
+
+- [#1708](https://github.com/MoonshotAI/kimi-code/pull/1708) [`ddfdfb0`](https://github.com/MoonshotAI/kimi-code/commit/ddfdfb0b09b59d95888eca7e9ddb7bb63be5e204) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Fix sub-agent completions being signaled as session turn completions, which fired premature completion notifications, sounds, and unread markers while the main turn was still running.
+
+- [#1714](https://github.com/MoonshotAI/kimi-code/pull/1714) [`20b6972`](https://github.com/MoonshotAI/kimi-code/commit/20b69724aafc8fb0b56a414988eb762a8b8a3ed1) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Fix code block copy buttons when the web UI is served over plain HTTP.
+
+- [#1643](https://github.com/MoonshotAI/kimi-code/pull/1643) [`d8d4e8c`](https://github.com/MoonshotAI/kimi-code/commit/d8d4e8ceb55d7a5cae7ce9b579996c9ff5601914) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Prevent long streaming responses from stalling after a tab is backgrounded.
+
+- [#1715](https://github.com/MoonshotAI/kimi-code/pull/1715) [`de493ae`](https://github.com/MoonshotAI/kimi-code/commit/de493aeec973623bc0e258d6598f6d9215693a5f) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Use an upward chevron for the expand button on minimized plan review and question cards so the icon matches the direction the cards open.
+
+- [#1641](https://github.com/MoonshotAI/kimi-code/pull/1641) [`b6ae0a1`](https://github.com/MoonshotAI/kimi-code/commit/b6ae0a1054635fc71efde61dafa03da8a8b0c4c8) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Show session list loading failures without discarding sessions that are still available.
+
+- [#1719](https://github.com/MoonshotAI/kimi-code/pull/1719) [`b24a347`](https://github.com/MoonshotAI/kimi-code/commit/b24a347e20a3efa7bba948316784a76439ed7cf5) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Expand the AgentSwarm card by default while its subagents are still running.
+
+- [#1693](https://github.com/MoonshotAI/kimi-code/pull/1693) [`7de218a`](https://github.com/MoonshotAI/kimi-code/commit/7de218a909d8f3e676ea3c160834090c9f19ca54) Thanks [@chengluyu](https://github.com/chengluyu)! - web: Resume paused goals when you select Resume.
+
+- [#1700](https://github.com/MoonshotAI/kimi-code/pull/1700) [`3107f96`](https://github.com/MoonshotAI/kimi-code/commit/3107f963a532de88d0affd0a08c60749455c5013) Thanks [@chengluyu](https://github.com/chengluyu)! - Prevent late activity from replaced goals from changing or consuming the budget of replacement goals.
+
+- [#1459](https://github.com/MoonshotAI/kimi-code/pull/1459) [`6eb8e13`](https://github.com/MoonshotAI/kimi-code/commit/6eb8e13417f28a553b4183f113e5b96eb31e4211) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Fix mobile safe-area handling, including the composer floating above the on-screen keyboard on iOS, doubled landscape insets, the PWA top bar under the notch, and toasts overlapping the composer as it grows.
+
+- [#1696](https://github.com/MoonshotAI/kimi-code/pull/1696) [`b781e8c`](https://github.com/MoonshotAI/kimi-code/commit/b781e8cbcfac2cd0e73e3b1b79fa3386c632fa5b) Thanks [@chengluyu](https://github.com/chengluyu)! - Preserve final status messages when automatic goal continuations reach a budget or report a blocker.
+
+- [#1722](https://github.com/MoonshotAI/kimi-code/pull/1722) [`3703d03`](https://github.com/MoonshotAI/kimi-code/commit/3703d0346e79e42f18b5097f5606e6ef7b0ff2dd) Thanks [@sailist](https://github.com/sailist)! - In print mode (`kimi -p`), keep the run alive by default while background tasks are pending and feed each completion back to the main agent as a new turn, with an effectively unbounded wait ceiling and turn cap and a 72-hour subagent timeout. Set `print_background_mode = "exit"` (or `"drain"`) to restore the previous exit-after-one-turn behavior.
+
+- [#1737](https://github.com/MoonshotAI/kimi-code/pull/1737) [`5d6ff02`](https://github.com/MoonshotAI/kimi-code/commit/5d6ff022b1a3732cf0b12d1a87497870def52c0c) Thanks [@sailist](https://github.com/sailist)! - In print mode (`kimi -p`), background Bash tasks and subagents no longer have a timeout by default — they run until they finish or the model stops them, and a foreground Bash command that times out is moved to the background without a new deadline. Interactive defaults are unchanged; tune per mode with `bash_task_timeout_s` under `[background]` or `timeout_ms` under `[subagent]` (`0` = no timeout).
+
+- [#1697](https://github.com/MoonshotAI/kimi-code/pull/1697) [`2bf009f`](https://github.com/MoonshotAI/kimi-code/commit/2bf009fe27d1b0259e90f285e94264a8bf6b5832) Thanks [@chengluyu](https://github.com/chengluyu)! - Reject subagent goal requests consistently instead of starting goals they cannot finish.
+
+- [#1711](https://github.com/MoonshotAI/kimi-code/pull/1711) [`9eff230`](https://github.com/MoonshotAI/kimi-code/commit/9eff230f976c6bd8cc757678293276d8dec013d8) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Log failed requests, WebSocket auth rejections, shutdowns, and key operations (abort, cancel, approvals, config changes) in the web UI server so daemon problems can be diagnosed from its logs.
+
+- [#1704](https://github.com/MoonshotAI/kimi-code/pull/1704) [`38a2363`](https://github.com/MoonshotAI/kimi-code/commit/38a2363a006d8ed32ff6100ccff2dc7d1a70b2b0) Thanks [@sailist](https://github.com/sailist)! - Fix `kimi server` reporting the internal server package version instead of the CLI version in its metadata; the web UI settings now show the CLI version.
+
+- [#1741](https://github.com/MoonshotAI/kimi-code/pull/1741) [`8a3f1ff`](https://github.com/MoonshotAI/kimi-code/commit/8a3f1ffa6fbd7855fd0b10d96587afc6b690ebe3) Thanks [@chengluyu](https://github.com/chengluyu)! - web: Fix the session title not being generated when the first message is a skill slash command.
+
+- [#1694](https://github.com/MoonshotAI/kimi-code/pull/1694) [`513f374`](https://github.com/MoonshotAI/kimi-code/commit/513f374aa08bd86b428f62697c1ca12594d533e9) Thanks [@chengluyu](https://github.com/chengluyu)! - Reject malformed persisted goal records during session recovery.
+
+- [#1704](https://github.com/MoonshotAI/kimi-code/pull/1704) [`38a2363`](https://github.com/MoonshotAI/kimi-code/commit/38a2363a006d8ed32ff6100ccff2dc7d1a70b2b0) Thanks [@sailist](https://github.com/sailist)! - web: Show each message's actual send time in chat history after reloading a session, instead of the session creation time.
+
+- [#1711](https://github.com/MoonshotAI/kimi-code/pull/1711) [`9eff230`](https://github.com/MoonshotAI/kimi-code/commit/9eff230f976c6bd8cc757678293276d8dec013d8) Thanks [@wbxl2000](https://github.com/wbxl2000)! - web: Surface server error details when actions such as stopping a session, archiving, or toggling modes fail, instead of failing silently, and log every operation failure to the console and the exported web log.
+
+- [#1701](https://github.com/MoonshotAI/kimi-code/pull/1701) [`07c3632`](https://github.com/MoonshotAI/kimi-code/commit/07c3632415fa77972c49c39d7171ee5a4790bd01) Thanks [@sailist](https://github.com/sailist)! - Keep the workspace catalog complete and durable: creating a session registers its directory as a workspace, the server backfills missing workspaces from session history at startup, and a removed workspace no longer reappears after a restart.
+
 ## 0.24.1
 
 ### Patch Changes
diff --git a/apps/kimi-code/package.json b/apps/kimi-code/package.json
index d67164fec..7b8a06914 100644
--- a/apps/kimi-code/package.json
+++ b/apps/kimi-code/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/kimi-code",
-  "version": "0.24.1",
+  "version": "0.26.0",
   "description": "The Starting Point for Next-Gen Agents",
   "license": "MIT",
   "author": "Moonshot AI",
diff --git a/apps/kimi-code/src/cli/run-shell.ts b/apps/kimi-code/src/cli/run-shell.ts
index 292aeaa64..64f18d490 100644
--- a/apps/kimi-code/src/cli/run-shell.ts
+++ b/apps/kimi-code/src/cli/run-shell.ts
@@ -2,7 +2,7 @@ import { execSync, spawnSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { log } from '@moonshot-ai/kimi-code-sdk';
+import { flushDiagnosticLogsSync, log } from '@moonshot-ai/kimi-code-sdk';
 import {
   setCrashPhase,
   setTelemetryContext,
@@ -176,6 +176,14 @@ export async function runShell(
   // raw mode with a hidden cursor and XON/XOFF flow control disabled. Restore
   // both before exiting so the user's shell is usable afterwards.
   const emergencyExit = (exitCode: number): void => {
+    // The crash log above is only enqueued into the async sink; flush it
+    // synchronously or the `process.exit()` below would drop the one line that
+    // explains why we crashed. Best-effort: an exit path must never throw.
+    try {
+      flushDiagnosticLogsSync();
+    } catch {
+      /* ignore */
+    }
     restoreTerminalModes();
     restoreStty();
     process.exit(exitCode);
diff --git a/apps/kimi-code/src/cli/sub/server/run.ts b/apps/kimi-code/src/cli/sub/server/run.ts
index 6a903123d..b7a9ffb03 100644
--- a/apps/kimi-code/src/cli/sub/server/run.ts
+++ b/apps/kimi-code/src/cli/sub/server/run.ts
@@ -401,6 +401,9 @@ async function runServerInProcess(
   const v2 = await startServer({
     host: options.host,
     port: options.port,
+    // Report the CLI's product version as `server_version` (/meta, web UI)
+    // rather than kap-server's private package version.
+    version,
     logLevel: options.logLevel,
     logger,
     debugEndpoints: options.debugEndpoints,
diff --git a/apps/kimi-code/src/cli/v2/run-v2-print.ts b/apps/kimi-code/src/cli/v2/run-v2-print.ts
index dd8e6c7a9..b284511ee 100644
--- a/apps/kimi-code/src/cli/v2/run-v2-print.ts
+++ b/apps/kimi-code/src/cli/v2/run-v2-print.ts
@@ -10,7 +10,8 @@
  *     native `DomainEvent` stream (payloads are already v1-protocol-shaped),
  *   - drives a turn through `IAgentPromptService.enqueue()` and awaits
  *     `Turn.result` for authoritative completion,
- *   - drains background tasks (config-driven) before exiting.
+ *   - applies the print-mode background policy (config-driven, v1-aligned:
+ *     `exit` / `drain` / `steer`) before exiting.
  *
  * Selected by `runPrompt` when `KIMI_CODE_EXPERIMENTAL_FLAG` is set.
  */
@@ -34,13 +35,16 @@ import {
   ensureMainAgent,
   hostRequestHeadersSeed,
   logSeed,
+  resolveAgentTaskConfig,
   resolveKimiHome,
   resolveLoggingConfig,
+  resolvePrintBackgroundMode,
   skillCatalogRuntimeOptionsSeed,
   type DomainEvent,
   type IAgentScopeHandle,
   type ISessionScopeHandle,
   type LoopRunResult,
+  type PrintBackgroundMode,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
 import { createKimiDefaultHeaders, createKimiDeviceId } from '@moonshot-ai/kimi-code-oauth';
@@ -81,12 +85,9 @@ import {
 
 const PROMPT_UI_MODE = 'print';
 const DEFAULT_PRINT_WAIT_CEILING_S = 3600;
-const TASK_CONFIG_SECTION = 'task';
-const LEGACY_BACKGROUND_CONFIG_SECTION = 'background';
-
-interface TaskPrintWaitConfig {
-  readonly printWaitCeilingS?: number;
-}
+const DEFAULT_PRINT_MAX_TURNS = 50;
+/** Re-check `goalActive` at least this often while waiting for goal turns. */
+const GOAL_WAIT_POLL_MS = 250;
 
 export async function runV2Print(
   opts: CLIOptions,
@@ -158,9 +159,11 @@ export async function runV2Print(
   removeTerminationCleanup = installPromptTerminationCleanup(promptProcess, cleanup);
 
   try {
-    const resolved = await resolveNativeSession(app, opts, workDir, defaultModel, stderr);
-    restorePermission = resolved.restorePermission;
-
+    // Install the appender BEFORE resolving the session: `session_started` and
+    // `session_load_failed` fire inside create()/resume(), so an appender wired
+    // up only after resolveNativeSession() would drop them to the null appender.
+    // The model below is the best known up front; a resumed session's real
+    // model is reconciled via setContext once resolved.
     telemetryService = app.accessor.get(ITelemetryService);
     if (telemetryEnabled) {
       telemetryService.setAppender(
@@ -168,12 +171,16 @@ export async function runV2Print(
           deviceId,
           appName: CLI_USER_AGENT_PRODUCT,
           uiMode: PROMPT_UI_MODE,
-          model: resolved.telemetryModel,
+          model: opts.model ?? defaultModel,
           getAccessToken: async () => (await auth.getCachedAccessToken()) ?? null,
         }),
       );
     }
-    telemetryService.setContext({ sessionId: resolved.session.id });
+
+    const resolved = await resolveNativeSession(app, opts, workDir, defaultModel, stderr);
+    restorePermission = resolved.restorePermission;
+
+    telemetryService.setContext({ sessionId: resolved.session.id, model: resolved.telemetryModel });
     if (firstLaunch) {
       telemetryService.track2('first_launch');
     }
@@ -336,8 +343,13 @@ async function runNativeTurn(
 
   await agent.accessor.get(IAuthSummaryService).ensureReady();
 
+  const turnEndings = createPrintTurnEndings();
   const subscription = agent.accessor.get(IEventBus).subscribe((event: DomainEvent) => {
     dispatchNativeEvent(writer, event, stderr);
+    // Arm the turn-endings collector before `turn.result` settles so a
+    // background-task completion that steers a new turn right after the main
+    // turn ends cannot have its `turn.ended` slip past the policy loop.
+    if (event.type === 'turn.ended') turnEndings.push(event);
   });
   try {
     const handle = await agent.accessor.get(IAgentPromptService).enqueue({
@@ -361,16 +373,41 @@ async function runNativeTurn(
     }
     const result = await turn.result;
 
-    // Turn settled, but `-p` is not done until any background work the turn
-    // spawned has drained (config-bounded). Flush the buffered assistant
-    // message first so a long drain does not withhold the final message.
+    // Turn settled, but `-p` is not done until the print-mode background
+    // policy says so (config-driven: exit / drain / steer). Flush the buffered
+    // assistant message first so a long drain/steer wait does not withhold the
+    // final message.
     writer.flushAssistant();
     if (result.type === 'completed') {
+      const configService = app.accessor.get(IConfigService);
+      const taskConfig = resolveAgentTaskConfig(configService);
+      const goalService = agent.accessor.get(IAgentGoalService);
       try {
-        await drainBackgroundTasks(app, session);
-      } catch {
-        // Draining is best-effort; a wedged background task must not fail the
-        // (already completed) turn. Swallow and proceed to finish.
+        await applyPrintBackgroundPolicy({
+          mode: resolvePrintBackgroundMode(configService),
+          ceilingS: taskConfig?.printWaitCeilingS ?? DEFAULT_PRINT_WAIT_CEILING_S,
+          maxTurns: taskConfig?.printMaxTurns ?? DEFAULT_PRINT_MAX_TURNS,
+          countPending: () => countPendingBackgroundTasks(session),
+          drain: () => drainBackgroundTasks(session, taskConfig?.printWaitCeilingS),
+          turnEndings,
+          skipTurnId: turn.id,
+          warn: (message) => stderr.write(`Warning: ${message}\n`),
+          now: () => Date.now(),
+          goalActive: () => goalService.getGoal().goal?.status === 'active',
+        });
+      } catch (error) {
+        // A steered turn that fails fails the run (v1 parity). Anything else
+        // is best-effort: a wedged background task must not fail the (already
+        // completed) main turn.
+        if (error instanceof PrintSteeredTurnFailedError) {
+          writer.finish();
+          throw error;
+        }
+        stderr.write(
+          `Warning: print background policy failed: ${
+            error instanceof Error ? error.message : String(error)
+          }\n`,
+        );
       }
       writer.finish();
       return;
@@ -466,12 +503,182 @@ function dispatchNativeEvent(
   }
 }
 
-async function drainBackgroundTasks(app: Scope, session: ISessionScopeHandle): Promise<void> {
-  const config = app.accessor.get(IConfigService);
-  const section =
-    config.get<TaskPrintWaitConfig>(TASK_CONFIG_SECTION) ??
-    config.get<TaskPrintWaitConfig>(LEGACY_BACKGROUND_CONFIG_SECTION);
-  const ceilingS = section?.printWaitCeilingS;
+export type PrintTurnEnding = Extract<DomainEvent, { type: 'turn.ended' }>;
+
+/**
+ * Source of `turn.ended` events for the print steer loop. `next` resolves with
+ * the next ending (skipping `skipTurnId`, the main turn's own buffered
+ * ending), or `null` when `remainingMs` elapses first.
+ */
+export interface PrintTurnEndings {
+  next(remainingMs: number, skipTurnId: number): Promise<PrintTurnEnding | null>;
+}
+
+/**
+ * Buffered `turn.ended` collector fed from the agent event bus. Events that
+ * arrive while no one is waiting are queued, so endings that fire between the
+ * main turn settling and the policy loop starting are not missed.
+ */
+export function createPrintTurnEndings(): PrintTurnEndings & {
+  push: (event: PrintTurnEnding) => void;
+} {
+  const buffer: PrintTurnEnding[] = [];
+  let waiter: ((ending: PrintTurnEnding | null) => void) | undefined;
+  return {
+    push: (event) => {
+      const resolve = waiter;
+      if (resolve !== undefined) {
+        waiter = undefined;
+        resolve(event);
+        return;
+      }
+      buffer.push(event);
+    },
+    next: async (remainingMs, skipTurnId) => {
+      const deadlineAt = Date.now() + remainingMs;
+      const waitOnce = (ms: number): Promise<PrintTurnEnding | null> =>
+        new Promise((resolve) => {
+          let settled = false;
+          const settle = (value: PrintTurnEnding | null): void => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            waiter = undefined;
+            // oxlint-disable-next-line promise/no-multiple-resolved -- `settled` guards the single resolve; the rule cannot see it
+            resolve(value);
+          };
+          const timer = Number.isFinite(ms)
+            ? setTimeout(() => {
+                settle(null);
+              }, ms)
+            : undefined;
+          waiter = settle;
+        });
+      for (;;) {
+        while (buffer.length > 0) {
+          const ending = buffer.shift()!;
+          if (ending.turnId !== skipTurnId) return ending;
+        }
+        const ms = deadlineAt - Date.now();
+        if (ms <= 0) return null;
+        const ending = await waitOnce(ms);
+        if (ending === null) return null;
+        if (ending.turnId !== skipTurnId) return ending;
+        // The skipped turn's own ending: keep waiting within the same budget.
+      }
+    },
+  };
+}
+
+/** A background-task completion steered a new main turn that did not complete. */
+export class PrintSteeredTurnFailedError extends Error {}
+
+export interface PrintBackgroundPolicyInput {
+  readonly mode: PrintBackgroundMode;
+  readonly ceilingS: number;
+  readonly maxTurns: number;
+  readonly countPending: () => number;
+  readonly drain: () => Promise<void>;
+  readonly turnEndings: PrintTurnEndings;
+  readonly skipTurnId: number;
+  readonly warn: (message: string) => void;
+  readonly now: () => number;
+  /**
+   * Reports whether an agent goal is still `active`. v2 drives goal
+   * continuation as new turns (v1 keeps a single turn alive), so a `-p` goal
+   * run must stay alive until the goal leaves `active`, independent of the
+   * background policy.
+   */
+  readonly goalActive?: () => boolean;
+}
+
+/**
+ * Apply the print-mode (`kimi -p`) background-task policy after the main turn
+ * completes. Mirrors v1's `Session.handlePrintMainTurnCompleted`:
+ *  - goal    : while a goal is `active`, keep waiting for its continuation
+ *              turns (bounded by `ceilingS` as a safety net), regardless of
+ *              the background mode; the goal summary drives the exit code.
+ *  - 'exit'  : return immediately (default).
+ *  - 'drain' : suppress + drain background tasks, then return.
+ *  - 'steer' : while background tasks are still pending, stay alive so task
+ *              completions steer new main turns; return once quiescent, or
+ *              when the wall-clock ceiling (`ceilingS`) or the turn cap
+ *              (`maxTurns`) is reached. A steered turn that does not complete
+ *              fails the run.
+ */
+export async function applyPrintBackgroundPolicy(
+  input: PrintBackgroundPolicyInput,
+): Promise<void> {
+  if (input.goalActive !== undefined) {
+    const goalDeadline = input.now() + input.ceilingS * 1000;
+    while (input.goalActive()) {
+      // Also wake on a short poll: a goal can leave `active` without any
+      // further turn.ended (budget block at a turn boundary, or a pause after
+      // a continuation-launch failure), which would otherwise hang the run
+      // until the ceiling.
+      const ended = await input.turnEndings.next(
+        Math.min(goalDeadline - input.now(), GOAL_WAIT_POLL_MS),
+        input.skipTurnId,
+      );
+      if (ended === null && input.now() >= goalDeadline) {
+        input.warn(`print goal wait ceiling reached (${input.ceilingS}s), finishing`);
+        return;
+      }
+      // A continuation turn that does not complete pauses/blocks the goal, so
+      // the loop condition exits on the next check.
+    }
+  }
+  if (input.mode === 'exit') return;
+  if (input.mode === 'drain') {
+    await input.drain();
+    return;
+  }
+
+  // 'steer'
+  const deadline = input.now() + input.ceilingS * 1000;
+  let turns = 0;
+  for (;;) {
+    turns += 1;
+    if (input.now() >= deadline) {
+      input.warn(`print steer ceiling reached (${input.ceilingS}s), finishing`);
+      return;
+    }
+    if (turns > input.maxTurns) {
+      input.warn(`print steer max turns reached (${input.maxTurns}), finishing`);
+      return;
+    }
+    if (input.countPending() === 0) return;
+    const ended = await input.turnEndings.next(deadline - input.now(), input.skipTurnId);
+    if (ended === null) return;
+    if (ended.reason !== 'completed') {
+      throw new PrintSteeredTurnFailedError(formatTurnEndingFailure(ended));
+    }
+  }
+}
+
+function formatTurnEndingFailure(ending: PrintTurnEnding): string {
+  if (ending.error?.code === 'provider.filtered') {
+    return 'Provider safety policy blocked the response.';
+  }
+  if (ending.error !== undefined) return `${ending.error.code}: ${ending.error.message}`;
+  if (ending.reason === 'blocked') {
+    return 'Prompt hook blocked the request.';
+  }
+  return `Prompt turn ended with reason: ${ending.reason}`;
+}
+
+function countPendingBackgroundTasks(session: ISessionScopeHandle): number {
+  let count = 0;
+  for (const handle of session.accessor.get(IAgentLifecycleService).list()) {
+    count += handle.accessor.get(IAgentTaskService).list(true).length;
+  }
+  return count;
+}
+
+async function drainBackgroundTasks(
+  session: ISessionScopeHandle,
+  ceilingS: number | undefined,
+): Promise<void> {
   const ceilingMs =
     typeof ceilingS === 'number' && Number.isFinite(ceilingS) && ceilingS > 0
       ? ceilingS * 1000
diff --git a/apps/kimi-code/src/core/harness.ts b/apps/kimi-code/src/core/harness.ts
index 52d9da753..85f00d9cd 100644
--- a/apps/kimi-code/src/core/harness.ts
+++ b/apps/kimi-code/src/core/harness.ts
@@ -18,6 +18,7 @@ import { dirname } from 'node:path';
 import {
   bootstrap,
   ensureMainAgent,
+  IAgentActivityView,
   IAgentPermissionModeService,
   IAgentProfileService,
   IBootstrapService,
@@ -26,7 +27,6 @@ import {
   IModelResolver,
   IPluginService,
   IProviderService,
-  ISessionActivity,
   ISessionContext,
   ISessionExportService,
   ISessionIndex,
@@ -71,7 +71,6 @@ import type {
   FlagExplanation,
   PermissionMode,
   ResumedSessionState,
-  SessionEvent,
   TelemetryClient,
   TelemetryContextPatch,
   TelemetryProperties,
@@ -311,11 +310,15 @@ export class CoreHarness {
     // TODO(v2-gap): G-5 — v2 cannot replay plugin session-start reminders;
     // `input.forcePluginSessionStartReminder` is accepted and ignored.
     const active = this.activeSessions.get(id);
-    if (active !== undefined && active.handle.accessor.get(ISessionActivity).status() !== 'idle') {
-      throw new CoreError(
-        CoreErrorCodes.TURN_AGENT_BUSY,
-        `Session "${id}" is busy; wait for the current turn to finish before reloading.`,
-      );
+    if (active !== undefined) {
+      const main = await ensureMainAgent(active.handle);
+      const activity = main.accessor.get(IAgentActivityView).state();
+      if (activity.turn !== undefined || activity.background.length > 0) {
+        throw new CoreError(
+          CoreErrorCodes.TURN_AGENT_BUSY,
+          `Session "${id}" is busy; wait for the current turn to finish before reloading.`,
+        );
+      }
     }
     await this.deps.app.accessor.get(IPluginService).reloadPlugins();
     if (active !== undefined) {
diff --git a/apps/kimi-code/src/core/replay.ts b/apps/kimi-code/src/core/replay.ts
index 103db8014..2e2745c31 100644
--- a/apps/kimi-code/src/core/replay.ts
+++ b/apps/kimi-code/src/core/replay.ts
@@ -19,20 +19,24 @@ import {
   IAgentPermissionModeService,
   IAgentPermissionRulesService,
   IAgentPlanService,
+  AGENT_WIRE_RECORD_KEY,
   IAgentProfileService,
+  IAgentScopeContext,
   IAgentSwarmService,
   IAgentTaskService,
   IAgentToolRegistryService,
   IAgentUsageService,
-  IAgentWireRecordService,
+  IAppendLogStore,
   ISessionMetadata,
   ISessionTodoService,
+  IWireService,
   MAIN_AGENT_ID,
   type AgentMeta,
   type IAgentScopeHandle,
   type ISessionScopeHandle,
   type SessionMeta,
   type ToolInfo,
+  type WireRecord,
 } from '@moonshot-ai/agent-core-v2';
 
 import {
@@ -107,7 +111,17 @@ export async function buildResumedAgents(
 async function buildReplayFromWireRecords(
   accessor: IAgentScopeHandle['accessor'],
 ): Promise<AgentReplayRecord[]> {
-  const records = accessor.get(IAgentWireRecordService).getRecords();
+  // Flush first so the read sees every appended record, then fold the
+  // persisted journal one-shot — the same read pattern
+  // `MessageLegacyService.readTranscript` uses.
+  await accessor.get(IWireService).flush();
+  const scope = accessor.get(IAgentScopeContext).scope();
+  const records: WireRecord[] = [];
+  for await (const record of accessor
+    .get(IAppendLogStore)
+    .read<WireRecord>(scope, AGENT_WIRE_RECORD_KEY)) {
+    records.push(record);
+  }
   const { entries } = reduceTranscript(records);
   const rehydrated = await rehydrateTranscript(entries, accessor.get(IAgentBlobService));
   return rehydrated.map(projectTranscriptEntry);
@@ -190,7 +204,7 @@ function projectSessionMetadata(meta: SessionMeta): ResumedSessionMetadata {
 function projectAgentMeta(id: string, meta: AgentMeta): ResumedAgentMeta {
   const type = meta.type === 'main' || meta.type === 'sub' ? meta.type : id === MAIN_AGENT_ID ? 'main' : 'sub';
   return {
-    homedir: meta.homedir,
+    homedir: meta.homedir ?? '',
     type,
     parentAgentId: meta.labels?.['parentAgentId'] ?? meta.parentAgentId ?? null,
     swarmItem: meta.labels?.['swarmItem'] ?? meta.swarmItem,
diff --git a/apps/kimi-code/src/core/transcript.ts b/apps/kimi-code/src/core/transcript.ts
index f39273aa5..e491e97be 100644
--- a/apps/kimi-code/src/core/transcript.ts
+++ b/apps/kimi-code/src/core/transcript.ts
@@ -13,12 +13,12 @@
  * be assignable to each other, so a transcript can never be fed to the model
  * by accident (and vice versa).
  *
- * Form: the reducer set is declared through v2's public `defineDerivedModel`
- * (the same shape a wire-attached derived model would use), but the TUI folds
- * it manually over `IAgentWireRecordService.getRecords()` — resume's
- * `wire.replay` runs inside v2 before the facade sees the session, so a
- * facade-side `wire.attach` would always miss the restore fold. Replay is
- * read exactly once per resume, so a one-shot reduce loses nothing.
+ * Form: the reducer set is a plain local table (the same shape a wire model
+ * would declare), folded one-shot over the persisted `wire.jsonl` records
+ * (`IAppendLogStore.read`) — resume's `wire.restore` runs inside v2 before
+ * the facade sees the session, so a facade-side live fold would always miss
+ * the restore. Replay is read exactly once per resume, so a one-shot reduce
+ * loses nothing.
  *
  * Record → entry mapping (op types not exported by the v2 barrel are keyed by
  * their literal wire names; payloads are declared locally):
@@ -50,7 +50,6 @@ import {
   contextApplyCompaction,
   contextClear,
   contextUndo,
-  defineDerivedModel,
   isRealUserInput,
   planModeCancel,
   planModeEnter,
@@ -485,10 +484,9 @@ function snapshotFromGoalStateLike(goal: GoalStateLike): GoalSnapshot {
 
 // -- public model + one-shot reduce -----------------------------------------
 
-export const TranscriptModel = defineDerivedModel<TranscriptModelState>(
-  'kimi.tui.transcript',
-  () => ({ entries: [], working: INITIAL_WORKING }),
-  {
+type TranscriptReducer = (state: TranscriptModelState, payload: unknown) => TranscriptModelState;
+
+const transcriptReducers: Record<string, TranscriptReducer> = {
     [contextAppendMessage.type]: (state, payload: unknown) =>
       applyAppendMessage(state, toMutableMessage((payload as { message: ContextMessageLike }).message)),
     [contextAppendLoopEvent.type]: (state, payload: unknown) =>
@@ -525,8 +523,13 @@ export const TranscriptModel = defineDerivedModel<TranscriptModelState>(
       entries: [...state.entries, { type: 'config_updated', config: payload as ConfigUpdateWirePayload }],
       working: state.working,
     }),
-  },
-);
+};
+
+export const TranscriptModel = {
+  name: 'kimi.tui.transcript',
+  initial: (): TranscriptModelState => ({ entries: [], working: INITIAL_WORKING }),
+  reducers: transcriptReducers,
+};
 
 function stripSummaryPrefix(text: string): string {
   return text.startsWith(COMPACTION_SUMMARY_PREFIX)
diff --git a/apps/kimi-code/src/migration/detect-pending.ts b/apps/kimi-code/src/migration/detect-pending.ts
index 48435d2bc..cf121bf60 100644
--- a/apps/kimi-code/src/migration/detect-pending.ts
+++ b/apps/kimi-code/src/migration/detect-pending.ts
@@ -3,10 +3,13 @@
  * shown. Cheap, synchronous-ish, no TTY required. Returns the MigrationPlan to
  * drive the screen, or null when there is nothing to offer.
  */
-import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
 
-import { detectMigration, type MigrationPlan } from '@moonshot-ai/migration-legacy';
+import {
+  detectMigration,
+  shouldSuppressMigration,
+  type MigrationPlan,
+} from '@moonshot-ai/migration-legacy';
 
 export interface DetectPendingInput {
   readonly sourceHome: string;
@@ -24,11 +27,11 @@ export async function detectPendingMigration(
 ): Promise<MigrationPlan | null> {
   const { sourceHome, targetHome } = input;
   if (!existsSync(sourceHome)) return null;
-  if (input.ignoreMarker !== true) {
-    if (migrationAlreadyTargeted(join(sourceHome, '.migrated-to-kimi-code'), targetHome)) {
-      return null;
-    }
-    if (existsSync(join(targetHome, '.skip-migration-from-kimi-cli'))) return null;
+  if (
+    input.ignoreMarker !== true &&
+    shouldSuppressMigration({ sourceHome, targetHome })
+  ) {
+    return null;
   }
 
   let plan: MigrationPlan;
@@ -52,21 +55,3 @@ export async function detectPendingMigration(
 
   return plan;
 }
-
-/**
- * True when the legacy `.migrated-to-kimi-code` marker records a migration
- * into *this* target home. A marker written for a different `KIMI_CODE_HOME`
- * must not suppress the prompt — that target has never received migrated data.
- * An unreadable/old marker without `target_path` is treated as "matches"
- * (conservative: do not re-prompt when the marker exists but is ambiguous).
- */
-function migrationAlreadyTargeted(markerPath: string, targetHome: string): boolean {
-  if (!existsSync(markerPath)) return false;
-  try {
-    const parsed = JSON.parse(readFileSync(markerPath, 'utf-8')) as { target_path?: unknown };
-    if (typeof parsed.target_path !== 'string') return true;
-    return resolve(parsed.target_path) === resolve(targetHome);
-  } catch {
-    return true;
-  }
-}
diff --git a/apps/kimi-code/src/tui/commands/config.ts b/apps/kimi-code/src/tui/commands/config.ts
index 762b6249f..9fe1e2128 100644
--- a/apps/kimi-code/src/tui/commands/config.ts
+++ b/apps/kimi-code/src/tui/commands/config.ts
@@ -36,6 +36,21 @@ import type { SlashCommandHost } from './dispatch';
 
 const MODEL_PICKER_REFRESH_TIMEOUT_MS = 2_000;
 
+const MODEL_SWITCH_CACHE_WARNING =
+  'Note: Switching models invalidates the existing prompt cache. Use /new to avoid extra token costs.';
+const EFFORT_SWITCH_CACHE_WARNING =
+  'Note: Switching effort invalidates the existing prompt cache. Use /new to avoid extra token costs.';
+
+/** True once the conversation has at least one user message: a switch from
+ * then on resends the accumulated context, losing the cache. Shell-command
+ * echoes are also 'user' transcript entries but carry an empty `bullet`, so
+ * they're excluded. */
+function hasConversationHistory(host: SlashCommandHost): boolean {
+  return host.state.transcriptEntries.some(
+    (entry) => entry.kind === 'user' && entry.bullet !== '',
+  );
+}
+
 function currentTuiConfig(host: SlashCommandHost): TuiConfig {
   return {
     theme: host.state.appState.theme,
@@ -46,6 +61,14 @@ function currentTuiConfig(host: SlashCommandHost): TuiConfig {
   };
 }
 
+function effectiveModelForHost(host: SlashCommandHost, model: ModelAlias): ModelAlias {
+  const providerType = host.state.appState.availableProviders[model.provider]?.type;
+  // Flat models (no named provider, e.g. inline base_url served by a v2
+  // backend) have no provider entry to look up; their own protocol declaration
+  // plays the provider-identity role, mirroring the resolver.
+  return effectiveModelAlias(model, providerType ?? model.protocol);
+}
+
 export async function handlePlanCommand(host: SlashCommandHost, args: string): Promise<void> {
   const session = host.session;
   if (session === undefined) {
@@ -252,7 +275,7 @@ export async function handleEffortCommand(host: SlashCommandHost, args: string):
     host.showError('No model selected. Run /model to select one first.');
     return;
   }
-  const effective = effectiveModelAlias(model);
+  const effective = effectiveModelForHost(host, model);
   const segments = segmentsFor(effective);
   const arg = args.trim().toLowerCase();
   if (arg.length === 0) {
@@ -260,10 +283,19 @@ export async function handleEffortCommand(host: SlashCommandHost, args: string):
     return;
   }
   if (!segments.includes(arg)) {
-    host.showError(
-      `Unsupported thinking effort "${arg}" for ${alias}. Available: ${segments.join(', ')}`,
+    const providerType = host.state.appState.availableProviders[effective.provider]?.type;
+    const protocol = effective.protocol ?? providerType;
+    if (protocol !== 'anthropic') {
+      host.showError(
+        `Unsupported thinking effort "${arg}" for ${alias}. Available: ${segments.join(', ')}`,
+      );
+      return;
+    }
+    const knownEfforts = effective.supportEfforts?.join(', ') ?? 'none declared';
+    host.showStatus(
+      `Thinking effort "${arg}" is not listed for ${alias} (known: ${knownEfforts}). Sending "${arg}" unchanged; the configured provider will validate it.`,
+      'warning',
     );
-    return;
   }
   await performModelSwitch(host, alias, arg, true);
 }
@@ -280,6 +312,7 @@ function showEffortPicker(
     new EffortSelectorComponent({
       efforts: segments,
       currentValue,
+      warning: hasConversationHistory(host) ? EFFORT_SWITCH_CACHE_WARNING : undefined,
       onSelect: (effort) => {
         host.restoreEditor();
         void performModelSwitch(host, alias, effort, true);
@@ -376,7 +409,13 @@ async function applyEditorChoice(host: SlashCommandHost, value: string): Promise
 }
 
 export function showModelPicker(host: SlashCommandHost, selectedValue: string = host.state.appState.model): void {
-  const entries = Object.entries(host.state.appState.availableModels);
+  const models = Object.fromEntries(
+    Object.entries(host.state.appState.availableModels).map(([alias, model]) => [
+      alias,
+      effectiveModelForHost(host, model),
+    ]),
+  );
+  const entries = Object.entries(models);
   if (entries.length === 0) {
     host.showNotice(
       'No models configured',
@@ -386,10 +425,11 @@ export function showModelPicker(host: SlashCommandHost, selectedValue: string =
   }
   host.mountEditorReplacement(
     new TabbedModelSelectorComponent({
-      models: host.state.appState.availableModels,
+      models,
       currentValue: host.state.appState.model,
       selectedValue,
       currentThinkingEffort: host.state.appState.thinkingEffort,
+      warning: hasConversationHistory(host) ? MODEL_SWITCH_CACHE_WARNING : undefined,
       onSelect: ({ alias, thinking }) => {
         host.restoreEditor();
         void performModelSwitch(host, alias, thinking, true);
diff --git a/apps/kimi-code/src/tui/components/chrome/footer.ts b/apps/kimi-code/src/tui/components/chrome/footer.ts
index 3a7de564e..e732ebc2f 100644
--- a/apps/kimi-code/src/tui/components/chrome/footer.ts
+++ b/apps/kimi-code/src/tui/components/chrome/footer.ts
@@ -3,7 +3,7 @@
  *
  * Layout:
  *   Line 1: [yolo] [plan] <model> <cwd>  <git-badge>  <shortcut hints>
- *   Line 2: context: XX.X% (raw X / projection Y / all Z)
+ *   Line 2: context: N% (raw X / projection Y / all Z)
  */
 
 import type { Component } from '@moonshot-ai/pi-tui';
@@ -23,7 +23,11 @@ import {
   type GitStatus,
   type GitStatusCache,
 } from '#/utils/git/git-status';
-import { safeUsageRatio } from '#/utils/usage/usage-format';
+import {
+  formatTokenCount,
+  usagePercent,
+  usagePercentFromRatio,
+} from '#/utils/usage/usage-format';
 
 const MAX_CWD_SEGMENTS = 3;
 const GOAL_TIMER_INTERVAL_MS = 1_000;
@@ -154,33 +158,33 @@ function shortenCwd(path: string): string {
   return `…/${tail}`;
 }
 
-function formatTokenCount(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
-  return String(n);
-}
-
-function safeUsage(usage: number): number {
-  return safeUsageRatio(usage);
-}
-
+/**
+ * Footer context readout: the folded projection size against the window, with
+ * the raw stored-history size alongside for fold visibility. Percent comes
+ * from the exact token counts when both are known (the ratio can lag a step
+ * behind); otherwise it falls back to the precomputed ratio. Counts use the
+ * shared 1024-based formatter.
+ */
 function formatContextStatus(
   usage: number,
   tokens?: number,
   maxTokens?: number,
   rawTokens?: number,
 ): string {
-  const pct = `${(safeUsage(usage) * 100).toFixed(1)}%`;
-  if (maxTokens && maxTokens > 0 && tokens !== undefined) {
+  if (maxTokens !== undefined && maxTokens > 0 && tokens !== undefined) {
+    const pct = String(usagePercent(tokens, maxTokens));
     // raw = whole stored history, projection = folded view the model sees,
     // all = the context-window ceiling the percentage is measured against.
-    const raw = rawTokens ?? tokens;
-    return (
-      `context: ${pct} (raw ${formatTokenCount(raw)} / ` +
-      `projection ${formatTokenCount(tokens)} / all ${formatTokenCount(maxTokens)})`
-    );
+    // raw reads 0 until the first measurement — show the compact form then.
+    if (rawTokens !== undefined && rawTokens > 0) {
+      return (
+        `context: ${pct}% (raw ${formatTokenCount(rawTokens)} / ` +
+        `projection ${formatTokenCount(tokens)} / all ${formatTokenCount(maxTokens)})`
+      );
+    }
+    return `context: ${pct}% (${formatTokenCount(tokens)}/${formatTokenCount(maxTokens)})`;
   }
-  return `context: ${pct}`;
+  return `context: ${String(usagePercentFromRatio(usage))}%`;
 }
 
 export function formatFooterGitBadge(status: GitStatus, colors: ColorPalette): string {
diff --git a/apps/kimi-code/src/tui/components/dialogs/effort-selector.ts b/apps/kimi-code/src/tui/components/dialogs/effort-selector.ts
index 13df75d0e..89c04f8ed 100644
--- a/apps/kimi-code/src/tui/components/dialogs/effort-selector.ts
+++ b/apps/kimi-code/src/tui/components/dialogs/effort-selector.ts
@@ -3,6 +3,7 @@ import {
   Key,
   matchesKey,
   truncateToWidth,
+  wrapTextWithAnsi,
   type Focusable,
 } from '@moonshot-ai/pi-tui';
 
@@ -22,6 +23,10 @@ export interface EffortSelectorOptions {
   /** When provided, Alt+S applies the choice to the current session only. */
   readonly onSessionOnlySelect?: (effort: ThinkingEffort) => void;
   readonly onCancel: () => void;
+  /** When set, rendered as warning-colored lines directly below the key-hint
+   * line; wraps instead of truncating when it exceeds the width (e.g. the
+   * mid-conversation switch cost notice). */
+  readonly warning?: string;
 }
 
 /**
@@ -76,8 +81,13 @@ export class EffortSelectorComponent extends Container implements Focusable {
       currentTheme.fg('primary', '─'.repeat(width)),
       currentTheme.boldFg('primary', ` ${this.opts.title ?? 'Select thinking effort'}`),
       currentTheme.fg('textMuted', ` ${hintParts.join(' · ')}`),
-      '',
     ];
+    if (this.opts.warning !== undefined) {
+      for (const line of wrapTextWithAnsi(this.opts.warning, Math.max(1, width - 1))) {
+        lines.push(currentTheme.fg('warning', ` ${line}`));
+      }
+    }
+    lines.push('');
 
     const segments = this.opts.efforts.map((effort, index) => {
       const label = effortLabel(effort);
diff --git a/apps/kimi-code/src/tui/components/dialogs/model-selector.ts b/apps/kimi-code/src/tui/components/dialogs/model-selector.ts
index 6cc23f0ee..5f42ee187 100644
--- a/apps/kimi-code/src/tui/components/dialogs/model-selector.ts
+++ b/apps/kimi-code/src/tui/components/dialogs/model-selector.ts
@@ -5,6 +5,7 @@ import {
   matchesKey,
   truncateToWidth,
   visibleWidth,
+  wrapTextWithAnsi,
   type Focusable,
 } from '@moonshot-ai/pi-tui';
 
@@ -73,6 +74,10 @@ export interface ModelSelectorOptions {
   /** When true, the hint line mentions the Tab provider switch — set by
    * TabbedModelSelectorComponent so the inner list advertises the tab keys. */
   readonly providerSwitchHint?: boolean;
+  /** When set, rendered as warning-colored lines directly below the key-hint
+   * line; wraps instead of truncating when it exceeds the width (e.g. the
+   * mid-conversation switch cost notice). */
+  readonly warning?: string;
   readonly onSelect: (selection: ModelSelection) => void;
   /** When provided, Alt+S invokes this instead of onSelect — used to apply the
    * choice to the current session only, without persisting it as the default. */
@@ -286,8 +291,13 @@ export class ModelSelectorComponent extends Container implements Focusable {
       currentTheme.fg('primary', '─'.repeat(width)),
       currentTheme.boldFg('primary', ' Select a model') + titleSuffix,
       currentTheme.fg('textMuted', ' ' + hintParts.join(' · ')),
-      '',
     ];
+    if (this.opts.warning !== undefined) {
+      for (const line of wrapTextWithAnsi(this.opts.warning, Math.max(1, width - 1))) {
+        lines.push(currentTheme.fg('warning', ` ${line}`));
+      }
+    }
+    lines.push('');
 
     if (searchable && view.query.length > 0) {
       lines.push(currentTheme.fg('primary', ' Search: ') + currentTheme.fg('text', view.query));
diff --git a/apps/kimi-code/src/tui/components/dialogs/tabbed-model-selector.ts b/apps/kimi-code/src/tui/components/dialogs/tabbed-model-selector.ts
index 5666a9b2b..59dcd5056 100644
--- a/apps/kimi-code/src/tui/components/dialogs/tabbed-model-selector.ts
+++ b/apps/kimi-code/src/tui/components/dialogs/tabbed-model-selector.ts
@@ -43,6 +43,10 @@ export interface TabbedModelSelectorOptions {
   /** When set, the tab for this provider id is initially active instead of the
    * tab derived from `currentValue`. */
   readonly initialTabId?: string;
+  /** Forwarded to each inner selector; when set, warning-colored lines are
+   * rendered directly below the key-hint line, wrapping as needed (e.g. the
+   * mid-conversation switch cost notice). */
+  readonly warning?: string;
   readonly onSelect: (selection: ModelSelection) => void;
   /** Forwarded to each inner selector; when set, Alt+S applies the choice to
    * the current session only without persisting it as the default. */
@@ -100,24 +104,20 @@ export class TabbedModelSelectorComponent extends Container implements Focusable
     if (this.tabs.length <= 1) {
       return inner.map((line) => truncateToWidth(line, width));
     }
-    // Layout: divider, title, hint, blank, tab strip, blank, then the model
-    // list. The inner selector's blank line (inner[3]) separates the hint from
-    // the tab strip; an extra blank separates the tabs from their list.
+    // Layout: divider, title, hint, optional warning, blank, tab strip, blank,
+    // then the model list. The header ends at its first blank line — keep that
+    // blank above the strip, and separate the tabs from the list with another
+    // blank.
     const stripLine = renderTabStrip({
       labels: this.tabs.map((tab) => tab.label),
       activeIndex: this.activeIndex,
       width,
       colors: currentTheme.palette,
     });
-    const out: string[] = [
-      inner[0] ?? '',
-      inner[1] ?? '',
-      inner[2] ?? '',
-      inner[3] ?? '',
-      stripLine,
-      '',
-    ];
-    for (let i = 4; i < inner.length; i++) out.push(inner[i]!);
+    const headerEnd = inner.findIndex((line) => line === '');
+    const splitAt = headerEnd === -1 ? 3 : headerEnd;
+    const out: string[] = [...inner.slice(0, splitAt + 1), stripLine, ''];
+    for (let i = splitAt + 1; i < inner.length; i++) out.push(inner[i]!);
     return out.map((line) => truncateToWidth(line, width));
   }
 
@@ -182,6 +182,7 @@ function makeSelector(
     currentThinkingEffort: opts.currentThinkingEffort,
     searchable: true,
     providerSwitchHint: true,
+    warning: opts.warning,
     onSelect: opts.onSelect,
     onSessionOnlySelect: opts.onSessionOnlySelect,
     onCancel: opts.onCancel,
diff --git a/apps/kimi-code/src/tui/components/editor/custom-editor.ts b/apps/kimi-code/src/tui/components/editor/custom-editor.ts
index e3532b157..b1677e87b 100644
--- a/apps/kimi-code/src/tui/components/editor/custom-editor.ts
+++ b/apps/kimi-code/src/tui/components/editor/custom-editor.ts
@@ -397,12 +397,21 @@ export class CustomEditor extends Editor {
       }
       if (this.onPasteImage !== undefined) {
         const handler = this.onPasteImage;
-        void handler().then((handled) => {
-          if (!handled) {
-            this.onTextPaste?.();
-            super.handleInput.call(this, normalized);
-          }
-        });
+        const pasteAsText = (): void => {
+          this.onTextPaste?.();
+          super.handleInput.call(this, normalized);
+        };
+        void handler().then(
+          (handled) => {
+            if (!handled) pasteAsText();
+          },
+          () => {
+            // A rejecting image-paste handler must not leak an unhandled
+            // rejection (the CLI turns those into a silent exit) — treat it
+            // the same as "no image available" and fall back to text paste.
+            pasteAsText();
+          },
+        );
         return;
       }
     }
diff --git a/apps/kimi-code/src/tui/components/messages/agent-group.ts b/apps/kimi-code/src/tui/components/messages/agent-group.ts
index 6fd1624d5..7e4752945 100644
--- a/apps/kimi-code/src/tui/components/messages/agent-group.ts
+++ b/apps/kimi-code/src/tui/components/messages/agent-group.ts
@@ -20,6 +20,7 @@ import { Container, Spacer, Text } from '@moonshot-ai/pi-tui';
 
 import { STATUS_BULLET } from '#/tui/constant/symbols';
 import { currentTheme } from '#/tui/theme';
+import { formatTokenCount } from '#/utils/usage/usage-format';
 
 import type { ToolCallComponent, ToolCallSubagentSnapshot } from './tool-call';
 
@@ -371,7 +372,5 @@ function formatElapsed(seconds: number): string {
 }
 
 function formatTokens(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M tok`;
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k tok`;
-  return `${String(n)} tok`;
+  return `${formatTokenCount(n)} tok`;
 }
diff --git a/apps/kimi-code/src/tui/components/messages/status-panel.ts b/apps/kimi-code/src/tui/components/messages/status-panel.ts
index 907401ef6..e7e20c808 100644
--- a/apps/kimi-code/src/tui/components/messages/status-panel.ts
+++ b/apps/kimi-code/src/tui/components/messages/status-panel.ts
@@ -20,6 +20,7 @@ import {
   ratioSeverity,
   renderProgressBar,
   safeUsageRatio,
+  usagePercent,
 } from '#/utils/usage/usage-format';
 
 import {
@@ -133,7 +134,7 @@ export function buildStatusReportLines(options: StatusReportOptions): string[] {
     const bar = renderProgressBar(safeRatio, 20);
     const barColoured = currentTheme.fg(severityToken(ratioSeverity(safeRatio)), bar);
     lines.push(
-      `  ${barColoured}  ${value(`${(safeRatio * 100).toFixed(1)}%`.padStart(6, ' '))}  ` +
+      `  ${barColoured}  ${value(`${String(usagePercent(tokens, maxTokens))}%`.padStart(6, ' '))}  ` +
         muted(`(${formatTokenCount(tokens)} / ${formatTokenCount(maxTokens)})`),
     );
   } else {
diff --git a/apps/kimi-code/src/tui/components/messages/tool-call.ts b/apps/kimi-code/src/tui/components/messages/tool-call.ts
index 1b03fc638..4459b4cce 100644
--- a/apps/kimi-code/src/tui/components/messages/tool-call.ts
+++ b/apps/kimi-code/src/tui/components/messages/tool-call.ts
@@ -28,6 +28,7 @@ import type { TokenUsage } from '#/core/index';
 import { appendStreamingArgsPreview } from '#/tui/utils/event-payload';
 import { decodeMcpToolName } from '#/tui/utils/mcp-tool-name';
 import { isRenderCacheEnabled } from '#/tui/utils/render-cache';
+import { formatTokenCount } from '#/utils/usage/usage-format';
 
 import { agentSwarmResultSummaryFromOutput } from './agent-swarm-progress';
 import { PlanBoxComponent } from './plan-box';
@@ -138,8 +139,7 @@ function str(v: unknown): string {
 
 function formatSubagentContextTokens(contextTokens: number | undefined): string | undefined {
   if (contextTokens === undefined || contextTokens <= 0) return undefined;
-  const formatted = contextTokens >= 1000 ? `${(contextTokens / 1000).toFixed(1)}k` : String(contextTokens);
-  return `${formatted} tok`;
+  return `${formatTokenCount(contextTokens)} tok`;
 }
 
 function usageInputTotal(usage: TokenUsage): number {
@@ -154,8 +154,7 @@ function usageTotal(usage: TokenUsage | undefined): number {
 function formatSubagentTokens(usage: TokenUsage | undefined): string | undefined {
   const total = usageTotal(usage);
   if (total <= 0) return undefined;
-  const formatted = total >= 1000 ? `${(total / 1000).toFixed(1)}k` : String(total);
-  return `${formatted} tok`;
+  return `${formatTokenCount(total)} tok`;
 }
 
 function formatByteSize(bytes: number): string {
@@ -2318,9 +2317,7 @@ function computeLatestActivity(
 }
 
 function formatTokens(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M tok`;
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k tok`;
-  return `${String(n)} tok`;
+  return `${formatTokenCount(n)} tok`;
 }
 
 function formatActivityLine(
diff --git a/apps/kimi-code/src/tui/components/messages/usage-panel.ts b/apps/kimi-code/src/tui/components/messages/usage-panel.ts
index 4d8a1e657..52296ea9c 100644
--- a/apps/kimi-code/src/tui/components/messages/usage-panel.ts
+++ b/apps/kimi-code/src/tui/components/messages/usage-panel.ts
@@ -13,6 +13,7 @@ import {
   ratioSeverity,
   renderProgressBar,
   safeUsageRatio,
+  usagePercent,
 } from '#/utils/usage/usage-format';
 import { currentTheme } from '#/tui/theme';
 import type { ColorToken } from '#/tui/theme';
@@ -266,7 +267,7 @@ export function buildUsageReportLines(options: UsageReportOptions): string[] {
   if (options.maxContextTokens > 0) {
     const ratio = safeUsageRatio(options.contextUsage);
     const bar = renderProgressBar(ratio, 20);
-    const pct = `${(ratio * 100).toFixed(1)}%`;
+    const pct = `${String(usagePercent(options.contextTokens, options.maxContextTokens))}%`;
     const barColoured = currentTheme.fg(severityColor(ratioSeverity(ratio)), bar);
     lines.push('');
     lines.push(accent('Context window'));
diff --git a/apps/kimi-code/src/tui/controllers/session-replay.ts b/apps/kimi-code/src/tui/controllers/session-replay.ts
index a13d062b5..f64f2a8d2 100644
--- a/apps/kimi-code/src/tui/controllers/session-replay.ts
+++ b/apps/kimi-code/src/tui/controllers/session-replay.ts
@@ -667,7 +667,7 @@ export class SessionReplayRenderer {
     switch (result.decision) {
       case 'rejected':
         content =
-          result.selected_label === 'Revise' ? 'Plan sent back for revision' : 'Plan review rejected';
+          result.selectedLabel === 'Revise' ? 'Plan sent back for revision' : 'Plan review rejected';
         break;
       case 'cancelled':
         content = 'Plan review cancelled';
diff --git a/apps/kimi-code/src/tui/utils/goal-completion.ts b/apps/kimi-code/src/tui/utils/goal-completion.ts
index 7217eb97d..a00e378a7 100644
--- a/apps/kimi-code/src/tui/utils/goal-completion.ts
+++ b/apps/kimi-code/src/tui/utils/goal-completion.ts
@@ -1,5 +1,7 @@
 import type { GoalSnapshot } from '#/core/index';
 
+import { formatTokenCount } from '#/utils/usage/usage-format';
+
 interface GoalCompletionStats {
   readonly terminalReason?: string | undefined;
   readonly turnsUsed: number;
@@ -19,7 +21,7 @@ export function buildGoalCompletionMessage(goal: GoalSnapshot): string {
 export function buildGoalCompletionMessageFromStats(goal: GoalCompletionStats): string {
   const head = `✓ Goal complete${goal.terminalReason ? ` — ${goal.terminalReason}` : ''}.`;
   const turns = `${goal.turnsUsed} turn${goal.turnsUsed === 1 ? '' : 's'}`;
-  const stats = `Worked ${turns} over ${formatElapsed(goal.wallClockMs)}, using ${formatTokens(goal.tokensUsed)} tokens.`;
+  const stats = `Worked ${turns} over ${formatElapsed(goal.wallClockMs)}, using ${formatTokenCount(goal.tokensUsed)} tokens.`;
   return `${head}\n${stats}`;
 }
 
@@ -32,9 +34,3 @@ function formatElapsed(ms: number): string {
   const hours = Math.floor(minutes / 60);
   return `${hours}h${(minutes % 60).toString().padStart(2, '0')}m`;
 }
-
-function formatTokens(tokens: number): string {
-  if (tokens < 1000) return String(tokens);
-  if (tokens < 1_000_000) return `${(tokens / 1000).toFixed(1)}k`;
-  return `${(tokens / 1_000_000).toFixed(1)}M`;
-}
diff --git a/apps/kimi-code/src/utils/usage/usage-format.ts b/apps/kimi-code/src/utils/usage/usage-format.ts
index 34db897a2..b44adb3f0 100644
--- a/apps/kimi-code/src/utils/usage/usage-format.ts
+++ b/apps/kimi-code/src/utils/usage/usage-format.ts
@@ -5,11 +5,40 @@
  * command itself chalks the colour afterwards.
  */
 
+/**
+ * Format a token count in 1024-based units: context sizes are powers of
+ * two, so 262144 reads as "256k", not "262.1k". k values at or above
+ * 100 are rounded to whole numbers ("977k").
+ */
 export function formatTokenCount(n: number): string {
   if (!Number.isFinite(n) || n < 0) return '0';
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
-  return String(Math.round(n));
+  if (n >= 1024 * 1024) return `${trimDecimal(n / (1024 * 1024))}M`;
+  if (n >= 1024) {
+    const k = n / 1024;
+    return `${k >= 100 ? Math.round(k) : trimDecimal(k)}k`;
+  }
+  return String(n);
+}
+
+/** One decimal place, dropping a redundant ".0" ("1.0" → "1", "1.5" stays). */
+function trimDecimal(v: number): string {
+  const s = v.toFixed(1);
+  return s.endsWith('.0') ? s.slice(0, -2) : s;
+}
+
+/**
+ * Usage as a whole-number percentage of `max`, ceiled so any non-zero
+ * usage shows at least 1%, clamped to [0, 100]. A non-positive or
+ * non-finite `max` reports 0.
+ */
+export function usagePercent(used: number, max: number): number {
+  if (!Number.isFinite(max) || max <= 0) return 0;
+  return Math.min(100, Math.max(0, Math.ceil((used / max) * 100)));
+}
+
+/** `usagePercent` for callers that only know the ratio (NaN-safe). */
+export function usagePercentFromRatio(ratio: number): number {
+  return Math.min(100, Math.max(0, Math.ceil(safeUsageRatio(ratio) * 100)));
 }
 
 /**
diff --git a/apps/kimi-code/test/cli/run-shell.test.ts b/apps/kimi-code/test/cli/run-shell.test.ts
index 5d2302d75..10bca3320 100644
--- a/apps/kimi-code/test/cli/run-shell.test.ts
+++ b/apps/kimi-code/test/cli/run-shell.test.ts
@@ -61,6 +61,7 @@ const mocks = vi.hoisted(() => {
       track: lifecycleTrack,
     })),
     resolveKimiHome: vi.fn((homeDir?: string) => homeDir ?? '/tmp/kimi-code-test-home'),
+    flushDiagnosticLogsSync: vi.fn(),
     harnessCreatesDeviceIdOnConstruction: false,
     execSync: vi.fn(),
     TuiConfigParseError,
@@ -72,6 +73,7 @@ vi.mock('@moonshot-ai/kimi-code-sdk', async (importOriginal) => {
   return {
     ...actual,
     resolveKimiHome: mocks.resolveKimiHome,
+    flushDiagnosticLogsSync: mocks.flushDiagnosticLogsSync,
   };
 });
 
@@ -567,6 +569,101 @@ describe('runShell', () => {
     expect(mocks.kimiTuiConstructor).not.toHaveBeenCalled();
   });
 
+  it('flushes diagnostic logs synchronously before exiting on a runtime crash', async () => {
+    mocks.loadTuiConfig.mockResolvedValue({
+      theme: 'dark',
+      editorCommand: null,
+      notifications: { enabled: true, condition: 'unfocused' },
+    });
+    mocks.tuiStart.mockResolvedValue(undefined);
+
+    const processOnSpy = vi.spyOn(process, 'on');
+    const stdout = captureProcessWrite('stdout');
+    const exitSpy = mockProcessExit();
+
+    try {
+      await runShell(
+        {
+          session: undefined,
+          continue: false,
+          yolo: false,
+          auto: false,
+          plan: false,
+          model: undefined,
+          outputFormat: undefined,
+          prompt: undefined,
+          skillsDirs: [],
+        },
+        '1.2.3-test',
+      );
+
+      const handler = processOnSpy.mock.calls.find(
+        ([event]) => event === 'uncaughtException',
+      )?.[1] as ((error: unknown) => void) | undefined;
+      expect(handler).toBeDefined();
+
+      // The async log sink cannot flush before process.exit() runs, so the
+      // crash handler must force a synchronous flush or the crash reason is
+      // lost (regression: uncaughtException logs never reached disk).
+      expect(() => handler?.(new Error('boom'))).toThrow(ExitCalled);
+      expect(mocks.flushDiagnosticLogsSync).toHaveBeenCalledOnce();
+      expect(exitSpy).toHaveBeenCalledWith(1);
+      expect(mocks.flushDiagnosticLogsSync.mock.invocationCallOrder[0]!).toBeLessThan(
+        exitSpy.mock.invocationCallOrder[0]!,
+      );
+    } finally {
+      processOnSpy.mockRestore();
+      exitSpy.mockRestore();
+      stdout.restore();
+    }
+  });
+
+  it('flushes diagnostic logs synchronously before exiting on an unhandled rejection', async () => {
+    mocks.loadTuiConfig.mockResolvedValue({
+      theme: 'dark',
+      editorCommand: null,
+      notifications: { enabled: true, condition: 'unfocused' },
+    });
+    mocks.tuiStart.mockResolvedValue(undefined);
+
+    const processOnSpy = vi.spyOn(process, 'on');
+    const stdout = captureProcessWrite('stdout');
+    const exitSpy = mockProcessExit();
+
+    try {
+      await runShell(
+        {
+          session: undefined,
+          continue: false,
+          yolo: false,
+          auto: false,
+          plan: false,
+          model: undefined,
+          outputFormat: undefined,
+          prompt: undefined,
+          skillsDirs: [],
+        },
+        '1.2.3-test',
+      );
+
+      const handler = processOnSpy.mock.calls.find(
+        ([event]) => event === 'unhandledRejection',
+      )?.[1] as ((reason: unknown) => void) | undefined;
+      expect(handler).toBeDefined();
+
+      expect(() => handler?.(new Error('boom'))).toThrow(ExitCalled);
+      expect(mocks.flushDiagnosticLogsSync).toHaveBeenCalledOnce();
+      expect(exitSpy).toHaveBeenCalledWith(1);
+      expect(mocks.flushDiagnosticLogsSync.mock.invocationCallOrder[0]!).toBeLessThan(
+        exitSpy.mock.invocationCallOrder[0]!,
+      );
+    } finally {
+      processOnSpy.mockRestore();
+      exitSpy.mockRestore();
+      stdout.restore();
+    }
+  });
+
   it('closes the harness when TUI startup fails', async () => {
     mocks.loadTuiConfig.mockResolvedValue({
       theme: 'dark',
diff --git a/apps/kimi-code/test/cli/run-v2-print.test.ts b/apps/kimi-code/test/cli/run-v2-print.test.ts
new file mode 100644
index 000000000..2e93c2137
--- /dev/null
+++ b/apps/kimi-code/test/cli/run-v2-print.test.ts
@@ -0,0 +1,288 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  applyPrintBackgroundPolicy,
+  createPrintTurnEndings,
+  PrintSteeredTurnFailedError,
+  type PrintTurnEnding,
+  type PrintTurnEndings,
+} from '#/cli/v2/run-v2-print';
+
+function ending(
+  turnId: number,
+  reason: PrintTurnEnding['reason'] = 'completed',
+): PrintTurnEnding {
+  return { type: 'turn.ended', turnId, reason };
+}
+
+interface ScriptedEntry {
+  readonly event: PrintTurnEnding;
+  /** Side effect applied when this entry is consumed (e.g. mutate pending). */
+  readonly apply?: () => void;
+}
+
+/**
+ * Scripted `PrintTurnEndings`: replays queued endings (honouring `skipTurnId`),
+ * then resolves `null` once the script is exhausted (the wait "timed out").
+ */
+function scriptedTurnEndings(entries: ScriptedEntry[]): PrintTurnEndings {
+  const queue = [...entries];
+  return {
+    next: async (_remainingMs: number, skipTurnId: number) => {
+      while (queue.length > 0) {
+        const entry = queue.shift()!;
+        if (entry.event.turnId === skipTurnId) continue;
+        entry.apply?.();
+        return entry.event;
+      }
+      return null;
+    },
+  };
+}
+
+describe('applyPrintBackgroundPolicy', () => {
+  it('exit returns immediately without draining or waiting', async () => {
+    const drain = vi.fn(async () => {});
+    const countPending = vi.fn(() => 1);
+    await applyPrintBackgroundPolicy({
+      mode: 'exit',
+      ceilingS: 60,
+      maxTurns: 50,
+      countPending,
+      drain,
+      turnEndings: scriptedTurnEndings([]),
+      skipTurnId: 1,
+      warn: () => {},
+      now: () => Date.now(),
+    });
+    expect(drain).not.toHaveBeenCalled();
+    expect(countPending).not.toHaveBeenCalled();
+  });
+
+  it('drain drains once and returns', async () => {
+    const drain = vi.fn(async () => {});
+    await applyPrintBackgroundPolicy({
+      mode: 'drain',
+      ceilingS: 60,
+      maxTurns: 50,
+      countPending: () => 1,
+      drain,
+      turnEndings: scriptedTurnEndings([]),
+      skipTurnId: 1,
+      warn: () => {},
+      now: () => Date.now(),
+    });
+    expect(drain).toHaveBeenCalledTimes(1);
+  });
+
+  it('steer returns once background tasks are quiescent', async () => {
+    let pending = 1;
+    const warn = vi.fn();
+    await applyPrintBackgroundPolicy({
+      mode: 'steer',
+      ceilingS: 60,
+      maxTurns: 50,
+      countPending: () => pending,
+      drain: async () => {},
+      turnEndings: scriptedTurnEndings([
+        // The main turn's own buffered ending is skipped.
+        { event: ending(1) },
+        // A background task completed and steered a new turn; it finished and
+        // no tasks remain.
+        { event: ending(2), apply: () => { pending = 0; } },
+      ]),
+      skipTurnId: 1,
+      warn,
+      now: () => Date.now(),
+    });
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it('steer finishes with a warning when max turns is reached', async () => {
+    const warn = vi.fn();
+    await applyPrintBackgroundPolicy({
+      mode: 'steer',
+      ceilingS: 60,
+      maxTurns: 2,
+      countPending: () => 1,
+      drain: async () => {},
+      turnEndings: scriptedTurnEndings([{ event: ending(2) }, { event: ending(3) }]),
+      skipTurnId: 1,
+      warn,
+      now: () => Date.now(),
+    });
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]?.[0]).toContain('max turns');
+  });
+
+  it('steer finishes with a warning when the ceiling is reached', async () => {
+    let now = 0;
+    const warn = vi.fn();
+    await applyPrintBackgroundPolicy({
+      mode: 'steer',
+      ceilingS: 10,
+      maxTurns: 50,
+      countPending: () => 1,
+      drain: async () => {},
+      turnEndings: scriptedTurnEndings([
+        { event: ending(2), apply: () => { now = 10_001; } },
+      ]),
+      skipTurnId: 1,
+      warn,
+      now: () => now,
+    });
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]?.[0]).toContain('ceiling');
+  });
+
+  it('steer returns when the wait times out with tasks still pending', async () => {
+    const warn = vi.fn();
+    await applyPrintBackgroundPolicy({
+      mode: 'steer',
+      ceilingS: 60,
+      maxTurns: 50,
+      countPending: () => 1,
+      drain: async () => {},
+      // Empty script: no further turn ends before the deadline.
+      turnEndings: scriptedTurnEndings([]),
+      skipTurnId: 1,
+      warn,
+      now: () => Date.now(),
+    });
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it('steer throws when a steered turn does not complete', async () => {
+    await expect(
+      applyPrintBackgroundPolicy({
+        mode: 'steer',
+        ceilingS: 60,
+        maxTurns: 50,
+        countPending: () => 1,
+        drain: async () => {},
+        turnEndings: scriptedTurnEndings([
+          {
+            event: {
+              type: 'turn.ended',
+              turnId: 2,
+              reason: 'failed',
+              error: { code: 'provider.overloaded', message: 'try later' },
+            } as PrintTurnEnding,
+          },
+        ]),
+        skipTurnId: 1,
+        warn: () => {},
+        now: () => Date.now(),
+      }),
+    ).rejects.toThrow(PrintSteeredTurnFailedError);
+  });
+
+  it('waits for goal continuation turns before applying the mode', async () => {
+    let active = true;
+    let consumed = 0;
+    const drain = vi.fn(async () => {});
+    await applyPrintBackgroundPolicy({
+      mode: 'drain',
+      ceilingS: 60,
+      maxTurns: 50,
+      countPending: () => 0,
+      drain,
+      turnEndings: scriptedTurnEndings([
+        { event: ending(2), apply: () => { consumed += 1; } },
+        {
+          event: ending(3),
+          apply: () => {
+            consumed += 1;
+            active = false;
+          },
+        },
+      ]),
+      skipTurnId: 1,
+      warn: () => {},
+      now: () => Date.now(),
+      goalActive: () => active,
+    });
+    // Both continuation turns ended before the mode ('drain') ran.
+    expect(consumed).toBe(2);
+    expect(drain).toHaveBeenCalledTimes(1);
+  });
+
+  it('warns and returns when the goal wait hits the ceiling', async () => {
+    let now = 0;
+    const warn = vi.fn();
+    await applyPrintBackgroundPolicy({
+      mode: 'exit',
+      ceilingS: 10,
+      maxTurns: 50,
+      countPending: () => 0,
+      drain: async () => {},
+      // No continuation turn ever ends; the poll interval elapses each time.
+      turnEndings: {
+        next: async () => {
+          now = 10_001;
+          return null;
+        },
+      },
+      skipTurnId: 1,
+      warn,
+      now: () => now,
+      goalActive: () => true,
+    });
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]?.[0]).toContain('goal wait ceiling');
+  });
+
+  it('exits the goal wait promptly when the goal settles without a turn ending', async () => {
+    let active = true;
+    const warn = vi.fn();
+    await applyPrintBackgroundPolicy({
+      mode: 'exit',
+      ceilingS: 3600,
+      maxTurns: 50,
+      countPending: () => 0,
+      drain: async () => {},
+      // Poll interval elapses; the goal settles (paused/blocked) mid-wait
+      // without producing a turn.ended.
+      turnEndings: {
+        next: async () => {
+          active = false;
+          return null;
+        },
+      },
+      skipTurnId: 1,
+      warn,
+      now: () => Date.now(),
+      goalActive: () => active,
+    });
+    expect(warn).not.toHaveBeenCalled();
+  });
+});
+
+describe('createPrintTurnEndings', () => {
+  it('buffers events pushed before next() and skips the given turn id', async () => {
+    const endings = createPrintTurnEndings();
+    endings.push(ending(1));
+    endings.push(ending(2));
+    await expect(endings.next(1000, 1)).resolves.toMatchObject({ turnId: 2 });
+  });
+
+  it('delivers a pushed event to a pending next()', async () => {
+    const endings = createPrintTurnEndings();
+    const pending = endings.next(1000, 1);
+    endings.push(ending(3));
+    await expect(pending).resolves.toMatchObject({ turnId: 3 });
+  });
+
+  it('resolves null when the remaining time elapses', async () => {
+    const endings = createPrintTurnEndings();
+    await expect(endings.next(5, 1)).resolves.toBeNull();
+  });
+
+  it('keeps waiting when only the skipped turn ends', async () => {
+    const endings = createPrintTurnEndings();
+    const pending = endings.next(1000, 1);
+    endings.push(ending(1));
+    endings.push(ending(4));
+    await expect(pending).resolves.toMatchObject({ turnId: 4 });
+  });
+});
diff --git a/apps/kimi-code/test/core/harness.test.ts b/apps/kimi-code/test/core/harness.test.ts
index 11a803a4c..8a15312d0 100644
--- a/apps/kimi-code/test/core/harness.test.ts
+++ b/apps/kimi-code/test/core/harness.test.ts
@@ -11,6 +11,7 @@ import { join } from 'node:path';
 
 import { afterEach, describe, expect, it } from 'vitest';
 import {
+  IAgentActivityView,
   IAgentBlobService,
   IAgentContextMemoryService,
   IAgentContextSizeService,
@@ -19,11 +20,12 @@ import {
   IAgentPermissionRulesService,
   IAgentPlanService,
   IAgentProfileService,
+  IAgentScopeContext,
   IAgentSwarmService,
   IAgentTaskService,
   IAgentToolRegistryService,
   IAgentUsageService,
-  IAgentWireRecordService,
+  IAppendLogStore,
   IBootstrapService,
   IConfigService,
   IEventBus,
@@ -32,7 +34,6 @@ import {
   IModelResolver,
   IPluginService,
   IProviderService,
-  ISessionActivity,
   ISessionApprovalService,
   ISessionContext,
   ISessionCronService,
@@ -44,6 +45,7 @@ import {
   ISessionQuestionService,
   ISessionTodoService,
   ISessionWorkspaceContext,
+  IWireService,
   IWorkspaceRegistry,
 } from '@moonshot-ai/agent-core-v2';
 import { CoreErrorCodes, isCoreError } from '../../src/core/errors';
@@ -173,7 +175,18 @@ function makeFixture(options?: {
         [IAgentUsageService, { status: () => usage }],
         [IAgentToolRegistryService, { list: () => [] }],
         [IAgentTaskService, { list: () => [] }],
-        [IAgentWireRecordService, { getRecords: () => [] }],
+        [
+          IAgentActivityView,
+          {
+            state: () =>
+              options?.activityStatus === 'running'
+                ? { lifecycle: 'ready', turn: { turnId: 1 }, background: [] }
+                : { lifecycle: 'ready', background: [] },
+          },
+        ],
+        [IWireService, { flush: () => Promise.resolve() }],
+        [IAgentScopeContext, { scope: () => 'agent-main' }],
+        [IAppendLogStore, { read: async function* () {} }],
         [IAgentBlobService, { loadParts: async (parts: readonly unknown[]) => parts }],
       ] as ReadonlyArray<readonly [unknown, unknown]>,
     };
@@ -223,7 +236,6 @@ function makeFixture(options?: {
           ISessionWorkspaceContext,
           { workDir, additionalDirs: ['/extra'], addAdditionalDir: record(`${sid}.addAdditionalDir`) },
         ],
-        [ISessionActivity, { status: () => options?.activityStatus ?? 'idle' }],
         [ISessionTodoService, { getTodos: () => [] }],
       ]),
     };
diff --git a/apps/kimi-code/test/core/replay.test.ts b/apps/kimi-code/test/core/replay.test.ts
index ee09430b6..6b33799d7 100644
--- a/apps/kimi-code/test/core/replay.test.ts
+++ b/apps/kimi-code/test/core/replay.test.ts
@@ -11,13 +11,15 @@ import {
   IAgentPermissionRulesService,
   IAgentPlanService,
   IAgentProfileService,
+  IAgentScopeContext,
   IAgentSwarmService,
   IAgentTaskService,
   IAgentToolRegistryService,
   IAgentUsageService,
-  IAgentWireRecordService,
+  IAppendLogStore,
   ISessionMetadata,
   ISessionTodoService,
+  IWireService,
 } from '@moonshot-ai/agent-core-v2';
 import { buildResumedAgents, buildResumedSessionState } from '../../src/core/replay';
 
@@ -141,7 +143,16 @@ function makeFixture(metaOverrides?: Record<string, unknown>) {
       [IAgentSwarmService, { isActive: true }],
       [IAgentUsageService, { status: () => usage }],
       [IAgentToolRegistryService, { list: () => toolInfos }],
-      [IAgentWireRecordService, { getRecords: () => wireRecords }],
+      [IWireService, { flush: () => Promise.resolve() }],
+      [IAgentScopeContext, { scope: () => 'agent-main' }],
+      [
+        IAppendLogStore,
+        {
+          read: async function* () {
+            for (const record of wireRecords) yield record;
+          },
+        },
+      ],
       [IAgentBlobService, { loadParts: async (parts: readonly unknown[]) => parts }],
       [
         IAgentTaskService,
diff --git a/apps/kimi-code/test/helpers/process.ts b/apps/kimi-code/test/helpers/process.ts
index 5a861724b..1da718fac 100644
--- a/apps/kimi-code/test/helpers/process.ts
+++ b/apps/kimi-code/test/helpers/process.ts
@@ -6,7 +6,7 @@ export class ExitCalled extends Error {
   }
 }
 
-export function mockProcessExit(): { mockRestore(): void } {
+export function mockProcessExit() {
   return vi.spyOn(process, 'exit').mockImplementation(((code?: string | number | null) => {
     throw new ExitCalled(Number(code ?? 0));
   }) as never);
diff --git a/apps/kimi-code/test/tui/components/dialogs/effort-selector.test.ts b/apps/kimi-code/test/tui/components/dialogs/effort-selector.test.ts
index e74fa7aa1..53ff5b170 100644
--- a/apps/kimi-code/test/tui/components/dialogs/effort-selector.test.ts
+++ b/apps/kimi-code/test/tui/components/dialogs/effort-selector.test.ts
@@ -102,4 +102,50 @@ describe('EffortSelectorComponent', () => {
     picker.handleInput(ESC);
     expect(onCancel).toHaveBeenCalledTimes(1);
   });
+
+  it('renders the warning line directly below the key-hint line when provided', () => {
+    const picker = new EffortSelectorComponent({
+      efforts: ['off', 'low', 'high', 'max'],
+      currentValue: 'high',
+      warning: 'Switching may increase token usage.',
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+    const lines = picker.render(120).map(strip);
+    const hintIdx = lines.findIndex((l) => l.includes('←→ switch'));
+    expect(hintIdx).toBeGreaterThanOrEqual(0);
+    expect(lines[hintIdx + 1]).toContain('Switching may increase token usage.');
+  });
+
+  it('renders no warning line without the warning option', () => {
+    const picker = new EffortSelectorComponent({
+      efforts: ['off', 'low', 'high', 'max'],
+      currentValue: 'high',
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+    const lines = picker.render(120).map(strip);
+    const hintIdx = lines.findIndex((l) => l.includes('←→ switch'));
+    expect(hintIdx).toBeGreaterThanOrEqual(0);
+    expect(lines[hintIdx + 1]).toBe('');
+  });
+
+  it('wraps a warning longer than the width instead of truncating it', () => {
+    const warning =
+      'Note: Switching effort invalidates the existing prompt cache. Use /new to avoid extra token costs.';
+    const picker = new EffortSelectorComponent({
+      efforts: ['off', 'low', 'high', 'max'],
+      currentValue: 'high',
+      warning,
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+    const lines = picker.render(40).map(strip);
+    const hintIdx = lines.findIndex((l) => l.includes('←→ switch'));
+    expect(lines[hintIdx + 1]).not.toBe('');
+    expect(lines[hintIdx + 2]).not.toBe('');
+    // Word-wrapped: nothing dropped — the full warning survives across lines.
+    const squashed = lines.join('').replaceAll(/\s+/g, '');
+    expect(squashed).toContain(warning.replaceAll(/\s+/g, ''));
+  });
 });
diff --git a/apps/kimi-code/test/tui/components/dialogs/model-selector.test.ts b/apps/kimi-code/test/tui/components/dialogs/model-selector.test.ts
index ba1499e04..8fced4176 100644
--- a/apps/kimi-code/test/tui/components/dialogs/model-selector.test.ts
+++ b/apps/kimi-code/test/tui/components/dialogs/model-selector.test.ts
@@ -338,6 +338,55 @@ describe('ModelSelectorComponent', () => {
     expect(out).toContain('Thinking  (←→ to switch)');
   });
 
+  it('derives official Anthropic effort segments from the model name', () => {
+    const onSelect = vi.fn();
+    const picker = new ModelSelectorComponent({
+      models: {
+        opus: {
+          provider: 'anthropic',
+          model: 'claude-opus-4-6',
+          maxContextSize: 200000,
+        },
+      },
+      currentValue: 'opus',
+      currentThinkingEffort: 'high',
+      onSelect,
+      onCancel: vi.fn(),
+    });
+
+    const out = text(picker);
+    expect(out).toContain('Low');
+    expect(out).toContain('[ High ]');
+    expect(out).toContain('Max');
+    expect(out).toContain('Off');
+    expect(out).not.toContain('Xhigh');
+
+    picker.handleInput(RIGHT);
+    picker.handleInput('\r');
+    expect(onSelect).toHaveBeenCalledWith({ alias: 'opus', thinking: 'max' });
+  });
+
+  it('derives official always-on Anthropic models without an Off segment', () => {
+    const picker = new ModelSelectorComponent({
+      models: {
+        fable: {
+          provider: 'anthropic',
+          model: 'claude-fable-5',
+          maxContextSize: 200000,
+        },
+      },
+      currentValue: 'fable',
+      currentThinkingEffort: 'high',
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+
+    const out = text(picker);
+    expect(out).toContain('Xhigh');
+    expect(out).toContain('Max');
+    expect(out).not.toContain('Off');
+  });
+
   it('cycles efforts with Left/Right and clamps at the ends', () => {
     const onSelect = vi.fn();
     const picker = new ModelSelectorComponent({
@@ -421,6 +470,45 @@ describe('ModelSelectorComponent', () => {
     // middle entry (medium), not a hardcoded level.
     expect(text(picker)).toContain('[ Medium ]');
   });
+
+  it('renders the warning line directly below the key-hint line when provided', () => {
+    const picker = new ModelSelectorComponent({
+      models: { kimi: model('Kimi K2') },
+      currentValue: 'kimi',
+      currentThinkingEffort: 'on',
+      warning: 'Switching may increase token usage.',
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+
+    const lines = picker.render(120).map(strip);
+    const hintIdx = lines.findIndex((l) => l.includes('↑↓ navigate'));
+    expect(hintIdx).toBeGreaterThanOrEqual(0);
+    expect(lines[hintIdx + 1]).toContain('Switching may increase token usage.');
+    // Model list is pushed below the inserted warning line, not overlapped.
+    expect(lines.findIndex((l) => l.includes('Kimi K2'))).toBeGreaterThan(hintIdx + 1);
+  });
+
+  it('wraps a warning longer than the width instead of truncating it', () => {
+    const warning =
+      'Note: Switching models invalidates the existing prompt cache. Use /new to avoid extra token costs.';
+    const picker = new ModelSelectorComponent({
+      models: { kimi: model('Kimi K2') },
+      currentValue: 'kimi',
+      currentThinkingEffort: 'on',
+      warning,
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+
+    const lines = picker.render(50).map(strip);
+    const hintIdx = lines.findIndex((l) => l.includes('↑↓ navigate'));
+    expect(lines[hintIdx + 1]).not.toBe('');
+    expect(lines[hintIdx + 2]).not.toBe('');
+    // Word-wrapped: nothing dropped — the full warning survives across lines.
+    const squashed = lines.join('').replaceAll(/\s+/g, '');
+    expect(squashed).toContain(warning.replaceAll(/\s+/g, ''));
+  });
 });
 
 describe('ModelSelectorComponent overrides', () => {
diff --git a/apps/kimi-code/test/tui/components/dialogs/tabbed-model-selector.test.ts b/apps/kimi-code/test/tui/components/dialogs/tabbed-model-selector.test.ts
index 28fc4210f..3f4287486 100644
--- a/apps/kimi-code/test/tui/components/dialogs/tabbed-model-selector.test.ts
+++ b/apps/kimi-code/test/tui/components/dialogs/tabbed-model-selector.test.ts
@@ -131,4 +131,26 @@ describe('TabbedModelSelectorComponent', () => {
     // It comes first, before the navigation hint.
     expect(hint!.indexOf('Tab toggle provider')).toBeLessThan(hint!.indexOf('↑↓ navigate'));
   });
+
+  it('keeps the tab strip between hint and list when a warning line is present', () => {
+    const component = new TabbedModelSelectorComponent({
+      models: {
+        k2: model('Kimi K2', 'managed:kimi-code'),
+        gpt: model('GPT-5', 'openai'),
+      },
+      currentValue: 'k2',
+      currentThinkingEffort: 'off',
+      warning: 'Switching may increase token usage.',
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+    const lines = component.render(120).map(strip);
+    const hintIdx = lines.findIndex((l) => l.includes('navigate') && l.includes('Esc cancel'));
+    expect(lines[hintIdx + 1]).toContain('Switching may increase token usage.');
+    expect(lines[hintIdx + 2]).toBe(''); // blank between warning and tabs
+    const stripIdx = lines.findIndex((l) => l.includes('All') && l.includes('openai'));
+    expect(stripIdx).toBe(hintIdx + 3);
+    expect(lines[stripIdx + 1]).toBe(''); // blank between tabs and list
+    expect(lines.findIndex((l) => l.includes('Kimi K2'))).toBeGreaterThan(stripIdx);
+  });
 });
diff --git a/apps/kimi-code/test/tui/components/editor/custom-editor.test.ts b/apps/kimi-code/test/tui/components/editor/custom-editor.test.ts
index 96598f6f5..cf7184b3b 100644
--- a/apps/kimi-code/test/tui/components/editor/custom-editor.test.ts
+++ b/apps/kimi-code/test/tui/components/editor/custom-editor.test.ts
@@ -587,6 +587,34 @@ describe('CustomEditor paste marker expansion', () => {
     editor.handleInput('x');
     expect(editor.getText()).toContain('x');
   });
+
+  it('falls back to the text paste path when the image paste handler rejects', async () => {
+    const editor = makeEditor();
+    const onTextPaste = vi.fn();
+    editor.onTextPaste = onTextPaste;
+    editor.onPasteImage = vi.fn(async () => {
+      throw new Error('clipboard backend broken');
+    });
+
+    // Regression: a rejecting onPasteImage must not leak an unhandled
+    // rejection — the CLI's crash path turns those into a silent exit.
+    const rejections: unknown[] = [];
+    const onRejection = (reason: unknown): void => {
+      rejections.push(reason);
+    };
+    process.on('unhandledRejection', onRejection);
+    try {
+      editor.handleInput(process.platform === 'win32' ? '\u001Bv' : '\u0016');
+      await new Promise((resolve) => {
+        setImmediate(resolve);
+      });
+
+      expect(onTextPaste).toHaveBeenCalledOnce();
+      expect(rejections).toHaveLength(0);
+    } finally {
+      process.off('unhandledRejection', onRejection);
+    }
+  });
 });
 
 describe('CustomEditor shortcut telemetry hooks', () => {
diff --git a/apps/kimi-code/test/tui/components/messages/goal-panel.test.ts b/apps/kimi-code/test/tui/components/messages/goal-panel.test.ts
index ed69d3a85..43e1aa8d1 100644
--- a/apps/kimi-code/test/tui/components/messages/goal-panel.test.ts
+++ b/apps/kimi-code/test/tui/components/messages/goal-panel.test.ts
@@ -55,7 +55,7 @@ describe('buildGoalReportLines', () => {
     expect(out).toContain('Running');
     expect(out).toContain('4m 12s');
     expect(out).toContain('Turns');
-    expect(out).toContain('128.4k'); // formatTokenCount
+    expect(out).toContain('125k'); // formatTokenCount
   });
 
   it('shows a no-stop-condition note for an unbounded active goal', () => {
diff --git a/apps/kimi-code/test/tui/components/messages/status-panel.test.ts b/apps/kimi-code/test/tui/components/messages/status-panel.test.ts
index e1b2b013e..1cb20833d 100644
--- a/apps/kimi-code/test/tui/components/messages/status-panel.test.ts
+++ b/apps/kimi-code/test/tui/components/messages/status-panel.test.ts
@@ -60,8 +60,8 @@ describe('status panel report lines', () => {
     expect(output).toContain('Session      ses-1');
     expect(output).toContain('Title        Implement status');
     expect(output).toContain('Context window');
-    expect(output).toContain('25.0%');
-    expect(output).toContain('(3.0k / 12.0k)');
+    expect(output).toContain('25%');
+    expect(output).toContain('(2.9k / 11.7k)');
     expect(output).toContain('Plan usage');
     expect(output).toContain('8% used');
     expect(output).not.toContain('Account');
diff --git a/apps/kimi-code/test/tui/components/messages/usage-panel.test.ts b/apps/kimi-code/test/tui/components/messages/usage-panel.test.ts
index cf2598f82..199031896 100644
--- a/apps/kimi-code/test/tui/components/messages/usage-panel.test.ts
+++ b/apps/kimi-code/test/tui/components/messages/usage-panel.test.ts
@@ -40,9 +40,9 @@ describe('UsagePanelComponent', () => {
     }).map(strip);
 
     expect(lines).toContain('Session usage');
-    expect(lines).toContain('  kimi  input 2.0k  output 250  total 2.3k');
+    expect(lines).toContain('  kimi  input 2k  output 250  total 2.2k');
     expect(lines).toContain('Context window');
-    expect(lines.join('\n')).toContain('25.0%');
+    expect(lines.join('\n')).toContain('25%');
     expect(lines).toContain('Plan usage');
     expect(lines.join('\n')).toContain('20% used');
     expect(lines.join('\n')).toContain('resets tomorrow');
diff --git a/apps/kimi-code/test/tui/components/panels/footer-context.test.ts b/apps/kimi-code/test/tui/components/panels/footer-context.test.ts
index 629cd6ec9..f7c576d9a 100644
--- a/apps/kimi-code/test/tui/components/panels/footer-context.test.ts
+++ b/apps/kimi-code/test/tui/components/panels/footer-context.test.ts
@@ -45,32 +45,50 @@ function baseState(overrides: Partial<AppState> = {}): AppState {
 }
 
 describe('FooterComponent — context NaN resilience', () => {
-  it('NaN usage → renders 0.0% (never literal "NaN%")', () => {
+  it('NaN usage → renders 0% (never literal "NaN%")', () => {
     const fc = new FooterComponent(baseState({ contextUsage: Number.NaN }));
     const out = strip(fc.render(120).join(''));
     expect(out).not.toMatch(/NaN/);
-    expect(out).toMatch(/context: 0\.0%/);
+    expect(out).toMatch(/context: 0%/);
   });
 
-  it('undefined-ish (coerced) usage → renders 0.0%', () => {
+  it('undefined-ish (coerced) usage → renders 0%', () => {
     const fc = new FooterComponent(
       baseState({ contextUsage: undefined as unknown as number }),
     );
     const out = strip(fc.render(120).join(''));
     expect(out).not.toMatch(/NaN/);
-    expect(out).toMatch(/context: 0\.0%/);
+    expect(out).toMatch(/context: 0%/);
   });
 
-  it('clamps ratios above 1.0 → renders 100.0%', () => {
+  it('clamps ratios above 1.0 → renders 100%', () => {
     const fc = new FooterComponent(baseState({ contextUsage: 1.5 }));
     const out = strip(fc.render(120).join(''));
-    expect(out).toMatch(/context: 100\.0%/);
+    expect(out).toMatch(/context: 100%/);
   });
 
-  it('ratio 0.427 → renders 42.7%', () => {
+  it('ratio 0.427 → renders 43% (ceiled whole percent)', () => {
     const fc = new FooterComponent(baseState({ contextUsage: 0.427 }));
     const out = strip(fc.render(200).join(''));
-    expect(out).toMatch(/context: 42\.7%/);
+    expect(out).toMatch(/context: 43%/);
+  });
+
+  it('tiny non-zero usage → renders 1% (ceil floor)', () => {
+    const fc = new FooterComponent(baseState({ contextUsage: 0.0004 }));
+    const out = strip(fc.render(200).join(''));
+    expect(out).toMatch(/context: 1%/);
+  });
+
+  it('valid tokens/maxTokens → percent from tokens, counts in 1024 units', () => {
+    const fc = new FooterComponent(
+      baseState({
+        contextUsage: 0.427,
+        contextTokens: 430_080,
+        maxContextTokens: 1_048_576,
+      }),
+    );
+    const out = strip(fc.render(200).join(''));
+    expect(out).toMatch(/context: 42% \(420k\/1M\)/);
   });
 
   it('renders raw / projection / all token counts when the window is known', () => {
@@ -83,7 +101,7 @@ describe('FooterComponent — context NaN resilience', () => {
       }),
     );
     const out = strip(fc.render(200).join(''));
-    expect(out).toMatch(/context: 25\.0% \(raw 400\.0k \/ projection 250\.0k \/ all 1\.0M\)/);
+    expect(out).toMatch(/context: 25% \(raw 391k \/ projection 244k \/ all 977k\)/);
   });
 
   it('tokens provided but max=0 → falls back to percent-only, no division-by-zero artefact', () => {
@@ -92,7 +110,7 @@ describe('FooterComponent — context NaN resilience', () => {
     );
     const out = strip(fc.render(200).join(''));
     expect(out).not.toMatch(/Infinity|NaN/);
-    expect(out).toMatch(/context: 0\.0%/);
+    expect(out).toMatch(/context: 0%/);
     // With maxTokens=0, token-count annotation is suppressed.
     expect(out).not.toMatch(/\(500\//);
   });
@@ -105,7 +123,7 @@ describe('FooterComponent — context NaN resilience', () => {
     const out = strip(footer.render(200).join(''));
     expect(out).toContain('kimi-k2-5');
     expect(out).not.toContain(' k2 ');
-    expect(out).toMatch(/context: 50\.0%/);
+    expect(out).toMatch(/context: 50%/);
   });
 
   it('shows "thinking" label when thinking is enabled, hides it when disabled', () => {
@@ -123,7 +141,7 @@ describe('FooterComponent — context NaN resilience', () => {
 
     const [, line2] = footer.render(120);
     expect(strip(line2 ?? '')).toContain('Press Ctrl-C again to exit');
-    expect(strip(line2 ?? '')).toContain('context: 0.0%');
+    expect(strip(line2 ?? '')).toContain('context: 0%');
   });
 
   it('highlights the pull request badge separately from git status text', () => {
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 83456780b..0ca292e13 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -20,6 +20,7 @@ import type { Event } from '@moonshot-ai/kimi-code-sdk';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { ApprovalPanelComponent } from '#/tui/components/dialogs/approval-panel';
+import { EffortSelectorComponent } from '#/tui/components/dialogs/effort-selector';
 import { KIMI_CODE_PLUGIN_MARKETPLACE_URL } from '#/constant/app';
 import { MOON_SPINNER_FRAMES } from '#/tui/constant/rendering';
 import {
@@ -4583,7 +4584,7 @@ command = "vim"
       expect(output).toContain('Permissions  auto');
       expect(output).toContain('Plan mode    on');
       expect(output).toContain('Context window');
-      expect(output).toContain('25.0%');
+      expect(output).toContain('25%');
     });
   });
 
@@ -5881,16 +5882,20 @@ describe('/model status displayName override', () => {
 });
 
 describe('/effort support_efforts override', () => {
-  it('rejects efforts hidden by support_efforts override', async () => {
+  it('warns and applies efforts hidden by an Anthropic support_efforts override', async () => {
     const session = makeSession();
     const { driver } = await makeDriver(session, {
       getConfig: vi.fn(async () => ({
+        providers: {
+          compatible: { type: 'kimi', apiKey: 'test-key' },
+        },
         models: {
           k2: {
-            provider: 'managed:kimi-code',
-            model: 'kimi-k2',
+            provider: 'compatible',
+            model: 'compatible-model',
+            protocol: 'anthropic',
             maxContextSize: 100,
-            displayName: 'Kimi K2',
+            displayName: 'Compatible Model',
             capabilities: ['thinking'],
             supportEfforts: ['low', 'high', 'max'],
             overrides: { supportEfforts: ['low', 'high'] },
@@ -5904,8 +5909,125 @@ describe('/effort support_efforts override', () => {
     await driver.handleUserInput('/effort max');
 
     await vi.waitFor(() => {
-      expect(renderTranscript(driver)).toContain('Unsupported thinking effort "max" for k2. Available: off, low, high');
+      expect(session.setThinking).toHaveBeenCalledWith('max');
     });
-    expect(renderTranscript(driver)).not.toContain('Switched to Kimi K2 with thinking max.');
+    await vi.waitFor(() => {
+      expect(renderTranscript(driver)).toContain('Thinking set to max.');
+    });
+    const transcript = renderTranscript(driver).replaceAll(/\s+/g, ' ');
+    expect(transcript).toContain(
+      'Thinking effort "max" is not listed for k2 (known: low, high). Sending "max" unchanged; the configured provider will validate it.',
+    );
+    expect(transcript).toContain('Thinking set to max.');
+  });
+
+  it('offers the latest Opus efforts for an unknown Anthropic-compatible model', async () => {
+    const { driver } = await makeDriver(makeSession(), {
+      getConfig: vi.fn(async () => ({
+        providers: {
+          compatible: { type: 'anthropic', apiKey: 'test-key' },
+        },
+        models: {
+          k2: {
+            provider: 'compatible',
+            model: 'compatible-model',
+            maxContextSize: 100,
+          },
+        },
+        defaultModel: 'k2',
+      })),
+    });
+
+    driver.handleUserInput('/effort');
+
+    await vi.waitFor(() => {
+      expect(driver.state.editorContainer.children[0]).toBeInstanceOf(EffortSelectorComponent);
+    });
+    const picker = driver.state.editorContainer.children[0] as EffortSelectorComponent;
+    expect(picker.render(80).join('\n')).toContain('Max');
+  });
+
+  it('offers no fallback efforts for an unknown model on a Kimi provider using the Anthropic protocol', async () => {
+    const { driver } = await makeDriver(makeSession(), {
+      getConfig: vi.fn(async () => ({
+        providers: {
+          compatible: { type: 'kimi', apiKey: 'test-key' },
+        },
+        models: {
+          k2: {
+            provider: 'compatible',
+            model: 'compatible-model',
+            protocol: 'anthropic',
+            maxContextSize: 100,
+          },
+        },
+        defaultModel: 'k2',
+      })),
+    });
+
+    driver.handleUserInput('/effort');
+
+    await vi.waitFor(() => {
+      expect(driver.state.editorContainer.children[0]).toBeInstanceOf(EffortSelectorComponent);
+    });
+    const picker = driver.state.editorContainer.children[0] as EffortSelectorComponent;
+    expect(picker.render(80).join('\n')).not.toContain('Max');
+  });
+
+  it('offers the latest Opus efforts for a flat providerless Anthropic model', async () => {
+    const { driver } = await makeDriver(makeSession(), {
+      getConfig: vi.fn(async () => ({
+        providers: {},
+        models: {
+          // v2 flat model shape: no named provider, inline endpoint + protocol.
+          k2: {
+            model: 'compatible-model',
+            baseUrl: 'https://anthropic.example.test',
+            protocol: 'anthropic',
+            maxContextSize: 100,
+          },
+        },
+        defaultModel: 'k2',
+      })),
+    });
+
+    driver.handleUserInput('/effort');
+
+    await vi.waitFor(() => {
+      expect(driver.state.editorContainer.children[0]).toBeInstanceOf(EffortSelectorComponent);
+    });
+    const picker = driver.state.editorContainer.children[0] as EffortSelectorComponent;
+    expect(picker.render(80).join('\n')).toContain('Max');
+  });
+
+  it('keeps rejecting efforts hidden by a Kimi support_efforts override', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session, {
+      getConfig: vi.fn(async () => ({
+        providers: {
+          kimi: { type: 'kimi', apiKey: 'test-key' },
+        },
+        models: {
+          k2: {
+            provider: 'kimi',
+            model: 'kimi-model',
+            maxContextSize: 100,
+            capabilities: ['thinking'],
+            supportEfforts: ['low', 'high'],
+          },
+        },
+        defaultModel: 'k2',
+        thinking: { enabled: true, effort: 'low' },
+      })),
+    });
+
+    driver.handleUserInput('/effort max');
+
+    await vi.waitFor(() => {
+      expect(renderTranscript(driver)).toContain(
+        'Unsupported thinking effort "max" for k2. Available: off, low, high',
+      );
+    });
+    expect(session.setThinking).not.toHaveBeenCalled();
   });
 });
diff --git a/apps/kimi-code/test/tui/message-replay.test.ts b/apps/kimi-code/test/tui/message-replay.test.ts
index 1bf0767b2..8645dd120 100644
--- a/apps/kimi-code/test/tui/message-replay.test.ts
+++ b/apps/kimi-code/test/tui/message-replay.test.ts
@@ -539,7 +539,7 @@ describe('KimiTUI resume message replay', () => {
     expect(transcript).toContain('Goal resumed');
     expect(transcript).toContain('Goal blocked');
     expect(transcript).toContain('Goal complete — done');
-    expect(transcript).toContain('Worked 1 turn over 7m15s, using 4.3k tokens.');
+    expect(transcript).toContain('Worked 1 turn over 7m15s, using 4.2k tokens.');
   });
 
   it('filters resume-normalization goal pause markers in TUI replay', async () => {
@@ -585,7 +585,7 @@ describe('KimiTUI resume message replay', () => {
     expect(entry).toMatchObject({
       kind: 'assistant',
       renderMode: 'markdown',
-      content: '✓ Goal complete.\nWorked 1 turn over 7m15s, using 4.3M tokens.',
+      content: '✓ Goal complete.\nWorked 1 turn over 7m15s, using 4.1M tokens.',
     });
   });
 
diff --git a/apps/kimi-code/test/tui/utils/goal-completion.test.ts b/apps/kimi-code/test/tui/utils/goal-completion.test.ts
index 0ef499e19..ac09feb73 100644
--- a/apps/kimi-code/test/tui/utils/goal-completion.test.ts
+++ b/apps/kimi-code/test/tui/utils/goal-completion.test.ts
@@ -20,7 +20,7 @@ describe('buildGoalCompletionMessage', () => {
     const text = buildGoalCompletionMessage(snapshot());
     expect(text).toContain('Goal complete — all tests pass.');
     expect(text).toContain('3 turns');
-    expect(text).toContain('12.5k tokens');
+    expect(text).toContain('12.2k tokens');
     expect(text).toContain('4m20s');
   });
 
diff --git a/apps/kimi-code/test/utils/usage/debug-timing.test.ts b/apps/kimi-code/test/utils/usage/debug-timing.test.ts
index 353b10ee5..5cd04ee24 100644
--- a/apps/kimi-code/test/utils/usage/debug-timing.test.ts
+++ b/apps/kimi-code/test/utils/usage/debug-timing.test.ts
@@ -39,7 +39,7 @@ describe('formatStepDebugTiming', () => {
       },
     });
     expect(result).toBe(
-      '[Debug] TTFT: 800ms | TPS: 40.0 tok/s (200 tokens in 5.0s) | tokens in 2.0k | cache read 1.2k (60%) / write 100',
+      '[Debug] TTFT: 800ms | TPS: 40.0 tok/s (200 tokens in 5.0s) | tokens in 2k | cache read 1.2k (60%) / write 100',
     );
   });
 
@@ -54,7 +54,7 @@ describe('formatStepDebugTiming', () => {
         output: 200,
       },
     });
-    expect(result).toContain('tokens in 1.0k');
+    expect(result).toContain('tokens in 1000');
     expect(result).toContain('cache read 0 (0%)');
     expect(result).not.toContain('/ write 0');
   });
diff --git a/apps/kimi-code/test/utils/usage/usage-format.test.ts b/apps/kimi-code/test/utils/usage/usage-format.test.ts
index 264bb5c55..f22078285 100644
--- a/apps/kimi-code/test/utils/usage/usage-format.test.ts
+++ b/apps/kimi-code/test/utils/usage/usage-format.test.ts
@@ -5,6 +5,8 @@ import {
   renderProgressBar,
   ratioSeverity,
   safeUsageRatio,
+  usagePercent,
+  usagePercentFromRatio,
 } from '#/utils/usage/usage-format';
 
 describe('formatTokenCount', () => {
@@ -14,15 +16,27 @@ describe('formatTokenCount', () => {
     expect(formatTokenCount(999)).toBe('999');
   });
 
-  it('rounds integers over 1k to 1 decimal', () => {
-    expect(formatTokenCount(1_000)).toBe('1.0k');
-    expect(formatTokenCount(1_234)).toBe('1.2k');
-    expect(formatTokenCount(9_876)).toBe('9.9k');
+  it('switches to k at 1024 and trims a redundant ".0"', () => {
+    expect(formatTokenCount(1_000)).toBe('1000');
+    expect(formatTokenCount(1_024)).toBe('1k');
+    expect(formatTokenCount(1_536)).toBe('1.5k');
+    expect(formatTokenCount(2_048)).toBe('2k');
   });
 
-  it('switches to M above a million', () => {
-    expect(formatTokenCount(1_000_000)).toBe('1.0M');
-    expect(formatTokenCount(2_500_000)).toBe('2.5M');
+  it('rounds k values to 1 decimal', () => {
+    expect(formatTokenCount(50_552)).toBe('49.4k');
+    expect(formatTokenCount(262_144)).toBe('256k');
+  });
+
+  it('rounds k values at or above 100k to whole k', () => {
+    expect(formatTokenCount(102_400)).toBe('100k');
+    expect(formatTokenCount(999_999)).toBe('977k');
+  });
+
+  it('switches to M at 1024*1024', () => {
+    expect(formatTokenCount(1_048_576)).toBe('1M');
+    expect(formatTokenCount(1_572_864)).toBe('1.5M');
+    expect(formatTokenCount(10_485_760)).toBe('10M');
   });
 
   it('clamps negatives and NaN to 0', () => {
@@ -32,6 +46,51 @@ describe('formatTokenCount', () => {
   });
 });
 
+describe('usagePercent', () => {
+  it('returns 0 for zero usage', () => {
+    expect(usagePercent(0, 1000)).toBe(0);
+  });
+
+  it('ceil-guarantees at least 1% for any non-zero usage', () => {
+    expect(usagePercent(4, 10_000)).toBe(1);
+  });
+
+  it('ceils fractional percentages', () => {
+    expect(usagePercent(427, 1000)).toBe(43);
+    expect(usagePercent(992, 1000)).toBe(100);
+  });
+
+  it('clamps to 100 when used meets or exceeds max', () => {
+    expect(usagePercent(1000, 1000)).toBe(100);
+    expect(usagePercent(1200, 1000)).toBe(100);
+  });
+
+  it('returns 0 for a non-positive or non-finite max', () => {
+    expect(usagePercent(500, 0)).toBe(0);
+    expect(usagePercent(500, -1)).toBe(0);
+    expect(usagePercent(500, Number.NaN)).toBe(0);
+  });
+});
+
+describe('usagePercentFromRatio', () => {
+  it('coerces NaN to 0', () => {
+    expect(usagePercentFromRatio(Number.NaN)).toBe(0);
+  });
+
+  it('returns 0 for zero usage', () => {
+    expect(usagePercentFromRatio(0)).toBe(0);
+  });
+
+  it('ceil-guarantees at least 1% for any non-zero ratio', () => {
+    expect(usagePercentFromRatio(0.004)).toBe(1);
+  });
+
+  it('ceils fractional percentages and clamps above 100', () => {
+    expect(usagePercentFromRatio(0.427)).toBe(43);
+    expect(usagePercentFromRatio(1.5)).toBe(100);
+  });
+});
+
 describe('renderProgressBar', () => {
   it('empty bar at ratio 0', () => {
     expect(renderProgressBar(0, 10)).toBe('░'.repeat(10));
diff --git a/apps/kimi-web/index.html b/apps/kimi-web/index.html
index dff0375e4..67fc5d790 100644
--- a/apps/kimi-web/index.html
+++ b/apps/kimi-web/index.html
@@ -3,25 +3,16 @@
   <head>
     <meta charset="UTF-8" />
     <link rel="icon" href="/favicon.ico" sizes="64x64" />
-    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, viewport-fit=cover" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, viewport-fit=cover, interactive-widget=resizes-content" />
     <meta name="color-scheme" content="light dark" />
     <meta name="theme-color" content="#ffffff" media="(prefers-color-scheme: light)" />
     <meta name="theme-color" content="#0d1117" media="(prefers-color-scheme: dark)" />
     <!-- Apply persisted display prefs BEFORE the bundle loads: without this,
          users can get a color-scheme/font flash before useKimiWebClient mirrors
-         the data attributes. Mirrors applyColorSchemeToDocument. -->
-    <script>
-      (function () {
-        try {
-          var v = localStorage.getItem('kimi-web.color-scheme');
-          if (v === 'light' || v === 'dark' || v === 'system') {
-            document.documentElement.dataset.colorScheme = v;
-          }
-        } catch (e) {
-          /* ignore */
-        }
-      })();
-    </script>
+         the data attributes. Mirrors applyColorSchemeToDocument. Loaded from the
+         external /boot.js (a classic script, so still render-blocking) because
+         the server's Content-Security-Policy forbids inline scripts. -->
+    <script src="/boot.js"></script>
     <title>Kimi Code Web</title>
   </head>
   <body>
diff --git a/apps/kimi-web/public/boot.js b/apps/kimi-web/public/boot.js
new file mode 100644
index 000000000..ec495553a
--- /dev/null
+++ b/apps/kimi-web/public/boot.js
@@ -0,0 +1,10 @@
+(function () {
+  try {
+    var v = localStorage.getItem('kimi-web.color-scheme');
+    if (v === 'light' || v === 'dark' || v === 'system') {
+      document.documentElement.dataset.colorScheme = v;
+    }
+  } catch {
+    /* ignore */
+  }
+})();
diff --git a/apps/kimi-web/src/App.vue b/apps/kimi-web/src/App.vue
index 5674a55ec..f8ab512d3 100644
--- a/apps/kimi-web/src/App.vue
+++ b/apps/kimi-web/src/App.vue
@@ -27,6 +27,9 @@ import GlobalLoading from './components/GlobalLoading.vue';
 import DebugPanel from './debug/DebugPanel.vue';
 import { isTraceEnabled } from './debug/trace';
 import { useKimiWebClient } from './composables/useKimiWebClient';
+import { useConfirmDialog } from './composables/useConfirmDialog';
+import type { PromptAttachment } from './composables/useKimiWebClient';
+import type { TurnAttachment } from './types';
 import { useAuthGate } from './composables/useAuthGate';
 import { usePageTitle } from './composables/usePageTitle';
 import { useSidebarLayout } from './composables/useSidebarLayout';
@@ -72,6 +75,7 @@ provide(
   (toolCallId: string): SwarmMember[] => client.swarmMembersByToolCallId.value.get(toolCallId) ?? [],
 );
 const { t } = useI18n();
+const { confirm } = useConfirmDialog();
 
 // KAP/daemon debug panel — opt-in via ?debug=1 or localStorage kimi-web.debug=1.
 const debugEnabled = isTraceEnabled();
@@ -143,6 +147,28 @@ function openOnboarding(): void {
   showOnboarding.value = true;
 }
 
+// iOS Safari does not shrink `dvh` for the on-screen keyboard. Instead it pans
+// the visual viewport (offsetTop > 0) to reveal the focused field, which a
+// 100dvh in-flow shell cannot follow: the dock ends up behind the keyboard, or
+// the page shows a blank band past the shell's bottom edge. Pin the shell to
+// the VISUAL viewport instead: position:fixed + top/height mirrored from
+// visualViewport (height shrinks with the keyboard, offsetTop tracks the pan).
+// No-ops on desktop, where offsetTop is 0 and height equals innerHeight.
+let appHeightRaf = 0;
+function setAppHeight(): void {
+  const vv = window.visualViewport;
+  const root = document.documentElement.style;
+  root.setProperty('--app-height', `${vv?.height ?? window.innerHeight}px`);
+  root.setProperty('--app-top', `${vv?.offsetTop ?? 0}px`);
+}
+function syncAppHeight(): void {
+  if (appHeightRaf) return;
+  appHeightRaf = requestAnimationFrame(() => {
+    appHeightRaf = 0;
+    setAppHeight();
+  });
+}
+
 onMounted(() => {
   // Register the 401 listener before the first requests go out, so a token
   // rejection during the initial load() can never be missed.
@@ -154,6 +180,10 @@ onMounted(() => {
   });
   void client.load();
   loadSidebarCollapsed();
+  setAppHeight();
+  window.visualViewport?.addEventListener('resize', syncAppHeight);
+  window.visualViewport?.addEventListener('scroll', syncAppHeight);
+  window.addEventListener('resize', syncAppHeight);
   // Capture-phase so Escape closes the side detail layer BEFORE the
   // conversation pane's bubble-phase handler interrupts a running prompt.
   document.addEventListener('keydown', onGlobalKeydown, true);
@@ -161,6 +191,15 @@ onMounted(() => {
 
 onUnmounted(() => {
   document.removeEventListener('keydown', onGlobalKeydown, true);
+  window.visualViewport?.removeEventListener('resize', syncAppHeight);
+  window.visualViewport?.removeEventListener('scroll', syncAppHeight);
+  window.removeEventListener('resize', syncAppHeight);
+  if (appHeightRaf) {
+    cancelAnimationFrame(appHeightRaf);
+    appHeightRaf = 0;
+  }
+  document.documentElement.style.removeProperty('--app-height');
+  document.documentElement.style.removeProperty('--app-top');
   if (offAuthRequired !== null) {
     offAuthRequired();
     offAuthRequired = null;
@@ -283,7 +322,7 @@ const showSettings = ref(false);
 
 type SubmitPayload = {
   text: string;
-  attachments: { fileId: string; kind: 'image' | 'video' }[];
+  attachments: PromptAttachment[];
 };
 const pendingWorkspaceSubmit = ref<SubmitPayload | null>(null);
 // Inline error shown inside the add-workspace picker after the daemon rejects
@@ -321,8 +360,10 @@ async function openModelPicker(): Promise<void> {
   modelsUnavailable.value = false;
   showModelPicker.value = true;
   try {
-    await client.refreshOAuthProviderModels();
-    await client.loadModels();
+    // Full refresh first (every refreshable provider, not just OAuth), so the
+    // list always reflects the live catalog — the WS model-catalog event that
+    // used to keep the cache warm is no longer forwarded by the daemon.
+    await client.refreshAllProviders();
   } catch {
     modelsUnavailable.value = true;
   } finally {
@@ -376,14 +417,43 @@ async function handleAddProvider(input: { type: string; apiKey?: string; baseUrl
   await client.addProvider(input);
 }
 
-async function handleDeleteProvider(id: string): Promise<void> {
-  await client.deleteProvider(id);
-}
-
 async function handleRefreshProvider(id: string): Promise<void> {
   await client.refreshProvider(id);
 }
 
+// Destructive session/workspace/provider actions confirm through the shared
+// modal here (the menu components only emit the intent). Each passes its work
+// as the dialog `action`, so the dialog stays open with a loading state until
+// the operation settles. All three client calls toast their own errors and
+// never reject.
+async function confirmArchiveSession(id: string): Promise<void> {
+  await confirm({
+    title: t('sidebar.archive'),
+    message: t('sidebar.archiveConfirm'),
+    variant: 'danger',
+    action: () => client.archiveSession(id),
+  });
+}
+
+async function confirmDeleteWorkspace(id: string): Promise<void> {
+  const name = client.workspacesView.value.find((w) => w.id === id)?.name ?? id;
+  await confirm({
+    title: t('sidebar.removeWorkspace'),
+    message: t('workspace.removeWorkspaceConfirm', { name }),
+    variant: 'danger',
+    action: () => client.deleteWorkspace(id),
+  });
+}
+
+async function confirmDeleteProvider(id: string): Promise<void> {
+  await confirm({
+    title: t('providers.delete'),
+    message: t('providers.confirmDelete'),
+    variant: 'danger',
+    action: () => client.deleteProvider(id),
+  });
+}
+
 async function handleUpdateConfig(patch: Partial<AppConfig>): Promise<void> {
   configSaving.value = true;
   try {
@@ -420,11 +490,11 @@ async function handleLoginSuccess(): Promise<void> {
 // then drop that message's text back into the composer for editing.
 async function handleEditMessage(payload: {
   text: string;
-  images?: { url: string; alt?: string; kind: 'image' | 'video'; fileId?: string }[];
+  attachments?: TurnAttachment[];
 }): Promise<void> {
   await client.undo(1);
   await nextTick();
-  conversationPaneRef.value?.loadComposerForEdit(payload.text, payload.images);
+  conversationPaneRef.value?.loadComposerForEdit(payload.text, payload.attachments);
 }
 
 // Handler for slash commands emitted by Composer (via ConversationPane)
@@ -671,11 +741,11 @@ function openPr(url: string): void {
         @select-workspace="client.openWorkspace($event)"
         @add-workspace="showAddWorkspace = true"
         @rename="(id, title) => client.renameSession(id, title)"
-        @archive="(id) => client.archiveSession(id)"
+        @archive="confirmArchiveSession($event)"
         @fork="(id) => client.forkSession(id)"
         @export="(id) => client.exportSession(id)"
         @rename-workspace="(id, name) => client.renameWorkspace(id, name)"
-        @delete-workspace="(id) => client.deleteWorkspace(id)"
+        @delete-workspace="confirmDeleteWorkspace($event)"
         @reorder-workspaces="client.reorderWorkspaces($event)"
         @set-workspace-sort-mode="client.setWorkspaceSortMode($event)"
         @load-more-sessions="(id) => void client.loadMoreSessions(id)"
@@ -732,10 +802,11 @@ function openPr(url: string): void {
       :pending-question-actions="client.pendingQuestionActions"
       :pending-approval-actions="client.pendingApprovalActions"
       :running="running"
+      :turn-active="client.turnActive.value"
       :queued="client.queued.value"
       :search-files="client.searchFiles"
       :upload-image="client.uploadImage"
-      :sending="client.isSending.value"
+      :working="client.working.value"
       :starting="client.isStartingFirstPrompt.value"
       :fast-moon="client.fastMoon.value"
       :file-reload-key="client.activeSessionId.value"
@@ -778,7 +849,7 @@ function openPr(url: string): void {
       @refresh-git-status="client.activeSessionId.value && client.loadGitStatus(client.activeSessionId.value)"
       @rename-session="(id, title) => client.renameSession(id, title)"
       @fork-session="(id) => client.forkSession(id)"
-      @archive-session="(id) => client.archiveSession(id)"
+      @archive-session="confirmArchiveSession($event)"
       @export-session="(id) => client.exportSession(id)"
       @compact="client.compact()"
       @pick-model="openModelPicker()"
@@ -957,7 +1028,7 @@ function openPr(url: string): void {
       :unavailable="providersUnavailable"
       @add="handleAddProvider($event)"
       @refresh="handleRefreshProvider($event)"
-      @delete="handleDeleteProvider($event)"
+      @delete="confirmDeleteProvider($event)"
       @open-login="() => { showProviders = false; openLogin(); }"
       @close="showProviders = false"
     />
@@ -1022,8 +1093,8 @@ function openPr(url: string): void {
       @create-in-workspace="handleCreateSessionInWorkspace($event)"
       @add-workspace="showAddWorkspace = true"
       @rename="(id, title) => client.renameSession(id, title)"
-      @archive="(id) => client.archiveSession(id)"
-      @delete-workspace="(id) => client.deleteWorkspace(id)"
+      @archive="confirmArchiveSession($event)"
+      @delete-workspace="confirmDeleteWorkspace($event)"
       @load-more="(id) => void client.loadMoreSessions(id)"
     />
 
@@ -1071,8 +1142,17 @@ function openPr(url: string): void {
 .gload-fade-leave-to { opacity: 0; }
 
 .app-shell {
+  /* Pinned to the visual viewport (see setAppHeight): --app-top tracks iOS's
+     keyboard pan and --app-height shrinks with the keyboard, so the shell
+     always covers exactly the visible area. Fixed positioning keeps it out of
+     the document flow that iOS pans. */
+  position: fixed;
+  top: var(--app-top, 0px);
+  left: 0;
+  right: 0;
   height: 100vh;
   height: 100dvh;
+  height: var(--app-height, 100dvh);
   display: flex;
   flex-direction: column;
   overflow: hidden;
@@ -1248,10 +1328,10 @@ function openPr(url: string): void {
   .auth-page {
     align-items: flex-start;
     padding:
-      max(48px, env(safe-area-inset-top))
-      max(20px, env(safe-area-inset-right))
-      max(24px, env(safe-area-inset-bottom))
-      max(20px, env(safe-area-inset-left));
+      max(48px, var(--safe-top))
+      max(20px, var(--safe-right))
+      max(24px, var(--safe-bottom))
+      max(20px, var(--safe-left));
   }
   .auth-page-copy h1 {
     font-size: 26px;
diff --git a/apps/kimi-web/src/api/daemon/agentEventProjector.ts b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
index 17d4cf542..88c47b799 100644
--- a/apps/kimi-web/src/api/daemon/agentEventProjector.ts
+++ b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
@@ -57,6 +57,7 @@ const MAIN_AGENT_TRANSCRIPT_FRAMES = new Set<string>([
   'tool.result',
   'agent.status.updated',
   'prompt.completed',
+  'prompt.aborted',
   'error',
 ]);
 
@@ -127,6 +128,10 @@ interface SessionState {
   // Subagent lifecycle deltas after spawned only carry subagentId. Keep the
   // spawned metadata here so later updates can replace the full AppTask.
   subagentMeta: Map<string, AppTask>;
+
+  // Bubble cleared by turn.step.retrying, to be reused by the retried
+  // step.started (same turn) instead of stacking a new bubble.
+  retryReuseMsgId: string | undefined;
 }
 
 function createSessionState(): SessionState {
@@ -148,6 +153,7 @@ function createSessionState(): SessionState {
     model: '',
     messages: [],
     subagentMeta: new Map(),
+    retryReuseMsgId: undefined,
   };
 }
 
@@ -699,12 +705,11 @@ export function createAgentProjector(): AgentProjector {
       // -----------------------------------------------------------------------
       case 'turn.started': {
         // Bind turnId → promptId. Generate a synthetic one if none was pre-bound.
-        // Session status is intentionally NOT projected here — the daemon's
-        // `event.session.status_changed` is the single source of status
-        // transitions (it carries the authoritative previousStatus /
-        // currentPromptId and dedupes per real transition); projecting a
-        // second running/idle event per turn from the raw stream made every
-        // turn-end consumer (notifications, sounds) fire twice.
+        // Session busy is intentionally NOT projected here — the daemon's
+        // `event.session.work_changed` is the single source of the busy fact
+        // (it re-reads the authoritative drain registry and dedupes per real
+        // transition); projecting a second busy flip per turn from the raw
+        // stream made every turn-end consumer fire twice.
         const turnId: number = p?.turnId;
         const existingPromptId = s.currentPromptId ?? ulid('pr_');
         s.currentPromptId = existingPromptId;
@@ -714,6 +719,9 @@ export function createAgentProjector(): AgentProjector {
         // Fresh turn → fresh step stream offsets.
         s.turnTextLen = 0;
         s.turnThinkLen = 0;
+        // Main-conversation liveness (the moon) keys off the main agent's turn
+        // boundary directly — only main-agent frames reach this switch arm.
+        out.push({ type: 'turnActiveChanged', sessionId, active: true });
         break;
       }
 
@@ -736,6 +744,17 @@ export function createAgentProjector(): AgentProjector {
         s.turnTextLen = 0;
         s.turnThinkLen = 0;
 
+        // A retry continuation: refill the bubble turn.step.retrying cleared,
+        // instead of creating a second bubble with the same step's content.
+        if (s.retryReuseMsgId !== undefined) {
+          const reuseId = s.retryReuseMsgId;
+          s.retryReuseMsgId = undefined;
+          if (getMsgById(s, reuseId) !== undefined) {
+            s.currentAssistantMsgId = reuseId;
+            break;
+          }
+        }
+
         // Create a new pending assistant message
         const msg = startAssistantMessage(s, sessionId, promptId);
         s.currentAssistantMsgId = msg.id;
@@ -957,6 +976,16 @@ export function createAgentProjector(): AgentProjector {
         const reason: string = p?.reason ?? 'completed';
         const durationMs = numberField(p ?? {}, 'durationMs');
 
+        // Main-conversation liveness: the prompt this turn served is done.
+        // This — not the session-busy status — is what ends the working moon.
+        // It MUST be emitted first in this arm: the onMainTurnEnd side effect
+        // gates on `seq > lastSeqBySession`, and sibling events in this arm
+        // advance that cursor — emitted after them, this event would compare
+        // equal and the prompt-finish cleanup (moon, queue drain) would never
+        // fire (observed: moon stuck when a turn ends with background tasks
+        // still running, where no work_changed(busy:false) fallback exists).
+        out.push({ type: 'turnActiveChanged', sessionId, active: false, reason: p?.reason });
+
         if (msgId) {
           finishAssistantMessage(s, msgId);
           const msg = getMsgById(s, msgId);
@@ -976,30 +1005,86 @@ export function createAgentProjector(): AgentProjector {
         const usageSnapshot = buildUsageSnapshot(s);
         out.push({ type: 'sessionUsageUpdated', sessionId, usage: usageSnapshot });
 
-        // No sessionStatusChanged here — see turn.started. The daemon's
-        // `event.session.status_changed` flips the session to idle/aborted.
+        // No busy projection here — see turn.started. The daemon's
+        // `event.session.work_changed` flips the session busy fact.
 
         // Clear per-turn state. Reset the stream offsets too so a stale length
         // from this turn can't wedge the next turn's delta alignment into a
-        // silent skip if its turn.started is missed across a reconnect.
+        // silent skip if its turn.started is missed across a reconnect. The
+        // retry reuse target is per-turn as well: if the turn died between
+        // turn.step.retrying and the retried step.started, the next prompt
+        // must open a fresh bubble, not refill this turn's emptied one.
         s.currentAssistantMsgId = undefined;
         s.currentPromptId = undefined;
         s.turnTextLen = 0;
         s.turnThinkLen = 0;
+        s.retryReuseMsgId = undefined;
         break;
       }
 
       // -----------------------------------------------------------------------
       case 'prompt.completed': {
-        // No-op at AppEvent level — turn.ended already handles the transition to idle
+        // No state change at AppEvent level — turn.ended / the session
+        // status_changed ahead of this event already finished the prompt. The
+        // event rides along so the web layer can spot the one case that has no
+        // turn-level signal: a prompt blocked before any turn started (reason
+        // 'blocked'), which would otherwise pin the in-flight state forever.
+        const promptId: string | undefined = p?.promptId;
+        if (typeof promptId === 'string' && promptId.length > 0) {
+          out.push({ type: 'promptCompleted', sessionId, promptId, reason: p?.reason ?? 'completed' });
+        }
         break;
       }
 
       // -----------------------------------------------------------------------
-      case 'turn.step.retrying':
+      case 'prompt.aborted': {
+        // Fires both for an active-turn abort (a turn.ended + status_changed
+        // precede it — the prompt is already finished) and for a QUEUED prompt
+        // that never started a turn (no turn events, no status flip). The web
+        // layer keys on promptId to clear the in-flight state in the latter case.
+        const promptId: string | undefined = p?.promptId;
+        if (typeof promptId === 'string' && promptId.length > 0) {
+          out.push({ type: 'promptAborted', sessionId, promptId });
+        }
+        break;
+      }
+
+      // -----------------------------------------------------------------------
+      case 'turn.step.retrying': {
+        // The step's stream restarts from offset 0. Reuse the abandoned
+        // bubble instead of stacking a new one: strip its streamed parts and
+        // keep the id in retryReuseMsgId so the retried step.started refills
+        // it in place. Otherwise the failed attempt's partial bubble stays
+        // rendered next to the retry's full stream — the "text/tool shown
+        // twice" duplication (far more visible since the retry budget grew).
+        const msgId = s.currentAssistantMsgId;
+        if (msgId !== undefined) {
+          const msg = getMsgById(s, msgId);
+          if (msg !== undefined) {
+            msg.content = msg.content.filter(
+              (c) => c.type !== 'text' && c.type !== 'thinking' && c.type !== 'toolUse',
+            );
+            out.push({
+              type: 'messageUpdated',
+              sessionId,
+              messageId: msgId,
+              content: msg.content.map((c) => ({ ...c })),
+              status: 'pending',
+            });
+            s.retryReuseMsgId = msgId;
+          }
+        }
+        s.turnTextLen = 0;
+        s.turnThinkLen = 0;
+        s.toolStartTimes.clear();
+        break;
+      }
+
       case 'turn.step.interrupted': {
-        // Discard current assistant message; next step.started will create a new one
+        // Discard current assistant message; next step.started will create a
+        // new one. Drop any pending retry reuse target for the same reason.
         s.currentAssistantMsgId = undefined;
+        s.retryReuseMsgId = undefined;
         break;
       }
 
@@ -1088,10 +1173,20 @@ export function createAgentProjector(): AgentProjector {
 
       // -----------------------------------------------------------------------
       case 'error': {
-        // Fold into an unknown event so the reducer pushes a warning string
+        // Fold into an unknown event so the reducer surfaces it as a structured
+        // error notice (semantic title + code/status/requestId details). The
+        // wire payload already carries name/details/retryable — pass them
+        // through untouched; the reducer decides what to display.
         out.push({
           type: 'unknown',
-          raw: { _agentError: true, code: p?.code, message: p?.message },
+          raw: {
+            _agentError: true,
+            code: p?.code,
+            message: p?.message,
+            name: p?.name,
+            details: p?.details,
+            retryable: p?.retryable,
+          },
         });
         break;
       }
@@ -1124,6 +1219,48 @@ export function createAgentProjector(): AgentProjector {
             : typeof info.command === 'string'
               ? info.command
               : i18n.global.t('tasks.defaultDescription');
+        // A background subagent registers into the background-task store under
+        // a fresh task id that differs from its agent id. Record the task id on
+        // the existing WS-owned row (keyed by agent id) instead of adding a
+        // second row — REST `/tasks` returns the same agent keyed by task id,
+        // and keepLiveSubagents folds that copy into this row.
+        if (info.kind === 'agent') {
+          const agentId =
+            typeof info.agentId === 'string' && info.agentId.length > 0
+              ? info.agentId
+              : undefined;
+          if (agentId !== undefined) {
+            // Key by agent id even when the spawn event never reached this
+            // client (subscribed late): later agent-scoped progress frames are
+            // routed by agent id, and seeding subagentMeta here keeps them on
+            // this one row instead of synthesizing a second one.
+            const task = patchSubagent(s, sessionId, agentId, {
+              description,
+              backgroundTaskId: taskId,
+              runInBackground: true,
+            });
+            if (task) out.push({ type: 'taskCreated', sessionId, task });
+          } else {
+            // No agent id — nothing to link; key the row by the background
+            // task id so the REST poll dedupes it.
+            out.push({
+              type: 'taskCreated',
+              sessionId,
+              task: {
+                id: taskId,
+                sessionId,
+                kind: 'subagent',
+                description,
+                status: 'running',
+                createdAt: startedAt ?? new Date().toISOString(),
+                startedAt,
+                subagentPhase: 'queued',
+                runInBackground: true,
+              },
+            });
+          }
+          break;
+        }
         const command = typeof info.command === 'string' ? info.command : undefined;
         out.push({
           type: 'taskCreated',
@@ -1318,6 +1455,7 @@ const KNOWN_AGENT_CORE_TYPES = new Set([
   'agent.status.updated',
   'prompt.submitted',
   'prompt.completed',
+  'prompt.aborted',
   'session.meta.updated',
   'compaction.started',
   'compaction.completed',
diff --git a/apps/kimi-web/src/api/daemon/client.ts b/apps/kimi-web/src/api/daemon/client.ts
index 30c883910..714ff47e2 100644
--- a/apps/kimi-web/src/api/daemon/client.ts
+++ b/apps/kimi-web/src/api/daemon/client.ts
@@ -17,7 +17,6 @@ import type {
   AppSessionCursor,
   AppSessionRuntimeStatus,
   AppSessionSnapshot,
-  AppSessionStatus,
   AppTask,
   AppTaskStatus,
   AppTerminal,
@@ -52,7 +51,6 @@ import {
   toWireApprovalResponse,
   toWirePromptSubmission,
   toWireQuestionResponse,
-  toWireSessionStatus,
   toAppWorkspace,
   wireEventSeq,
   wireEventSessionId,
@@ -347,7 +345,7 @@ export class DaemonKimiWebApi implements KimiWebApi {
 
   async listSessions(
     input?: PageRequest & {
-      status?: AppSessionStatus;
+      busy?: boolean;
       workspaceId?: string;
       includeArchive?: boolean;
       archivedOnly?: boolean;
@@ -358,7 +356,7 @@ export class DaemonKimiWebApi implements KimiWebApi {
       before_id: input?.beforeId,
       after_id: input?.afterId,
       page_size: input?.pageSize,
-      status: input?.status ? toWireSessionStatus(input.status) : undefined,
+      busy: input?.busy,
       include_archive: input?.includeArchive,
       archived_only: input?.archivedOnly,
       exclude_empty: input?.excludeEmpty,
@@ -566,7 +564,7 @@ export class DaemonKimiWebApi implements KimiWebApi {
       };
       traceKeyEvent('session:snapshot:accepted', {
         sessionId,
-        status: snapshot.session.status,
+        busy: snapshot.session.busy,
         seq: snapshot.asOfSeq,
         messageCount: snapshot.messages.length,
         durationMs: Date.now() - startedAt,
@@ -1178,8 +1176,6 @@ export class DaemonKimiWebApi implements KimiWebApi {
           name: e.name,
           path: e.path,
           isDir: e.is_dir,
-          isGitRepo: e.is_git_repo,
-          branch: e.branch,
         })),
       };
     } catch {
@@ -1435,6 +1431,18 @@ export class DaemonKimiWebApi implements KimiWebApi {
         const { type, seq, session_id: sessionId, payload, offset } = frame;
         const appEvents = projector.project(type, payload, sessionId, { offset });
         for (const appEvent of appEvents) {
+          const turnId = (payload as { turnId?: unknown } | null)?.turnId;
+          const stream =
+            appEvent.type === 'assistantDelta' &&
+            typeof turnId === 'number' &&
+            typeof offset === 'number' &&
+            (type === 'assistant.delta' || type === 'thinking.delta')
+              ? {
+                  turnId,
+                  offset,
+                  kind: type === 'assistant.delta' ? ('text' as const) : ('thinking' as const),
+                }
+              : undefined;
           // historyCompacted from the projector is either a compaction signal
           // (reason auto_compact — no reload, the divider marker handles it) or
           // a delta-gap recovery (reason delta_gap — a real resync, routed to
@@ -1442,7 +1450,7 @@ export class DaemonKimiWebApi implements KimiWebApi {
           if (appEvent.type === 'historyCompacted' && !isCompactionReason(appEvent.reason)) {
             handlers.onResync(sessionId, seq);
           }
-          handlers.onEvent(appEvent, { sessionId, seq });
+          handlers.onEvent(appEvent, { sessionId, seq, stream });
         }
       },
 
diff --git a/apps/kimi-web/src/api/daemon/eventReducer.ts b/apps/kimi-web/src/api/daemon/eventReducer.ts
index 667b70f7d..4916bfa7b 100644
--- a/apps/kimi-web/src/api/daemon/eventReducer.ts
+++ b/apps/kimi-web/src/api/daemon/eventReducer.ts
@@ -15,6 +15,8 @@ import type {
   AppGoal,
   AppMessage,
   AppMessageContent,
+  AppNotice,
+  AppNoticeDetail,
   AppWarning,
   AppQuestionRequest,
   AppSession,
@@ -66,6 +68,11 @@ export interface KimiClientState {
    *  live event won the race even when the goal entry stayed absent. */
   goalVersionBySession: Record<string, number>;
   lastSeqBySession: Record<string, number>;
+  /** MAIN-agent turn in flight, per session — set from the main agent's
+   *  turn.started/turn.ended boundary events and seeded from the snapshot's
+   *  (main-only) inFlightTurn. Half of the working moon; subagent turns never
+   *  reach the events that set this. */
+  turnActiveBySession: Record<string, boolean>;
   compactionBySession: Record<string, CompactionStatus>;
   config?: AppConfig | null;
   warnings: AppWarning[];
@@ -83,6 +90,7 @@ export function createInitialState(): KimiClientState {
     goalBySession: {},
     goalVersionBySession: {},
     lastSeqBySession: {},
+    turnActiveBySession: {},
     compactionBySession: {},
     warnings: [],
   };
@@ -110,6 +118,7 @@ function cloneState(s: KimiClientState): KimiClientState {
     goalBySession: { ...s.goalBySession },
     goalVersionBySession: { ...s.goalVersionBySession },
     lastSeqBySession: { ...s.lastSeqBySession },
+    turnActiveBySession: { ...s.turnActiveBySession },
     compactionBySession: { ...s.compactionBySession },
     warnings: [...s.warnings],
   };
@@ -229,6 +238,64 @@ function appendToolOutputToMessages(messages: AppMessage[], toolCallId: string,
 // Reducer
 // ---------------------------------------------------------------------------
 
+/** Agent error code → semantic title key under `warnings.agentError`. Codes
+ *  come from the protocol error domain (agent-core-v2 `ProtocolErrors`);
+ *  anything unmapped falls back to the generic `title`. */
+const AGENT_ERROR_TITLE_KEYS: Readonly<Record<string, string>> = {
+  'provider.connection_error': 'connection',
+  'provider.auth_error': 'auth',
+  'provider.rate_limit': 'rateLimit',
+  'provider.overloaded': 'overloaded',
+  'provider.filtered': 'filtered',
+  'provider.api_error': 'api',
+  'context.overflow': 'contextOverflow',
+};
+
+interface AgentErrorRaw {
+  code?: string;
+  message?: string;
+  name?: string;
+  details?: Record<string, unknown>;
+}
+
+/**
+ * Build the structured error notice for a failed agent turn (typically a
+ * model-provider failure). The wire payload already carries the coded error —
+ * surface it in full so a rate-limit / auth / endpoint failure is diagnosable
+ * from the toast: semantic title, the provider's raw message as the body, and
+ * a diagnostics list (error code, HTTP status, request id, SDK error name,
+ * plus any extra detail fields such as finishReason).
+ */
+function buildAgentErrorNotice(raw: AgentErrorRaw): AppNotice {
+  const t = i18n.global.t;
+  const details: AppNoticeDetail[] = [];
+  const push = (label: string, value: unknown): void => {
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      details.push({ label, value: String(value) });
+    } else if (typeof value === 'string' && value.length > 0) {
+      details.push({ label, value });
+    }
+  };
+  push(t('warnings.details.code'), raw.code);
+  const rawDetails = raw.details ?? {};
+  push(t('warnings.details.status'), rawDetails['statusCode']);
+  push(t('warnings.details.requestId'), rawDetails['requestId']);
+  push(t('warnings.details.errorName'), raw.name);
+  // Keep any remaining detail fields (finishReason, rawFinishReason, …) so no
+  // diagnostics the daemon sent are hidden.
+  for (const [key, value] of Object.entries(rawDetails)) {
+    if (key === 'statusCode' || key === 'requestId') continue;
+    push(key, value);
+  }
+  const titleKey = (raw.code !== undefined ? AGENT_ERROR_TITLE_KEYS[raw.code] : undefined) ?? 'title';
+  return {
+    severity: 'error',
+    title: t(`warnings.agentError.${titleKey}`),
+    message: raw.message,
+    details: details.length > 0 ? details : undefined,
+  };
+}
+
 /**
  * Apply a single AppEvent to the state, returning a new state object.
  * The event carries `_wireSeq` and `_wireSessionId` as hidden extras when
@@ -282,6 +349,7 @@ export function reduceAppEvent(
       delete next.approvalsBySession[id];
       delete next.questionsBySession[id];
       delete next.lastSeqBySession[id];
+      delete next.turnActiveBySession[id];
       if (next.activeSessionId === id) {
         next.activeSessionId = undefined;
       }
@@ -289,15 +357,25 @@ export function reduceAppEvent(
     }
 
     // -------------------------------------------------------------------------
-    case 'sessionStatusChanged': {
+    case 'sessionWorkChanged': {
       next.sessions = next.sessions.map((s) => {
         if (s.id !== event.sessionId) return s;
         return {
           ...s,
-          status: event.status,
-          currentPromptId: event.currentPromptId,
+          busy: event.busy,
+          mainTurnActive: event.mainTurnActive ?? (event.busy ? s.mainTurnActive : false),
+          pendingInteraction: event.pendingInteraction ?? s.pendingInteraction,
+          // Authoritative, not nullish-merge: an omitted last_turn_reason is
+          // how the server says "no current outcome" (a fresh turn cleared
+          // the previous one), so the stale value must not survive.
+          lastTurnReason: event.lastTurnReason,
         };
       });
+      if (event.mainTurnActive === true) {
+        next.turnActiveBySession[event.sessionId] = true;
+      } else if (event.mainTurnActive === false || !event.busy) {
+        delete next.turnActiveBySession[event.sessionId];
+      }
       break;
     }
 
@@ -582,6 +660,7 @@ export function reduceAppEvent(
           parentToolCallId: event.task.parentToolCallId ?? previous.parentToolCallId,
           subagentType: event.task.subagentType ?? previous.subagentType,
           runInBackground: event.task.runInBackground ?? previous.runInBackground,
+          backgroundTaskId: event.task.backgroundTaskId ?? previous.backgroundTaskId,
         };
         next.tasksBySession[sid] = patched;
       }
@@ -664,6 +743,29 @@ export function reduceAppEvent(
     case 'agentTurnEnded':
       break;
 
+    // -------------------------------------------------------------------------
+    // Prompt-level lifecycle events drive the web layer's in-flight cleanup
+    // (see useKimiWebClient.processEvent), not reducer state. Advance seq
+    // silently.
+    case 'promptCompleted':
+    case 'promptAborted':
+      break;
+
+    // -------------------------------------------------------------------------
+    case 'turnActiveChanged': {
+      next.sessions = next.sessions.map((session) =>
+        session.id === event.sessionId
+          ? { ...session, mainTurnActive: event.active }
+          : session,
+      );
+      if (event.active) {
+        next.turnActiveBySession[event.sessionId] = true;
+      } else {
+        delete next.turnActiveBySession[event.sessionId];
+      }
+      break;
+    }
+
     case 'unknown': {
       // Distinguish no-op known events (sentinel _noop) from agent errors/warnings
       // and truly unknown events.
@@ -673,18 +775,20 @@ export function reduceAppEvent(
         _agentWarning?: boolean;
         code?: string;
         message?: string;
+        name?: string;
+        details?: Record<string, unknown>;
         type?: string;
       } | null;
       if (raw && raw._noop === true) {
         // No-op streaming/tool event — seq already advanced, nothing else to do
-      } else if (raw && (raw._agentError || raw._agentWarning)) {
-        // Surface the agent's real error/warning message (e.g. a 403 from the
-        // model provider) instead of a useless "Unhandled event".
-        const label = raw._agentError
-          ? i18n.global.t('warnings.errorLabel')
-          : i18n.global.t('warnings.noteLabel');
-        const msg = raw.message ?? raw.code ?? 'agent error';
-        next.warnings = [...next.warnings, `${label}: ${msg}`];
+      } else if (raw && raw._agentError) {
+        // Surface the agent's real error (e.g. a 429 from the model provider)
+        // as a structured notice: semantic title + raw provider message +
+        // diagnostics (code / HTTP status / request id) for troubleshooting.
+        next.warnings = [...next.warnings, buildAgentErrorNotice(raw)];
+      } else if (raw && raw._agentWarning) {
+        const msg = raw.message ?? raw.code ?? 'agent warning';
+        next.warnings = [...next.warnings, `${i18n.global.t('warnings.noteLabel')}: ${msg}`];
       } else {
         // Truly unknown — push a warning
         const wireType = raw?.type ?? '(unknown)';
diff --git a/apps/kimi-web/src/api/daemon/mappers.ts b/apps/kimi-web/src/api/daemon/mappers.ts
index 648734ae3..5eeda29e0 100644
--- a/apps/kimi-web/src/api/daemon/mappers.ts
+++ b/apps/kimi-web/src/api/daemon/mappers.ts
@@ -15,7 +15,6 @@ import type {
   AppMessageRole,
   AppQuestionRequest,
   AppSession,
-  AppSessionStatus,
   AppSessionUsage,
   AppTask,
   AppTaskStatus,
@@ -46,7 +45,6 @@ import type {
   WireQuestionRequest,
   WireQuestionResponse,
   WireSession,
-  WireSessionStatus,
   WireSessionUsage,
   WireWorkspace,
   WireEvent,
@@ -88,33 +86,16 @@ export function isPlaceholderSessionUsage(usage: AppSessionUsage): boolean {
   );
 }
 
-export function toAppSessionStatus(wire: WireSessionStatus): AppSessionStatus {
-  switch (wire) {
-    case 'idle': return 'idle';
-    case 'running': return 'running';
-    case 'awaiting_approval': return 'awaitingApproval';
-    case 'awaiting_question': return 'awaitingQuestion';
-    case 'aborted': return 'aborted';
-  }
-}
-
-export function toWireSessionStatus(status: AppSessionStatus): WireSessionStatus {
-  switch (status) {
-    case 'idle': return 'idle';
-    case 'running': return 'running';
-    case 'awaitingApproval': return 'awaiting_approval';
-    case 'awaitingQuestion': return 'awaiting_question';
-    case 'aborted': return 'aborted';
-  }
-}
-
 export function toAppSession(wire: WireSession): AppSession {
   return {
     id: wire.id,
     title: wire.title,
     createdAt: wire.created_at,
     updatedAt: wire.updated_at,
-    status: toAppSessionStatus(wire.status),
+    busy: wire.busy,
+    mainTurnActive: wire.main_turn_active,
+    pendingInteraction: wire.pending_interaction,
+    lastTurnReason: wire.last_turn_reason,
     archived: wire.archived ?? false,
     currentPromptId: wire.current_prompt_id,
     lastPrompt: wire.last_prompt,
@@ -136,8 +117,6 @@ export function toAppWorkspace(wire: WireWorkspace): AppWorkspace {
     id: wire.id,
     root: wire.root,
     name: wire.name,
-    isGitRepo: wire.is_git_repo,
-    branch: wire.branch ?? undefined,
     lastOpenedAt: wire.last_opened_at,
     sessionCount: wire.session_count,
   };
@@ -530,13 +509,31 @@ export function toAppEvent(wire: WireEvent): AppEvent {
         root: w.payload.root,
       };
 
+    case 'event.session.work_changed':
+      return {
+        type: 'sessionWorkChanged',
+        sessionId: w.session_id,
+        busy: w.payload.busy,
+        mainTurnActive: w.payload.main_turn_active,
+        pendingInteraction: w.payload.pending_interaction,
+        lastTurnReason: w.payload.last_turn_reason,
+      };
+
+    // Deprecated: old journals may still carry status_changed; fold it onto
+    // the busy flag (awaiting/running were live work, aborted was not).
     case 'event.session.status_changed':
       return {
-        type: 'sessionStatusChanged',
+        type: 'sessionWorkChanged',
         sessionId: w.session_id,
-        status: toAppSessionStatus(w.payload.status),
-        previousStatus: toAppSessionStatus(w.payload.previous_status),
-        currentPromptId: w.payload.current_prompt_id,
+        busy: w.payload.status !== 'idle' && w.payload.status !== 'aborted',
+        mainTurnActive: w.payload.status !== 'idle' && w.payload.status !== 'aborted',
+        pendingInteraction:
+          w.payload.status === 'awaiting_approval'
+            ? 'approval'
+            : w.payload.status === 'awaiting_question'
+              ? 'question'
+              : 'none',
+        lastTurnReason: w.payload.status === 'aborted' ? 'cancelled' : undefined,
       };
 
     case 'event.session.usage_updated':
diff --git a/apps/kimi-web/src/api/daemon/wire.ts b/apps/kimi-web/src/api/daemon/wire.ts
index e401d5faf..7831dc83d 100644
--- a/apps/kimi-web/src/api/daemon/wire.ts
+++ b/apps/kimi-web/src/api/daemon/wire.ts
@@ -66,7 +66,10 @@ export interface WireSession {
   title: string;
   created_at: string;
   updated_at: string;
-  status: WireSessionStatus;
+  busy: boolean;
+  main_turn_active?: boolean;
+  pending_interaction?: 'none' | 'approval' | 'question';
+  last_turn_reason?: 'completed' | 'cancelled' | 'failed';
   archived: boolean;
   current_prompt_id?: string;
   /** Text of the most recent user prompt, for search/preview. */
@@ -156,8 +159,6 @@ export interface WireWorkspace {
   id: string;
   root: string;
   name: string;
-  is_git_repo: boolean;
-  branch: string | null;
   last_opened_at?: string;
   session_count: number;
 }
@@ -166,8 +167,6 @@ export interface WireFsBrowseEntry {
   name: string;
   path: string;
   is_dir: boolean;
-  is_git_repo: boolean;
-  branch?: string;
 }
 
 export interface WireFsBrowseResult {
@@ -678,6 +677,13 @@ interface WireEventBase<T extends string, P> {
 type WireEventSessionCreated = WireEventBase<'event.session.created', { session: WireSession }>;
 type WireEventSessionUpdated = WireEventBase<'event.session.updated', { session: WireSession; changed_fields: string[] }>;
 type WireEventSessionDeleted = WireEventBase<'event.session.deleted', { session_id: string }>;
+type WireEventSessionWorkChanged = WireEventBase<'event.session.work_changed', {
+  busy: boolean;
+  main_turn_active?: boolean;
+  pending_interaction?: 'none' | 'approval' | 'question';
+  last_turn_reason?: 'completed' | 'cancelled' | 'failed';
+}>;
+/** @deprecated Old journals may still carry this; mapped onto busy for replay. */
 type WireEventSessionStatusChanged = WireEventBase<'event.session.status_changed', {
   status: WireSessionStatus;
   previous_status: WireSessionStatus;
@@ -829,6 +835,7 @@ export type WireEvent =
   | WireEventSessionCreated
   | WireEventSessionUpdated
   | WireEventSessionDeleted
+  | WireEventSessionWorkChanged
   | WireEventSessionStatusChanged
   | WireEventSessionUsageUpdated
   | WireEventSessionHistoryCompacted
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index 84b495bcd..7fb19f8bf 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -41,13 +41,6 @@ export type AppWarning = string | AppNotice;
 // Session
 // ---------------------------------------------------------------------------
 
-export type AppSessionStatus =
-  | 'idle'
-  | 'running'
-  | 'awaitingApproval'
-  | 'awaitingQuestion'
-  | 'aborted';
-
 export interface AppSessionUsage {
   inputTokens: number;
   outputTokens: number;
@@ -67,7 +60,19 @@ export interface AppSession {
   title: string;
   createdAt: string;
   updatedAt: string;
-  status: AppSessionStatus;
+  /** Any agent in the session holds an active turn or background lease.
+   *  Awaiting states ride the approval/question channels; turn outcomes ride
+   *  turn.ended. */
+  busy: boolean;
+  /** Whether the main agent has an active turn. Unlike busy, this excludes
+   *  background tasks and sub-agent work. */
+  mainTurnActive?: boolean;
+  /** List-level fallback for the action-required badge. */
+  pendingInteraction?: 'none' | 'approval' | 'question';
+  /** Outcome of the main agent's most recent turn (when the server reports
+   *  one). Presentation rule for the "aborted" tag:
+   *  `!busy && (cancelled | failed)`. */
+  lastTurnReason?: 'completed' | 'cancelled' | 'failed';
   archived: boolean;
   currentPromptId?: string;
   /** Text of the most recent user prompt, for search/preview. */
@@ -120,10 +125,6 @@ export interface AppWorkspace {
   root: string;
   /** Display name — defaults to basename(root), may be renamed on the daemon. */
   name: string;
-  /** Whether root is inside a git repository. */
-  isGitRepo: boolean;
-  /** Current branch, when known. */
-  branch?: string;
   /** ISO timestamp of when this workspace was last opened. */
   lastOpenedAt?: string;
   /** Number of sessions belonging to this workspace. */
@@ -135,8 +136,6 @@ export interface FsBrowseEntry {
   name: string;
   path: string;
   isDir: boolean;
-  isGitRepo: boolean;
-  branch?: string;
 }
 
 export interface FsBrowseResult {
@@ -338,6 +337,12 @@ export interface AppTask {
    *  the dock: the dock lists background subagents, while foreground subagents
    *  render inline in the message flow as the `Agent` tool card. */
   runInBackground?: boolean;
+  /** The id this same subagent has in the server's background-task store
+   *  (REST `/tasks`), learned from the `task.started` registration event. The
+   *  WS event stream keys the agent by agent id while REST keys it by task id;
+   *  this links the two so the REST copy can be folded into this row and so
+   *  cancel can target the id REST actually knows. */
+  backgroundTaskId?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -417,7 +422,14 @@ export type AppEvent =
   | { type: 'workspaceDeleted'; workspaceId: string; root: string }
   | { type: 'sessionUpdated'; session: AppSession; changedFields: string[] }
   | { type: 'sessionDeleted'; sessionId: string }
-  | { type: 'sessionStatusChanged'; sessionId: string; status: AppSessionStatus; previousStatus: AppSessionStatus; currentPromptId?: string }
+  | {
+      type: 'sessionWorkChanged';
+      sessionId: string;
+      busy: boolean;
+      mainTurnActive?: boolean;
+      pendingInteraction?: 'none' | 'approval' | 'question';
+      lastTurnReason?: 'completed' | 'cancelled' | 'failed';
+    }
   | { type: 'sessionMetaUpdated'; sessionId: string; title?: string; lastPrompt?: string }
   | { type: 'sessionUsageUpdated'; sessionId: string; usage: AppSessionUsage; model?: string; swarmMode?: boolean; planMode?: boolean }
   | { type: 'historyCompacted'; sessionId: string; beforeSeq: number; reason: string; summaryMessageId?: string }
@@ -454,6 +466,20 @@ export type AppEvent =
       kind?: 'line' | 'text';
     }
   | { type: 'taskCompleted'; sessionId: string; taskId: string; status: AppTaskStatus; outputPreview?: string; outputBytes?: number }
+  // Prompt-level lifecycle (distinct from turn-level): a prompt that never
+  // produced a turn — blocked by a pre-submit hook, or aborted while queued —
+  // gets no turn.ended and no session status flip, so these are the web layer's
+  // only signal to clear the per-session in-flight state. A normal turn's
+  // prompt.completed is a no-op for state (the status_changed ahead of it
+  // already finished the prompt).
+  | { type: 'promptCompleted'; sessionId: string; promptId: string; reason: string }
+  | { type: 'promptAborted'; sessionId: string; promptId: string }
+  // The MAIN agent's turn boundary — the single source of truth for "the main
+  // conversation has a turn in flight" (half of the working moon, and the
+  // streaming reveal). Deliberately NOT derived from session status: a
+  // background subagent or BTW side chat keeps the session busy but must not
+  // light up the main conversation's moon. `reason` rides on deactivation.
+  | { type: 'turnActiveChanged'; sessionId: string; active: boolean; reason?: string }
   | { type: 'goalUpdated'; sessionId: string; goal: AppGoal | null }
   | { type: 'configChanged'; changedFields: string[]; config: AppConfig }
   | {
@@ -512,7 +538,7 @@ export interface AppSessionSnapshot {
 }
 
 export interface KimiEventHandlers {
-  onEvent(event: AppEvent, meta: { sessionId: string; seq: number }): void;
+  onEvent(event: AppEvent, meta: KimiEventMeta): void;
   onResync(sessionId: string, currentSeq: number, epoch?: string): void;
   onError(code: number, msg: string, fatal: boolean): void;
   onConnectionChange(connected: boolean): void;
@@ -520,6 +546,18 @@ export interface KimiEventHandlers {
   onTerminalExit?(sessionId: string, terminalId: string, exitCode: number | null): void;
 }
 
+/** Raw stream coordinates are present only for kap-server assistant/thinking
+    deltas. They let the render queue merge chunks without guessing continuity. */
+export interface KimiEventMeta {
+  sessionId: string;
+  seq: number;
+  stream?: {
+    turnId: number;
+    offset: number;
+    kind: 'text' | 'thinking';
+  };
+}
+
 export interface KimiEventConnection {
   subscribe(sessionId: string, cursor?: AppSessionCursor): void;
   unsubscribe(sessionId: string): void;
@@ -667,7 +705,7 @@ export interface AppSessionWarning {
 export interface KimiWebApi {
   getHealth(): Promise<{ status: 'ok'; uptimeSec: number }>;
   getMeta(): Promise<{ serverVersion: string; serverId: string; startedAt: string; capabilities: Record<string, boolean>; openInApps: string[]; dangerousBypassAuth: boolean; backend: 'v1' | 'v2' }>;
-  listSessions(input?: PageRequest & { status?: AppSessionStatus; workspaceId?: string; includeArchive?: boolean; archivedOnly?: boolean; excludeEmpty?: boolean }): Promise<Page<AppSession>>;
+  listSessions(input?: PageRequest & { busy?: boolean; workspaceId?: string; includeArchive?: boolean; archivedOnly?: boolean; excludeEmpty?: boolean }): Promise<Page<AppSession>>;
   createSession(input: { title?: string; cwd?: string; model?: string; workspaceId?: string }): Promise<AppSession>;
   /** Fetch one session by id (deep links beyond the first listSessions page). */
   getSession(sessionId: string): Promise<AppSession>;
diff --git a/apps/kimi-web/src/components/ResizeHandle.vue b/apps/kimi-web/src/components/ResizeHandle.vue
index b37a8c246..c2887ad2f 100644
--- a/apps/kimi-web/src/components/ResizeHandle.vue
+++ b/apps/kimi-web/src/components/ResizeHandle.vue
@@ -69,7 +69,9 @@ watch(dragging, (d) => emit('update:dragging', d));
   touch-action: none;
   /* sits over the 1px column border so the whole 4px strip is grabbable */
   margin: 0 -2px;
-  z-index: var(--z-sticky);
+  /* above pane-level sticky chrome (chat dock, headers at --z-sticky): its 2px
+     overhang into the neighbour pane must stay visible and grabbable */
+  z-index: var(--z-dropdown);
 }
 .rh-bar {
   position: absolute;
diff --git a/apps/kimi-web/src/components/SessionRow.vue b/apps/kimi-web/src/components/SessionRow.vue
index bc3b55cf3..e95cce49a 100644
--- a/apps/kimi-web/src/components/SessionRow.vue
+++ b/apps/kimi-web/src/components/SessionRow.vue
@@ -8,7 +8,6 @@ import type { Session } from '../types';
 import { copyTextToClipboard } from '../lib/clipboard';
 import Spinner from './ui/Spinner.vue';
 import Badge from './ui/Badge.vue';
-import { useConfirmDialog } from '../composables/useConfirmDialog';
 import IconButton from './ui/IconButton.vue';
 import Menu from './ui/Menu.vue';
 import MenuItem from './ui/MenuItem.vue';
@@ -16,7 +15,6 @@ import Icon from './ui/Icon.vue';
 import Tooltip from './ui/Tooltip.vue';
 
 const { t } = useI18n();
-const { confirm } = useConfirmDialog();
 
 const props = withDefaults(
   defineProps<{
@@ -168,18 +166,11 @@ function exportRow(): void {
   emit('export', props.session.id);
 }
 
-// Archive confirm — modal, consistent with remove-workspace.
-async function startArchive(): Promise<void> {
+// Archive — the modal confirm and the async work live in App.vue
+// (confirmArchiveSession); the row only emits the intent.
+function startArchive(): void {
   closeMenu();
-  if (
-    await confirm({
-      title: t('sidebar.archive'),
-      message: t('sidebar.archiveConfirm'),
-      variant: 'danger',
-    })
-  ) {
-    emit('archive', props.session.id);
-  }
+  emit('archive', props.session.id);
 }
 
 // Expose closeMenu so the parent can close on outside-click.
@@ -214,12 +205,11 @@ defineExpose({ closeMenu });
 
       <!-- Pending tags — coloured per kind, shown even when the row isn't
            active. "Answer" = an askUserQuestion is waiting; "Approve" = a
-           permission request is waiting. The session's lifecycle status drives
-           the same tags as a fallback for background sessions whose pending
-           lists aren't loaded yet (status known, counts not). -->
+           permission request is waiting. The list-level interaction fact is
+           the fallback for sessions whose detailed pending lists aren't loaded. -->
       <Tooltip :text="t('workspace.awaitingAnswerTitle')">
         <Badge
-          v-if="!renaming && (questionCount > 0 || session.status === 'awaitingQuestion')"
+          v-if="!renaming && (questionCount > 0 || session.pendingInteraction === 'question')"
           variant="info"
           size="sm"
         >
@@ -228,17 +218,20 @@ defineExpose({ closeMenu });
       </Tooltip>
       <Tooltip :text="t('workspace.awaitingPermissionTitle')">
         <Badge
-          v-if="!renaming && (approvalCount > 0 || session.status === 'awaitingApproval')"
+          v-if="!renaming && (approvalCount > 0 || session.pendingInteraction === 'approval')"
           variant="warning"
           size="sm"
         >
           {{ t('workspace.awaitingPermission') }}
         </Badge>
       </Tooltip>
-      <!-- Aborted: a distinct, low-key error tag (not collapsed into idle). -->
+      <!-- Aborted: a distinct, low-key error tag — the session is quiet and
+           its last main turn was cancelled or failed. Hidden while input is
+           pending (the awaiting pills own the row then, exactly like the
+           retired awaiting_* lifecycle status superseded `aborted`). -->
       <Tooltip :text="t('workspace.abortedTitle')">
         <Badge
-          v-if="!renaming && session.status === 'aborted'"
+          v-if="!renaming && !session.busy && session.pendingInteraction !== 'question' && session.pendingInteraction !== 'approval' && questionCount === 0 && approvalCount === 0 && (session.lastTurnReason === 'cancelled' || session.lastTurnReason === 'failed')"
           variant="danger"
           size="sm"
         >
diff --git a/apps/kimi-web/src/components/Sidebar.vue b/apps/kimi-web/src/components/Sidebar.vue
index b7e6089ab..e422b2208 100644
--- a/apps/kimi-web/src/components/Sidebar.vue
+++ b/apps/kimi-web/src/components/Sidebar.vue
@@ -30,10 +30,8 @@ import Kbd from './ui/Kbd.vue';
 import Menu from './ui/Menu.vue';
 import MenuItem from './ui/MenuItem.vue';
 import Pill from './ui/Pill.vue';
-import { useConfirmDialog } from '../composables/useConfirmDialog';
 
 const { t } = useI18n();
-const { confirm } = useConfirmDialog();
 
 // Dev-only affordance: when the page is served by the Vite dev server, the
 // logo turns yellow and a backend pill next to the brand shows the engine
@@ -371,19 +369,12 @@ function startRenameFromMenu(): void {
   closeGhMenu();
 }
 
-async function deleteFromMenu(): Promise<void> {
+function deleteFromMenu(): void {
   const ws = ghMenuTarget.value;
   if (!ws) return;
   closeGhMenu();
-  if (
-    await confirm({
-      title: t('sidebar.removeWorkspace'),
-      message: t('workspace.removeWorkspaceConfirm', { name: ws.name }),
-      variant: 'danger',
-    })
-  ) {
-    emit('deleteWorkspace', ws.id);
-  }
+  // The modal confirm + async delete live in App.vue (confirmDeleteWorkspace).
+  emit('deleteWorkspace', ws.id);
 }
 
 // ---------------------------------------------------------------------------
@@ -449,17 +440,10 @@ function startRenameWs(ws: WorkspaceView): void {
   closeWsMenu();
 }
 
-async function deleteWs(ws: WorkspaceView): Promise<void> {
+function deleteWs(ws: WorkspaceView): void {
   closeWsMenu();
-  if (
-    await confirm({
-      title: t('sidebar.removeWorkspace'),
-      message: t('workspace.removeWorkspaceConfirm', { name: ws.name }),
-      variant: 'danger',
-    })
-  ) {
-    emit('deleteWorkspace', ws.id);
-  }
+  // The modal confirm + async delete live in App.vue (confirmDeleteWorkspace).
+  emit('deleteWorkspace', ws.id);
 }
 
 // ---------------------------------------------------------------------------
@@ -571,6 +555,7 @@ async function chooseBackend(name: BackendName): Promise<void> {
   }
   const next = await switchDevBackend(name);
   if (next === null) {
+    console.warn('[kimi-web] dev backend switch failed:', name);
     closeBackendMenu();
     return;
   }
diff --git a/apps/kimi-web/src/components/WarningToasts.vue b/apps/kimi-web/src/components/WarningToasts.vue
index a6addba38..ba03f448d 100644
--- a/apps/kimi-web/src/components/WarningToasts.vue
+++ b/apps/kimi-web/src/components/WarningToasts.vue
@@ -295,7 +295,9 @@ onUnmounted(() => {
   .toasts {
     left: 12px;
     right: 12px;
-    bottom: calc(76px + env(safe-area-inset-bottom));
+    /* Sit just above the chat dock; --dock-h already includes the dock's own
+       safe-area padding, so no extra safe-bottom term is needed. */
+    bottom: calc(var(--dock-h, 76px) + 8px);
     width: auto;
     max-height: 50vh;
   }
diff --git a/apps/kimi-web/src/components/chat/ApprovalCard.vue b/apps/kimi-web/src/components/chat/ApprovalCard.vue
index 6dd2e36bb..33542020c 100644
--- a/apps/kimi-web/src/components/chat/ApprovalCard.vue
+++ b/apps/kimi-web/src/components/chat/ApprovalCard.vue
@@ -198,7 +198,7 @@ onUnmounted(() => document.removeEventListener('keydown', handleKeydown));
           :label="minimized ? t('question.expand') : t('question.minimize')"
           @click="minimized = !minimized"
         >
-          <Icon v-if="minimized" name="chevron-down" size="md" />
+          <Icon v-if="minimized" name="chevron-up" size="md" />
           <Icon v-else name="minus" size="md" />
         </IconButton>
       </div>
diff --git a/apps/kimi-web/src/components/chat/AttachmentChip.vue b/apps/kimi-web/src/components/chat/AttachmentChip.vue
new file mode 100644
index 000000000..b245664d2
--- /dev/null
+++ b/apps/kimi-web/src/components/chat/AttachmentChip.vue
@@ -0,0 +1,204 @@
+<!-- apps/kimi-web/src/components/chat/AttachmentChip.vue -->
+<!-- One attachment rendered as a pill chip — the SAME component for the
+     composer's pending-attachment strip and for sent messages in the chat
+     bubble. Context differences are props, not restyled variants:
+       - composer: uploading spinner, error tint, remove button
+       - bubble:   plain chip, click opens preview / downloads
+     Tile rule: images show a real thumbnail, videos a play glyph, files a
+     neutral file icon with the extension badge next to the name. -->
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import AuthMedia from './AuthMedia.vue';
+import Icon from '../ui/Icon.vue';
+import Spinner from '../ui/Spinner.vue';
+import Tooltip from '../ui/Tooltip.vue';
+import type { IconName } from '../../lib/icons';
+
+const props = withDefaults(
+  defineProps<{
+    kind: 'image' | 'video' | 'file';
+    /** Undefined only for pasted media without a name — a generic label shows. */
+    name?: string;
+    /** Thumbnail source for images (object URL or the authed file URL). */
+    url?: string;
+    /** When present, AuthMedia fetches image bytes with auth. */
+    fileId?: string;
+    mediaType?: string;
+    size?: number;
+    /** Composer: upload in flight — spinner replaces the ext badge. */
+    uploading?: boolean;
+    /** Composer: upload failed — chip tinted, info icon replaces the badge. */
+    error?: boolean;
+    /** Composer: show a remove button. */
+    removable?: boolean;
+    /** Accessible label for the remove button. */
+    removeLabel?: string;
+  }>(),
+  { uploading: false, error: false, removable: false },
+);
+
+const emit = defineEmits<{
+  /** Primary action (preview media / download file) — the parent decides. */
+  activate: [];
+  remove: [];
+}>();
+
+const { t } = useI18n();
+
+const ext = computed(() => {
+  const fromName = props.name?.match(/\.([A-Za-z0-9]{1,8})$/)?.[1];
+  const e = fromName ?? props.mediaType?.split('/')[1]?.split('+')[0];
+  return e ? e.toUpperCase() : undefined;
+});
+
+const fileIcon = computed<IconName>(() => {
+  const e = ext.value ?? '';
+  if (/^(txt|md|doc|docx|rtf|log)$/i.test(e)) return 'file-text';
+  return 'file';
+});
+
+const displayName = computed(() => {
+  if (props.name) return props.name;
+  if (props.kind === 'image') return t('composer.attachmentImage');
+  if (props.kind === 'video') return t('composer.attachmentVideo');
+  return t('composer.attachmentFile');
+});
+
+function formatSize(size: number): string {
+  if (size < 1024) return `${size} B`;
+  if (size < 1024 * 1024) return `${Math.round(size / 1024)} KB`;
+  return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+const title = computed(() => {
+  const parts = [displayName.value];
+  if (props.size !== undefined) parts.push(formatSize(props.size));
+  return parts.join(' · ');
+});
+</script>
+
+<template>
+  <span
+    class="att-chip"
+    :class="{ 'is-error': error, uploading }"
+    :title="title"
+    :data-kind="kind"
+  >
+    <button type="button" class="att-activate" :aria-label="title" @click="emit('activate')">
+      <span class="att-tile">
+        <AuthMedia
+          v-if="kind === 'image' && url"
+          :url="url"
+          kind="image"
+          :alt="name"
+          :file-id="fileId"
+          media-class="att-thumb"
+        />
+        <Icon v-else-if="kind === 'video'" name="play" size="sm" />
+        <Icon v-else-if="kind === 'image'" name="image" size="sm" />
+        <Icon v-else :name="fileIcon" size="sm" />
+      </span>
+      <span class="att-name">{{ displayName }}</span>
+      <Spinner v-if="uploading" size="sm" :label="t('composer.uploading')" />
+      <span v-else-if="error" class="att-err"><Icon name="info" size="sm" /></span>
+    </button>
+    <Tooltip v-if="removable" :text="removeLabel ?? t('composer.remove')">
+      <button type="button" class="att-rm" :aria-label="removeLabel ?? t('composer.remove')" @click="emit('remove')">
+        <Icon name="close" size="sm" />
+      </button>
+    </Tooltip>
+  </span>
+</template>
+
+<style scoped>
+.att-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  max-width: 220px;
+  padding: 4px 9px 4px 5px;
+  background: var(--color-bg);
+  border: 1px solid var(--color-line);
+  border-radius: 999px;
+  font-size: var(--ui-font-size-sm);
+  transition: border-color var(--duration-fast) ease;
+}
+.att-chip:hover {
+  border-color: var(--color-line-strong);
+}
+.att-activate {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-width: 0;
+  padding: 0;
+  border: none;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+}
+.att-activate:focus-visible {
+  outline: none;
+  box-shadow: var(--p-focus-ring);
+  border-radius: 999px;
+}
+.att-tile {
+  width: 20px;
+  height: 20px;
+  border-radius: 50%;
+  flex: none;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  color: var(--color-text-muted);
+  background: var(--color-surface-sunken);
+}
+.att-tile :deep(.att-thumb) {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+}
+.att-name {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--color-text);
+  font-weight: var(--weight-medium);
+}
+.att-chip.is-error {
+  border-color: var(--color-danger-bd);
+}
+.att-chip.is-error .att-err {
+  flex: none;
+  display: flex;
+  align-items: center;
+  color: var(--color-danger);
+}
+.att-rm {
+  flex: none;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  padding: 0;
+  border: none;
+  border-radius: 50%;
+  background: transparent;
+  color: var(--color-text-faint);
+  cursor: pointer;
+}
+.att-rm:hover {
+  background: var(--color-hover);
+  color: var(--color-text);
+}
+.att-rm:focus-visible {
+  outline: none;
+  box-shadow: var(--p-focus-ring);
+}
+</style>
diff --git a/apps/kimi-web/src/components/chat/ChatDock.vue b/apps/kimi-web/src/components/chat/ChatDock.vue
index 27a8a8a47..4ce3de522 100644
--- a/apps/kimi-web/src/components/chat/ChatDock.vue
+++ b/apps/kimi-web/src/components/chat/ChatDock.vue
@@ -3,11 +3,12 @@
 <!-- pending question/approval cards, and the composer. Only rendered inside a -->
 <!-- chat-pane group so it never leaks into files/tasks/preview/btw panes. -->
 <script setup lang="ts">
-import { computed, onUnmounted, ref, watch } from 'vue';
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import type { ActivationBadges, ApprovalBlock, ConversationStatus, PermissionMode, QueuedPromptView, TaskItem, TodoTreeNode, TodoView, UIQuestion } from '../../types';
 import type { AppGoal, AppModel, AppSkill, QuestionResponse, ThinkingLevel } from '../../api/types';
 import type { FileItem } from './MentionMenu.vue';
+import type { PromptAttachment } from '../../composables/useKimiWebClient';
 import Composer from './Composer.vue';
 import GoalStrip from './GoalStrip.vue';
 import QuestionCard from './QuestionCard.vue';
@@ -59,8 +60,8 @@ const props = defineProps<{
 }>();
 
 const emit = defineEmits<{
-  submit: [payload: { text: string; attachments: { fileId: string; kind: 'image' | 'video' }[] }];
-  steer: [payload: { text: string; attachments: { fileId: string; kind: 'image' | 'video' }[] }];
+  submit: [payload: { text: string; attachments: PromptAttachment[] }];
+  steer: [payload: { text: string; attachments: PromptAttachment[] }];
   command: [cmd: string];
   interrupt: [];
   setPermission: [mode: PermissionMode];
@@ -107,11 +108,12 @@ const treeStats = computed(() => {
 
 const composerRef = ref<{
   loadForEdit: (value: string) => boolean;
-  loadAttachmentsForEdit: (atts: { fileId?: string; kind: 'image' | 'video'; url: string; name?: string }[]) => void;
+  loadAttachmentsForEdit: (atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]) => void;
   focus: () => void;
 } | null>(null);
 const workPanelRef = ref<HTMLElement | null>(null);
 const workbarRef = ref<HTMLElement | null>(null);
+const dockRef = ref<HTMLElement | null>(null);
 
 function loadForEdit(value: string): boolean {
   // The nested Composer is only rendered in ChatDock's v-else — when a pending
@@ -122,7 +124,7 @@ function loadForEdit(value: string): boolean {
   return true;
 }
 
-function loadAttachmentsForEdit(atts: { fileId?: string; kind: 'image' | 'video'; url: string; name?: string }[]): void {
+function loadAttachmentsForEdit(atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
   composerRef.value?.loadAttachmentsForEdit(atts);
 }
 
@@ -149,17 +151,36 @@ watch(
   { immediate: true },
 );
 
+let dockResizeObserver: ResizeObserver | null = null;
+
+function publishDockHeight(): void {
+  // Border-box height of the dock, exposed so fixed overlays (e.g. toasts) can
+  // anchor just above the composer. offsetHeight includes the dock's own
+  // safe-area padding, so consumers don't need to add safe-bottom again.
+  const height = dockRef.value?.offsetHeight ?? 0;
+  document.documentElement.style.setProperty('--dock-h', `${height}px`);
+}
+
+onMounted(() => {
+  if (typeof ResizeObserver !== 'function' || !dockRef.value) return;
+  dockResizeObserver = new ResizeObserver(publishDockHeight);
+  dockResizeObserver.observe(dockRef.value);
+  publishDockHeight();
+});
+
 onUnmounted(() => {
   if (typeof document !== 'undefined') {
     document.removeEventListener('mousedown', onDocumentMouseDown, true);
   }
+  dockResizeObserver?.disconnect();
+  dockResizeObserver = null;
 });
 
 defineExpose({ loadForEdit, loadAttachmentsForEdit, focus });
 </script>
 
 <template>
-  <div class="chat-dock" :class="[mobile ? 'align-mobile' : 'align-center']" @click.stop>
+  <div ref="dockRef" class="chat-dock" :class="[mobile ? 'align-mobile' : 'align-center']" @click.stop>
     <Transition name="dock-panel">
       <div
         ref="workPanelRef"
@@ -386,12 +407,10 @@ defineExpose({ loadForEdit, loadAttachmentsForEdit, focus });
 
 @media (max-width: 640px) {
   .chat-dock {
-    --dock-inline-left: max(12px, env(safe-area-inset-left));
-    --dock-inline-right: max(12px, env(safe-area-inset-right));
-  }
-  .chat-dock.align-mobile {
-    padding-left: env(safe-area-inset-left);
-    padding-right: env(safe-area-inset-right);
+    /* Inline (landscape) safe-area lives here only; the inner composer /
+       workbar read --dock-inline-* so the inset is applied exactly once. */
+    --dock-inline-left: max(12px, var(--safe-left));
+    --dock-inline-right: max(12px, var(--safe-right));
   }
   .dock-work-panel {
     left: 10px;
diff --git a/apps/kimi-web/src/components/chat/ChatHeader.vue b/apps/kimi-web/src/components/chat/ChatHeader.vue
index ef7e9f9e5..0dff7bae6 100644
--- a/apps/kimi-web/src/components/chat/ChatHeader.vue
+++ b/apps/kimi-web/src/components/chat/ChatHeader.vue
@@ -12,10 +12,8 @@ import MenuItem from '../ui/MenuItem.vue';
 import IconButton from '../ui/IconButton.vue';
 import Icon from '../ui/Icon.vue';
 import Tooltip from '../ui/Tooltip.vue';
-import { useConfirmDialog } from '../../composables/useConfirmDialog';
 
 const { t } = useI18n();
-const { confirm } = useConfirmDialog();
 
 const props = defineProps<{
   sessionId?: string;
@@ -210,21 +208,13 @@ function exportSession(): void {
 }
 
 // ---------------------------------------------------------------------------
-// Archive — modal confirm (the header has no session row to swap, so use the
-// shared ConfirmDialog instead of the inline strip used in SessionRow).
+// Archive — the modal confirm and the async work live in App.vue
+// (confirmArchiveSession); the header only emits the intent.
 // ---------------------------------------------------------------------------
-async function startArchive(): Promise<void> {
+function startArchive(): void {
   if (!props.sessionId) return;
   closeMenu();
-  if (
-    await confirm({
-      title: t('header.archiveSession'),
-      message: t('sidebar.archiveConfirm'),
-      variant: 'danger',
-    })
-  ) {
-    emit('archiveSession', props.sessionId);
-  }
+  emit('archiveSession', props.sessionId);
 }
 </script>
 
diff --git a/apps/kimi-web/src/components/chat/ChatPane.vue b/apps/kimi-web/src/components/chat/ChatPane.vue
index 68b403a55..5886e0ef9 100644
--- a/apps/kimi-web/src/components/chat/ChatPane.vue
+++ b/apps/kimi-web/src/components/chat/ChatPane.vue
@@ -2,7 +2,7 @@
 <script setup lang="ts">
 import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
-import type { ChatTurn, ApprovalBlock, FilePreviewRequest, ToolMedia, QueuedPromptView } from '../../types';
+import type { ChatTurn, ApprovalBlock, FilePreviewRequest, ToolMedia, QueuedPromptView, TurnAttachment } from '../../types';
 import ToolCall from './ToolCall.vue';
 import ToolGroup from './ToolGroup.vue';
 import Markdown from './Markdown.vue';
@@ -11,12 +11,14 @@ import ActivityNotice from './ActivityNotice.vue';
 import CronNotice from './CronNotice.vue';
 import MessageTime from './MessageTime.vue';
 import AuthMedia from './AuthMedia.vue';
+import AttachmentChip from './AttachmentChip.vue';
 import MoonSpinner from '../ui/MoonSpinner.vue';
 import Spinner from '../ui/Spinner.vue';
 import Icon from '../ui/Icon.vue';
 import Tooltip from '../ui/Tooltip.vue';
 import { useConfirmDialog } from '../../composables/useConfirmDialog';
 import { copyTextToClipboard } from '../../lib/clipboard';
+import { openFileAttachment } from '../../lib/openFileAttachment';
 import {
   assistantRenderBlocks,
   formatDuration,
@@ -43,6 +45,10 @@ onUnmounted(() => {
     clearTimeout(undoFallbackTimer);
     undoFallbackTimer = null;
   }
+  if (unsupportedOpenTimer !== null) {
+    clearTimeout(unsupportedOpenTimer);
+    unsupportedOpenTimer = null;
+  }
 });
 
 const props = withDefaults(
@@ -50,17 +56,18 @@ const props = withDefaults(
     turns: ChatTurn[];
     approvals?: { approvalId: string; block: ApprovalBlock; agentName?: string }[];
     /**
-     * True while the active session is busy (activity !== idle). Used to mark the
-     * last assistant turn as actively streaming so its Markdown animates the
-     * smooth typewriter/fade reveal; all other turns render statically.
+     * True while the MAIN agent has a turn in flight (not merely "session
+     * busy" — background subagents and BTW side chats don't set this). Marks
+     * the last assistant turn as actively streaming so its Markdown animates
+     * the smooth typewriter/fade reveal; all other turns render statically.
      */
-    running?: boolean;
+    turnActive?: boolean;
     /**
-     * True immediately after the user hits send and before the assistant reply
-     * starts streaming. Renders a moon-spinner placeholder at the end of the
-     * transcript so the user knows the request is in flight.
+     * The main conversation has an unfinished prompt (submitted, or a main
+     * turn in flight). Renders the moon-spinner placeholder at the end of the
+     * transcript and gates "edit & resend" on the last user message.
      */
-    sending?: boolean;
+    working?: boolean;
     /** Switches the CSS-only working moon to the faster visual cadence. */
     fastMoon?: boolean;
     /**
@@ -110,8 +117,8 @@ const props = withDefaults(
   }>(),
   {
     approvals: () => [],
-    running: false,
-    sending: false,
+    turnActive: false,
+    working: false,
     fastMoon: false,
     compaction: null,
     hasMoreMessages: false,
@@ -170,21 +177,20 @@ watch(
 );
 
 // The id of the turn that is actively streaming: the last assistant turn while
-// the session is running. Its Markdown renders with `streaming` (final=false);
-// every other turn renders statically.
+// the main turn is in flight. Its Markdown renders with `streaming`
+// (final=false); every other turn renders statically.
 const streamingTurnId = computed<string | null>(() => {
-  if (!props.running || props.turns.length === 0) return null;
+  if (!props.turnActive || props.turns.length === 0) return null;
   const last = props.turns.at(-1)!;
   return last.role === 'assistant' ? last.id : null;
 });
 
-// Trailing "working" moon. `sending` is an optimistic flag set on submit and
-// kept until the session goes idle, so during a normal turn the moon shows the
-// whole time. After a page refresh that in-memory flag is gone, so fall back to
-// `running` (restored from the session's live status) — otherwise a refresh mid
-// stream froze the transcript with no "still working" indicator. Either flag
-// shows the same moon footer.
-const showWorking = computed(() => props.sending || props.running);
+// Trailing "working" moon: shown while the main conversation has an unfinished
+// prompt. `working` is the union of the optimistic submit window and the main
+// turn's liveness (restored from the snapshot's inFlightTurn after a refresh);
+// background agents and BTW side chats never show here — the moon belongs to
+// the main conversation only.
+const showWorking = computed(() => props.working);
 
 const emit = defineEmits<{
   openFile: [target: FilePreviewRequest];
@@ -200,7 +206,7 @@ const emit = defineEmits<{
   /** Show an Edit/Write tool call's diff in the right-side panel. */
   openToolDiff: [id: string];
   /** Edit + resend the last user message (parent undoes, then refills composer). */
-  editMessage: [payload: { text: string; images?: { url: string; alt?: string; kind: 'image' | 'video'; fileId?: string }[] }];
+  editMessage: [payload: { text: string; attachments?: TurnAttachment[] }];
   /** Fetch the next older page of messages (triggered by top sentinel visibility or click). */
   loadOlderMessages: [];
   /** Remove a queued message by index. */
@@ -217,7 +223,7 @@ const emit = defineEmits<{
 const dragFrom = ref<number | null>(null);
 const dragOver = ref<{ index: number; position: 'before' | 'after' } | null>(null);
 
-function hasImages(item: QueuedPromptView): boolean {
+function hasAttachments(item: QueuedPromptView): boolean {
   return (item.attachments?.length ?? 0) > 0;
 }
 
@@ -277,13 +283,12 @@ const lastUserTurnId = computed<string | null>(() => {
 });
 
 /** Whether to offer "edit & resend" on this turn: the latest user message, only
-    while the session is idle (not mid-reply) and it isn't a slash activation. */
+    while the conversation has nothing unfinished and it isn't a slash activation. */
 function canEditTurn(turn: ChatTurn): boolean {
   return (
     turn.role === 'user' &&
     turn.id === lastUserTurnId.value &&
-    !props.running &&
-    !props.sending &&
+    !props.working &&
     !turn.skillActivation &&
     !turn.pluginCommand
   );
@@ -333,7 +338,7 @@ async function onUndo(turn: ChatTurn): Promise<void> {
 function confirmEditMessage(turn: ChatTurn): void {
   if (undoingTurnId.value !== null) return;
   undoingTurnId.value = turn.id;
-  emit('editMessage', { text: turn.text, images: turn.images });
+  emit('editMessage', { text: turn.text, attachments: turn.attachments });
   // Fallback: if the server rewind never removes the turn (e.g. it failed),
   // release the guard so the user can retry.
   undoFallbackTimer = setTimeout(() => {
@@ -468,12 +473,37 @@ function copyUserMessage(turn: ChatTurn): void {
   }).catch(() => {/* ignore */});
 }
 
-function userImageMedia(img: { url: string; alt?: string; fileId?: string }): ToolMedia {
-  // User-uploaded images carry no path/mime metadata; the preview panel falls
+function userAttachmentMedia(att: TurnAttachment): ToolMedia {
+  // User-uploaded media carries no path/mime metadata; the preview panel falls
   // back to a generic label and sniffs the mime from the URL when needed. When
   // a fileId is present the preview fetches the bytes with auth (a bare
   // getFileUrl src 401s under daemon auth).
-  return { kind: 'image', url: img.url, path: img.alt, fileId: img.fileId };
+  return { kind: att.kind === 'video' ? 'video' : 'image', url: att.url, path: att.name, fileId: att.fileId };
+}
+
+// Transient "can't open this type" hint after clicking a file chip of a
+// non-previewable type. Mirrors the copiedTurn timer pattern; cleared on unmount.
+const unsupportedOpenName = ref<string | null>(null);
+let unsupportedOpenTimer: ReturnType<typeof setTimeout> | null = null;
+
+function onAttachmentClick(att: TurnAttachment): void {
+  if (att.kind === 'image' || att.kind === 'video') {
+    emit('openMedia', userAttachmentMedia(att));
+    return;
+  }
+  // Generic files open in a new tab, but only whitelisted inert types —
+  // anything else gets the unsupported hint instead of an active-document
+  // preview (see openFileAttachment).
+  if (att.fileId === undefined) return;
+  void openFileAttachment(att.fileId, att.name, att.mediaType).then((result) => {
+    if (result !== 'unsupported') return;
+    unsupportedOpenName.value = att.name ?? att.fileId ?? '';
+    if (unsupportedOpenTimer !== null) clearTimeout(unsupportedOpenTimer);
+    unsupportedOpenTimer = setTimeout(() => {
+      unsupportedOpenTimer = null;
+      unsupportedOpenName.value = null;
+    }, 2400);
+  });
 }
 
 function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }): boolean {
@@ -523,32 +553,19 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
       <template v-if="turn.role === 'user'">
         <div class="u-turn">
           <div class="u-bub turn-anchor" :class="{ undoing: undoingTurnId === turn.id }" :data-turn-id="turn.id">
-            <!-- Image / video attachments -->
-            <div v-if="turn.images && turn.images.length > 0" class="u-imgs">
-              <template v-for="(img, ii) in turn.images" :key="ii">
-                <AuthMedia
-                  v-if="img.kind === 'video'"
-                  :url="img.url"
-                  kind="video"
-                  :file-id="img.fileId"
-                  media-class="u-img"
-                />
-                <button
-                  v-else
-                  type="button"
-                  class="u-img-btn"
-                  :aria-label="t('filePreview.enlargeImage')"
-                  @click="emit('openMedia', userImageMedia(img))"
-                >
-                  <AuthMedia
-                    :url="img.url"
-                    kind="image"
-                    :alt="img.alt"
-                    :file-id="img.fileId"
-                    media-class="u-img"
-                  />
-                </button>
-              </template>
+            <!-- Unified attachment chips: files, images and videos -->
+            <div v-if="turn.attachments && turn.attachments.length > 0" class="u-atts">
+              <AttachmentChip
+                v-for="(att, ai) in turn.attachments"
+                :key="ai"
+                :kind="att.kind"
+                :name="att.name"
+                :url="att.url"
+                :file-id="att.fileId"
+                :media-type="att.mediaType"
+                :size="att.size"
+                @activate="onAttachmentClick(att)"
+              />
             </div>
             <!-- Skill activation card (replaces raw XML) -->
             <div v-if="turn.skillActivation" class="skill-act">
@@ -656,9 +673,9 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
     <!-- Compaction in progress — body-sized moon activity notice -->
     <ActivityNotice v-if="compaction" :label="t('conversation.compacting')" />
 
-    <!-- Working placeholder — moon spinner while the turn is in flight (covers
-         a page refresh mid-stream, where `sending` was lost but the session is
-         still running). -->
+    <!-- Working placeholder — moon spinner while the conversation has an
+         unfinished prompt (covers a page refresh mid-stream, where the
+         optimistic submit flag was lost but the main turn is still in flight). -->
     <div v-if="showWorking" class="sending-placeholder">
       <MoonSpinner :fast="fastMoon" />
     </div>
@@ -703,21 +720,26 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
           >
             <span v-if="item.text" class="u-text q-text">{{ item.text }}</span>
             <span v-else class="q-text q-text-placeholder">
-              <Icon name="image" size="sm" />
-              {{ t('composer.queuedImageOnly', { n: item.attachments?.length ?? 0 }) }}
+              <Icon name="file" size="sm" />
+              {{ t('composer.queuedAttachments', { n: item.attachments?.length ?? 0 }) }}
             </span>
           </button>
-          <div v-if="hasImages(item)" class="q-imgs">
-            <AuthMedia
-              v-for="(att, ai) in item.attachments"
-              :key="ai"
-              :url="att.url"
-              :kind="att.kind"
-              :file-id="att.fileId"
-              media-class="q-img"
-              :controls="false"
-              muted
-            />
+          <div v-if="hasAttachments(item)" class="q-imgs">
+            <template v-for="(att, ai) in item.attachments" :key="ai">
+              <span v-if="att.kind === 'file'" class="q-file">
+                <Icon name="file" size="sm" />
+                {{ att.name ?? att.fileId }}
+              </span>
+              <AuthMedia
+                v-else
+                :url="att.url"
+                :kind="att.kind"
+                :file-id="att.fileId"
+                media-class="q-img"
+                :controls="false"
+                muted
+              />
+            </template>
           </div>
           <span v-if="qi === 0" class="q-tag q-tag-next">{{ t('composer.queueNext') }}</span>
           <span v-else class="q-tag q-tag-idx">#{{ qi + 1 }}</span>
@@ -734,6 +756,10 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
     </div>
   </div>
 
+  <!-- Transient hint after clicking a file chip whose type can't be opened. -->
+  <div v-if="unsupportedOpenName !== null" class="open-unsupported" role="status">
+    {{ t('composer.attachmentOpenUnsupported', { name: unsupportedOpenName }) }}
+  </div>
 </template>
 
 <style scoped>
@@ -773,8 +799,29 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
   padding: 16px 14px 20px;
   flex: 1;
   min-height: 0;
+  position: relative;
 }
 .chat .chat-empty { align-self: stretch; }
+
+/* Bottom-center pill for the "can't open this file type" hint. */
+.open-unsupported {
+  position: absolute;
+  bottom: 16px;
+  left: 50%;
+  transform: translateX(-50%);
+  max-width: min(90%, 480px);
+  padding: 6px 12px;
+  border-radius: var(--radius-md);
+  border: 1px solid var(--color-line);
+  background: var(--color-surface-raised);
+  color: var(--color-text-muted);
+  font-size: var(--ui-font-size-sm);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  pointer-events: none;
+  z-index: 2;
+}
 .chat > .u-turn,
 .chat > .a-msg,
 .chat > .compact-divider,
@@ -1059,39 +1106,14 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
   }
 }
 
-.u-imgs {
+/* Unified attachment chips (files / images / videos) above the bubble text —
+   the chip itself is AttachmentChip; this is only the row layout. */
+.u-atts {
   display: flex;
   flex-wrap: wrap;
   gap: 6px;
   margin-bottom: 8px;
 }
-.u-img {
-  max-width: 100%;
-  max-height: 200px;
-  border-radius: 8px;
-  object-fit: cover;
-}
-/* Clickable image thumbnail — reset button chrome so it looks like the plain
-   image it replaced, while still opening the preview on click. */
-.u-img-btn {
-  display: block;
-  flex: none;
-  align-self: flex-start;
-  max-width: 100%;
-  padding: 0;
-  border: none;
-  background: transparent;
-  cursor: pointer;
-  border-radius: 8px;
-  overflow: hidden;
-}
-.u-img-btn .u-img {
-  display: block;
-}
-.u-img-btn:focus-visible {
-  outline: none;
-  box-shadow: var(--p-focus-ring);
-}
 
 /* NOTE: Chat/bubble styles live in src/style.css (global). Scoped `.u-bub`
    rules here did NOT win the cascade, so they were moved to the global sheet. */
@@ -1133,7 +1155,7 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
   .chat {
     box-sizing: border-box;
     width: 100%;
-    padding: 14px max(12px, env(safe-area-inset-right)) 18px max(12px, env(safe-area-inset-left));
+    padding: 14px max(12px, var(--safe-right)) 18px max(12px, var(--safe-left));
   }
   .u-bub {
     max-width: min(88%, calc(100vw - 52px));
@@ -1347,6 +1369,21 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
   border-radius: var(--radius-sm);
   border: 1px solid var(--color-line);
 }
+.q-file {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  height: 28px;
+  padding: 0 6px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--color-line);
+  color: var(--color-text-muted);
+  font-size: calc(var(--ui-font-size) - 3px);
+  max-width: 160px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
 .q-tag {
   flex: none;
   padding: 1px 6px;
diff --git a/apps/kimi-web/src/components/chat/Composer.vue b/apps/kimi-web/src/components/chat/Composer.vue
index aab185e0e..7062cc78c 100644
--- a/apps/kimi-web/src/components/chat/Composer.vue
+++ b/apps/kimi-web/src/components/chat/Composer.vue
@@ -6,6 +6,7 @@ import { useI18n } from 'vue-i18n';
 import SlashMenu from './SlashMenu.vue';
 import MentionMenu from './MentionMenu.vue';
 import { buildSlashItems, parseSlash, SKILL_COMMAND_PREFIX } from '../../lib/slashCommands';
+import { formatTokens } from '../../lib/formatTokens';
 import type { FileItem } from './MentionMenu.vue';
 import type { ActivationBadges, ConversationStatus, PermissionMode, QueuedPromptView } from '../../types';
 import type { AppGoal, AppModel, AppSkill, ThinkingLevel } from '../../api/types';
@@ -21,13 +22,16 @@ import { useInputHistory } from '../../composables/useInputHistory';
 import { useSlashMenu } from '../../composables/useSlashMenu';
 import { useMentionMenu } from '../../composables/useMentionMenu';
 import { useComposerDraft } from '../../composables/useComposerDraft';
-import { useAttachmentUpload } from '../../composables/useAttachmentUpload';
+import { useAttachmentUpload, type Attachment } from '../../composables/useAttachmentUpload';
+import { openFileAttachment } from '../../lib/openFileAttachment';
+import type { PromptAttachment } from '../../composables/useKimiWebClient';
 import Spinner from '../ui/Spinner.vue';
 import Button from '../ui/Button.vue';
 import IconButton from '../ui/IconButton.vue';
 import Icon from '../ui/Icon.vue';
 import ContextRing from '../ui/ContextRing.vue';
 import Tooltip from '../ui/Tooltip.vue';
+import AttachmentChip from './AttachmentChip.vue';
 
 // ---------------------------------------------------------------------------
 // Props & emits
@@ -82,10 +86,10 @@ const placeholder = computed(() =>
 );
 
 const emit = defineEmits<{
-  submit: [payload: { text: string; attachments: { fileId: string; kind: 'image' | 'video' }[] }];
+  submit: [payload: { text: string; attachments: PromptAttachment[] }];
   /** Steer the composer text (+ any queued prompts, merged by the parent)
       into the RUNNING turn — TUI ctrl+s. */
-  steer: [payload: { text: string; attachments: { fileId: string; kind: 'image' | 'video' }[] }];
+  steer: [payload: { text: string; attachments: PromptAttachment[] }];
   command: [cmd: string];
   interrupt: [];
   setPermission: [mode: PermissionMode];
@@ -287,11 +291,28 @@ function focus(): void {
   // or if focus is triggered during an animation/transition.
   textareaRef.value?.focus({ preventScroll: true });
 }
-function loadAttachmentsForEdit(atts: { fileId?: string; kind: 'image' | 'video'; url: string; name?: string }[]): void {
+function loadAttachmentsForEdit(atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
   loadAttachments(atts);
 }
 defineExpose({ loadForEdit, loadAttachmentsForEdit, focus });
 
+// Build the wire-bound attachment payload: images/videos only need the fileId,
+// while file parts also carry name/mediaType/size for the daemon's file shape.
+function toPromptAttachment(a: Attachment): PromptAttachment {
+  return { fileId: a.fileId!, kind: a.kind, name: a.name, mediaType: a.mediaType, size: a.size };
+}
+
+// Chip primary action: media opens the lightbox preview; a generic file opens
+// in a new tab (browser-renderable types) or downloads, once its upload has
+// completed and produced a daemon file id.
+function onAttachmentActivate(att: Attachment): void {
+  if (att.kind === 'file') {
+    if (att.fileId !== undefined) void openFileAttachment(att.fileId, att.name, att.mediaType);
+    return;
+  }
+  openAttachmentPreview(att);
+}
+
 function handleSubmit(): void {
   const trimmed = text.value.trim();
 
@@ -334,7 +355,7 @@ function handleSubmit(): void {
 
   const payload = {
     text: trimmed,
-    attachments: readyAttachments.map((a) => ({ fileId: a.fileId!, kind: a.kind })),
+    attachments: readyAttachments.map((a) => toPromptAttachment(a)),
   };
 
   // Revoke object URLs and drop the submitted attachments.
@@ -364,7 +385,7 @@ function handleSteer(): void {
 
   const payload = {
     text: trimmed,
-    attachments: readyAttachments.map((a) => ({ fileId: a.fileId!, kind: a.kind })),
+    attachments: readyAttachments.map((a) => toPromptAttachment(a)),
   };
   clearAfterSubmit();
   history.push(trimmed);
@@ -587,14 +608,14 @@ onUnmounted(() => {
   document.removeEventListener('click', onDocClick, true);
 });
 
-// Context formatting
-const kFmt = (n: number) => `${Math.round(n / 1000)}k`;
 // Clamped to 0–100: ctxUsed can momentarily exceed ctxMax (estimates), and
-// ctxMax can be 0 before the first status fetch — both broke the ring.
+// ctxMax can be 0 before the first status fetch — both broke the ring. ceil
+// (not round) so a session under 0.5% usage still shows a sliver of arc —
+// Math.round floored it to an empty, "no data"-looking ring.
 const pct = computed(() => {
   const max = props.status?.ctxMax ?? 0;
   if (max <= 0) return 0;
-  return Math.min(100, Math.max(0, Math.round(((props.status?.ctxUsed ?? 0) / max) * 100)));
+  return Math.min(100, Math.max(0, Math.ceil(((props.status?.ctxUsed ?? 0) / max) * 100)));
 });
 
 const rawPct = computed(() => {
@@ -607,10 +628,10 @@ const rawPct = computed(() => {
 const hasRaw = computed(() => (props.status?.ctxRaw ?? 0) > (props.status?.ctxUsed ?? 0));
 
 const ctxTooltip = computed(() => {
-  const used = (props.status?.ctxUsed ?? 0).toLocaleString();
-  const max = (props.status?.ctxMax ?? 0).toLocaleString();
+  const used = formatTokens(props.status?.ctxUsed ?? 0);
+  const max = formatTokens(props.status?.ctxMax ?? 0);
   if (hasRaw.value) {
-    const raw = (props.status?.ctxRaw ?? 0).toLocaleString();
+    const raw = formatTokens(props.status?.ctxRaw ?? 0);
     return t('status.ctxTooltipRaw', { used, raw, max, pct: pct.value });
   }
   return t('status.ctxTooltip', { used, max, pct: pct.value });
@@ -841,34 +862,22 @@ function selectModel(modelId: string): void {
   >
     <!-- Attachment chips (above the input row) -->
     <div v-if="attachments.length > 0" class="att-strip">
-      <div v-for="att in attachments" :key="att.localId" class="att-chip" :class="{ 'att-error': att.error }">
-        <!-- Thumbnail (video shows its first frame; an icon overlays it) -->
-        <Tooltip :text="t('composer.previewAttachment', { name: att.name })">
-          <button type="button" class="att-preview" @click="openAttachmentPreview(att)">
-            <video v-if="att.kind === 'video'" class="att-thumb" :src="att.previewUrl" muted playsinline preload="metadata" />
-            <img v-else class="att-thumb" :src="att.previewUrl" :alt="att.name" />
-            <span v-if="att.kind === 'video'" class="att-video-badge" aria-hidden="true">
-              <Icon name="play" size="sm" />
-            </span>
-          </button>
-        </Tooltip>
-        <!-- Name + status -->
-        <span class="att-name">{{ att.name }}</span>
-        <!-- Spinner while uploading -->
-        <Spinner v-if="att.uploading" size="sm" :label="t('composer.uploading')" />
-        <!-- Error indicator -->
-        <Tooltip v-else-if="att.error" :text="t('composer.uploadFailed')">
-          <span class="att-err-icon">
-            <Icon name="info" size="sm" />
-          </span>
-        </Tooltip>
-        <!-- Remove button -->
-        <Tooltip :text="t('composer.removeNamed', { name: att.name })">
-          <button class="att-rm" @click="removeAttachment(att.localId)">
-            <Icon name="close" size="sm" />
-          </button>
-        </Tooltip>
-      </div>
+      <AttachmentChip
+        v-for="att in attachments"
+        :key="att.localId"
+        :kind="att.kind"
+        :name="att.name"
+        :url="att.previewUrl"
+        :file-id="att.fileId"
+        :media-type="att.mediaType"
+        :size="att.size"
+        :uploading="att.uploading"
+        :error="att.error"
+        removable
+        :remove-label="t('composer.removeNamed', { name: att.name })"
+        @activate="onAttachmentActivate(att)"
+        @remove="removeAttachment(att.localId)"
+      />
     </div>
 
     <div v-if="previewAttachment" class="att-lightbox" @click.self="closeAttachmentPreview">
@@ -937,12 +946,11 @@ function selectModel(modelId: string): void {
         </div>
       </div>
 
-      <!-- Hidden file input -->
+      <!-- Hidden file input (no accept filter — any file type can be attached) -->
       <input
         v-if="hasUpload"
         ref="fileInputRef"
         type="file"
-        accept="image/*,video/*"
         multiple
         class="file-input-hidden"
         @change="handleFileInputChange"
@@ -959,10 +967,10 @@ function selectModel(modelId: string): void {
           <IconButton
             v-if="hasUpload"
             size="md"
-            :label="t('composer.attachImage')"
+            :label="t('composer.attachFile')"
             @click="openFilePicker"
           >
-            <Icon name="image" />
+            <Icon name="attachment" />
           </IconButton>
 
           <!-- Permission pill — click to open dropdown -->
@@ -1091,12 +1099,10 @@ function selectModel(modelId: string): void {
           <!-- Compact chip when context is high -->
           <button v-if="showCompact" class="compact-chip" @click.stop="emit('compact')">/compact</button>
 
-          <!-- Context meter — circular ring + token count. The ring is
-               aria-hidden, so the trigger exposes the full usage (used/max/pct)
-               via aria-label; focusable so keyboard and switch-control users
-               reach the same tooltip hover users see. The visible "12k/256k"
-               count is hidden under 980px by CSS, but SR users still get this
-               label. -->
+          <!-- Context meter — circular ring only; the full usage (used/max/pct)
+               lives in the tooltip. The ring is aria-hidden, so the trigger
+               exposes those numbers via aria-label; focusable so keyboard and
+               switch-control users reach the same tooltip hover users see. -->
           <Tooltip :text="ctxTooltip">
             <span
               v-if="status && !hideContext"
@@ -1106,7 +1112,7 @@ function selectModel(modelId: string): void {
               :aria-label="ctxTooltip"
             >
               <ContextRing :pct="pct" :raw-pct="hasRaw ? rawPct : undefined" />
-              <span class="ctx-num">{{ kFmt(status.ctxUsed) }}/<template v-if="hasRaw">{{ kFmt(status.ctxRaw) }}/</template>{{ kFmt(status.ctxMax) }}</span>
+              <span class="ctx-num">{{ formatTokens(status.ctxUsed) }}/<template v-if="hasRaw">{{ formatTokens(status.ctxRaw) }}/</template>{{ formatTokens(status.ctxMax) }}</span>
             </span>
           </Tooltip>
 
@@ -1218,6 +1224,16 @@ function selectModel(modelId: string): void {
         </div>
       </div>
   </div>
+  <!-- Full-window drop target affordance: shown while files are dragged anywhere
+       over the app (document-level listeners in useAttachmentUpload). Pure CSS
+       show/hide — a Vue <Transition> can strand an invisible node when the drag
+       ends before the enter transition starts. -->
+  <div class="drop-overlay" :class="{ show: isDragOver }" aria-hidden="true">
+    <div class="drop-card">
+      <Icon name="file-plus" size="lg" />
+      <span>{{ t('composer.dropToAttach') }}</span>
+    </div>
+  </div>
 </div>
 </template>
 
@@ -1232,6 +1248,41 @@ function selectModel(modelId: string): void {
   background: var(--color-accent-soft);
 }
 
+/* Full-window drop overlay: pointer-events none — the document-level handlers
+   in useAttachmentUpload receive the drop, the overlay is purely visual. */
+.drop-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: var(--z-modal);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: color-mix(in srgb, var(--color-bg) 72%, transparent);
+  pointer-events: none;
+  opacity: 0;
+  visibility: hidden;
+  transition:
+    opacity var(--duration-base) ease,
+    visibility var(--duration-base);
+}
+.drop-overlay.show {
+  opacity: 1;
+  visibility: visible;
+}
+.drop-card {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+  padding: var(--space-4) var(--space-6);
+  border-radius: var(--radius-lg);
+  border: 1.5px dashed var(--color-accent);
+  background: var(--color-bg);
+  color: var(--color-accent);
+  font-size: var(--ui-font-size-lg);
+  font-weight: var(--weight-medium);
+  box-shadow: var(--shadow-md);
+}
+
 /* Main composer card */
 .composer-card {
   --composer-send-size: 32px;
@@ -1251,7 +1302,8 @@ function selectModel(modelId: string): void {
 
 
 
-/* Attachment strip */
+/* Attachment strip — the chip itself is the shared AttachmentChip; this is
+   only the row layout above the input. */
 .att-strip {
   display: flex;
   flex-wrap: wrap;
@@ -1259,100 +1311,6 @@ function selectModel(modelId: string): void {
   padding: 4px 0 6px;
 }
 
-.att-chip {
-  position: relative;
-  display: flex;
-  align-items: center;
-  gap: 5px;
-  background: var(--panel2);
-  border: 1px solid var(--color-accent-bd);
-  border-radius: 4px;
-  padding: 3px 6px 3px 4px;
-  font-family: var(--mono);
-  font-size: calc(var(--ui-font-size) - 3px);
-  color: var(--color-text);
-  max-width: 220px;
-}
-
-.att-preview {
-  position: relative;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  border: none;
-  border-radius: var(--radius-xs);
-  background: transparent;
-  padding: 0;
-  cursor: zoom-in;
-  flex: none;
-}
-.att-preview:focus-visible {
-  outline: 2px solid var(--color-accent);
-  outline-offset: 2px;
-}
-
-/* Play glyph over a video thumbnail so it reads as a video, not a still. */
-.att-video-badge {
-  position: absolute;
-  left: 4px;
-  top: 50%;
-  transform: translateY(-50%);
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  width: 16px;
-  height: 16px;
-  border-radius: 50%;
-  background: rgba(0, 0, 0, 0.55);
-  color: var(--color-text-on-accent);
-  pointer-events: none;
-}
-
-.att-chip.att-error {
-  border-color: var(--color-danger);
-  color: var(--color-danger);
-}
-
-.att-thumb {
-  width: 28px;
-  height: 28px;
-  object-fit: cover;
-  border-radius: var(--radius-xs);
-  flex-shrink: 0;
-  background: var(--line2);
-}
-
-.att-name {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  flex: 1;
-  min-width: 0;
-}
-
-.att-err-icon {
-  display: flex;
-  align-items: center;
-  color: var(--color-danger);
-  flex-shrink: 0;
-}
-
-.att-rm {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  background: none;
-  border: none;
-  padding: 1px;
-  cursor: pointer;
-  color: var(--muted);
-  flex-shrink: 0;
-}
-
-.att-rm:hover {
-  color: var(--color-danger);
-}
-
 .att-lightbox {
   position: fixed;
   inset: 0;
@@ -1646,8 +1604,8 @@ function selectModel(modelId: string): void {
   color: var(--color-danger);
 }
 
-/* Context group — circular ring + num. Focusable for keyboard / switch access
-   to its aria-label and tooltip (see template), so it needs a focus ring. */
+/* Context group — circular ring. Focusable for keyboard / switch access to its
+   aria-label and tooltip (see template), so it needs a focus ring. */
 .ctx-group {
   display: flex;
   align-items: center;
@@ -2154,10 +2112,10 @@ function selectModel(modelId: string): void {
    toolbar shows every control on one row and toolbar-left / toolbar-right are
    overflow:hidden, so without shedding ink the row clips its own content. The
    context ring stays visible at every width (it is the live context-pressure
-   signal) but the "12k/256k" readout moves into the ring's tooltip, the model
-   name truncates earlier, and the permission label is capped so the ring and
-   the send button are never squeezed out. Mobile (≤640px) additionally hides
-   perm / modes via the rules below (those live in MobileSettingsSheet there). */
+   signal; the exact numbers live in its tooltip), the model name truncates
+   earlier, and the permission label is capped so the ring and the send button
+   are never squeezed out. Mobile (≤640px) additionally hides perm / modes via
+   the rules below (those live in MobileSettingsSheet there). */
 @media (max-width: 980px) {
   /* The ring already conveys context pressure; the "12k/256k" readout lives in
      the tooltip and returns at wider widths. */
@@ -2186,9 +2144,9 @@ function selectModel(modelId: string): void {
   .composer {
     padding:
       9px
-      var(--dock-inline-right, max(12px, env(safe-area-inset-right)))
-      max(24px, env(safe-area-inset-bottom))
-      var(--dock-inline-left, max(12px, env(safe-area-inset-left)));
+      var(--dock-inline-right, max(12px, var(--safe-right)))
+      max(24px, var(--safe-bottom))
+      var(--dock-inline-left, max(12px, var(--safe-left)));
   }
   .composer-card {
     --composer-send-size: 36px;
@@ -2243,9 +2201,9 @@ function selectModel(modelId: string): void {
   /* Mobile toolbar: hide secondary controls; attach / context ring / model /
      send stay visible. Permission + plan move into the MobileSettingsSheet.
      The context ring stays at every width by design — it is the live
-     context-pressure signal on a phone (the "12k/256k" readout is hidden here
-     by the ≤980px rule above and remains in the ring's tooltip). The /compact
-     chip also stays so compaction is one tap away at ≥80% usage. */
+     context-pressure signal on a phone (the exact numbers live in the ring's
+     tooltip). The /compact chip also stays so compaction is one tap away at
+     ≥80% usage. */
   .perm-pill,
   .modes {
     display: none;
diff --git a/apps/kimi-web/src/components/chat/ConversationPane.vue b/apps/kimi-web/src/components/chat/ConversationPane.vue
index 81a16952a..a33f7fe4b 100644
--- a/apps/kimi-web/src/components/chat/ConversationPane.vue
+++ b/apps/kimi-web/src/components/chat/ConversationPane.vue
@@ -2,9 +2,10 @@
 <script setup lang="ts">
 import { computed, nextTick, onMounted, onUnmounted, provide, ref, watch, type ComponentPublicInstance } from 'vue';
 import { useI18n } from 'vue-i18n';
-import type { ActivationBadges, ApprovalBlock, ChatTurn, ConversationStatus, FilePreviewRequest, PermissionMode, QueuedPromptView, TaskItem, TodoTreeNode, TodoView, ToolMedia, UIQuestion, WorkspaceView } from '../../types';
+import type { ActivationBadges, ApprovalBlock, ChatTurn, ConversationStatus, FilePreviewRequest, PermissionMode, QueuedPromptView, TaskItem, TodoTreeNode, TodoView, ToolMedia, TurnAttachment, UIQuestion, WorkspaceView } from '../../types';
 import type { AppGoal, AppModel, AppSkill, QuestionResponse, ThinkingLevel } from '../../api/types';
 import type { FileItem } from './MentionMenu.vue';
+import type { PromptAttachment } from '../../composables/useKimiWebClient';
 import ChatPane from './ChatPane.vue';
 import ChatHeader from './ChatHeader.vue';
 import Composer from './Composer.vue';
@@ -42,7 +43,11 @@ const props = defineProps<{
   pendingQuestionActions?: Record<string, 'answer' | 'dismiss'>;
   /** Approval ids with an in-flight respond (drives the card loading state). */
   pendingApprovalActions?: Record<string, true>;
+  /** Session busy (any agent, incl. background work) — Stop/Escape affordances. */
   running?: boolean;
+  /** MAIN agent turn in flight — the conversation's streaming state (streaming
+   *  reveal, turn-end scroll settle). Background-only work does NOT set this. */
+  turnActive?: boolean;
   queued?: QueuedPromptView[];
   searchFiles?: (q: string) => Promise<FileItem[]>;
   uploadImage?: (file: Blob, name?: string) => Promise<{ fileId: string; name: string; mediaType: string } | null>;
@@ -50,7 +55,9 @@ const props = defineProps<{
   changes?: { path: string; status: string }[];
   /** Cache-buster that remounts the chat pane when the active session changes. */
   fileReloadKey?: string | number;
-  sending?: boolean;
+  /** The main conversation has an unfinished prompt (submitted or a main turn
+   *  in flight) — the working moon. */
+  working?: boolean;
   /** True while the empty-composer first prompt is being created + submitted.
    *  Drives the empty-session "starting conversation…" loading state. */
   starting?: boolean;
@@ -94,8 +101,8 @@ const props = defineProps<{
 }>();
 
 const emit = defineEmits<{
-  submit: [payload: { text: string; attachments: { fileId: string; kind: 'image' | 'video' }[] }];
-  steer: [payload: { text: string; attachments: { fileId: string; kind: 'image' | 'video' }[] }];
+  submit: [payload: { text: string; attachments: PromptAttachment[] }];
+  steer: [payload: { text: string; attachments: PromptAttachment[] }];
   approval: [approvalId: string, response: { decision: 'approved' | 'rejected' | 'cancelled'; scope?: 'session'; feedback?: string }];
   cancelTask: [taskId: string];
   answer: [questionId: string, response: QuestionResponse];
@@ -125,7 +132,7 @@ const emit = defineEmits<{
   openChanges: [];
   refreshGitStatus: [];
   /** Edit + resend the last user message (App undoes, then refills composer). */
-  editMessage: [payload: { text: string; images?: { url: string; alt?: string; kind: 'image' | 'video'; fileId?: string }[] }];
+  editMessage: [payload: { text: string; attachments?: TurnAttachment[] }];
   /** Empty-composer workspace picker: start a new conversation elsewhere. */
   selectWorkspace: [workspaceId: string];
   /** Empty-composer workspace picker: create a new workspace. */
@@ -192,7 +199,7 @@ let copyConversationCopiedTimer: ReturnType<typeof setTimeout> | null = null;
     so the caller can avoid dropping the prompt. */
 function loadComposerForEdit(
   value: string,
-  attachments?: { fileId?: string; kind: 'image' | 'video'; url: string; name?: string }[],
+  attachments?: TurnAttachment[],
 ): boolean {
   const composer = dockedComposerRef.value ?? emptyComposerRef.value;
   if (!composer) return false;
@@ -425,7 +432,7 @@ const chatDockStyle = computed(() => ({
 }));
 type ComposerHandle = {
   loadForEdit: (value: string) => boolean | void;
-  loadAttachmentsForEdit: (atts: { fileId?: string; kind: 'image' | 'video'; url: string; name?: string }[]) => void;
+  loadAttachmentsForEdit: (atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]) => void;
   focus: () => void;
 };
 type RefArg = Element | (ComponentPublicInstance & Partial<ComposerHandle>) | null;
@@ -898,7 +905,9 @@ watch(
 );
 
 watch(
-  () => props.running,
+  // Settle the scroll-follow when the conversation's turn finishes (not when
+  // background-only work ends — the transcript didn't move then).
+  () => props.turnActive,
   async (now, was) => {
     if (now || !was) return;
     if (!following.value && !hasUserActionFollowLock()) return;
@@ -918,7 +927,7 @@ function followAfterUserAction(): void {
   });
 }
 
-function handleComposerSubmit(payload: { text: string; attachments: { fileId: string; kind: 'image' | 'video' }[] }): void {
+function handleComposerSubmit(payload: { text: string; attachments: PromptAttachment[] }): void {
   followAfterUserAction();
   emit('submit', payload);
 }
@@ -930,7 +939,7 @@ function handleComposerSubmit(payload: { text: string; attachments: { fileId: st
 // smooth-scrolls once the truncated turns actually land.
 function handleEditMessage(payload: {
   text: string;
-  images?: { url: string; alt?: string; kind: 'image' | 'video'; fileId?: string }[];
+  attachments?: TurnAttachment[];
 }): void {
   following.value = true;
   showPill.value = false;
@@ -1170,12 +1179,20 @@ function handleInterrupt(): void {
 }
 
 function onKeyDown(event: KeyboardEvent): void {
-  if (event.key === 'Escape' && (props.running || props.sending)) {
+  if (event.key === 'Escape' && (props.running || props.working)) {
     event.preventDefault();
     handleInterrupt();
   }
 }
 
+// When the on-screen keyboard opens, browsers without interactive-widget support
+// fire a visualViewport resize instead of shrinking the layout viewport. Re-follow
+// the tail so the latest turn stays visible above the keyboard. No-op while the
+// user has manually scrolled away (following === false).
+function onVisualViewportResize(): void {
+  if (following.value) scheduleFollow();
+}
+
 onMounted(() => {
   nextTick(() => {
     if (typeof MutationObserver === 'function') {
@@ -1207,6 +1224,7 @@ onMounted(() => {
       document.addEventListener('visibilitychange', onVisibilityChange);
       document.addEventListener('keydown', onKeyDown);
     }
+    window.visualViewport?.addEventListener('resize', onVisualViewportResize);
   });
 });
 
@@ -1226,6 +1244,7 @@ onUnmounted(() => {
     document.removeEventListener('visibilitychange', onVisibilityChange);
     document.removeEventListener('keydown', onKeyDown);
   }
+  window.visualViewport?.removeEventListener('resize', onVisualViewportResize);
 });
 
 function focusComposer(): void {
@@ -1398,8 +1417,8 @@ defineExpose({ loadComposerForEdit, focusComposer });
               :key="fileReloadKey ?? 'no-session'"
               :turns="turns"
               :approvals="approvals"
-              :running="running"
-              :sending="sending"
+              :turn-active="turnActive"
+              :working="working"
               :fast-moon="fastMoon"
               :session-loading="sessionLoading"
               :compaction="compaction"
diff --git a/apps/kimi-web/src/components/chat/GoalStrip.vue b/apps/kimi-web/src/components/chat/GoalStrip.vue
index c0fddfe36..9689f2a44 100644
--- a/apps/kimi-web/src/components/chat/GoalStrip.vue
+++ b/apps/kimi-web/src/components/chat/GoalStrip.vue
@@ -3,6 +3,7 @@ import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import type { AppGoal } from '../../api/types';
 import { useConfirmDialog } from '../../composables/useConfirmDialog';
+import { formatTokens } from '../../lib/formatTokens';
 import Card from '../ui/Card.vue';
 import Badge from '../ui/Badge.vue';
 import Button from '../ui/Button.vue';
@@ -95,7 +96,7 @@ async function onCancel(): Promise<void> {
       >
         <div class="goal-meta">
           <span>{{ goal.turnsUsed }} turns</span>
-          <span>{{ goal.tokensUsed.toLocaleString() }} tokens</span>
+          <span>{{ formatTokens(goal.tokensUsed) }} tokens</span>
           <span>{{ formatMs(goal.wallClockMs) }}</span>
           <span v-if="goal.budget.tokenBudget !== null">{{ tokenPct }}% token budget</span>
         </div>
diff --git a/apps/kimi-web/src/components/chat/Markdown.vue b/apps/kimi-web/src/components/chat/Markdown.vue
index 0432bc180..3e20657dd 100644
--- a/apps/kimi-web/src/components/chat/Markdown.vue
+++ b/apps/kimi-web/src/components/chat/Markdown.vue
@@ -338,6 +338,15 @@ const codeBlockProps = {
   loading: false,
 };
 
+function copyCodeBlockFallback(code: string): void {
+  // markstream emits `copy` even when it skipped the write because the
+  // Clipboard API is unavailable. Reuse our plain-HTTP fallback in that case,
+  // while avoiding a duplicate write after markstream succeeds on HTTPS.
+  const clipboard = typeof navigator !== 'undefined' ? navigator.clipboard : undefined;
+  if (clipboard && typeof clipboard.writeText === 'function') return;
+  void copyTextToClipboard(code);
+}
+
 // Root cause for the "large session turns into code skeletons" failure:
 // markstream mounts every code block in the loaded transcript, then shiki has
 // to tokenize all of them. `loading: false` removes the visible skeleton gate,
@@ -437,6 +446,7 @@ function copyDiff(code: string, idx: number) {
         :smooth-streaming="streaming"
         :batch-rendering="allowBatchRender"
         :defer-nodes-until-visible="false"
+        @copy="copyCodeBlockFallback"
       />
 
       <!-- ```diff fence → local renderer (preserves +/- markers + colours) -->
diff --git a/apps/kimi-web/src/components/chat/QuestionCard.vue b/apps/kimi-web/src/components/chat/QuestionCard.vue
index 361716779..6fdf48fdb 100644
--- a/apps/kimi-web/src/components/chat/QuestionCard.vue
+++ b/apps/kimi-web/src/components/chat/QuestionCard.vue
@@ -283,7 +283,7 @@ onUnmounted(() => document.removeEventListener('keydown', handleKeydown));
           :label="minimized ? t('question.expand') : t('question.minimize')"
           @click="minimized = !minimized"
         >
-          <Icon v-if="minimized" name="chevron-down" size="md" />
+          <Icon v-if="minimized" name="chevron-up" size="md" />
           <Icon v-else name="minus" size="md" />
         </IconButton>
       </div>
diff --git a/apps/kimi-web/src/components/chat/SideChatPanel.vue b/apps/kimi-web/src/components/chat/SideChatPanel.vue
index 87fb34592..473c17969 100644
--- a/apps/kimi-web/src/components/chat/SideChatPanel.vue
+++ b/apps/kimi-web/src/components/chat/SideChatPanel.vue
@@ -115,8 +115,8 @@ function autosize(): void {
         v-else
         :turns="turns"
         :approvals="[]"
-        :running="running"
-        :sending="sending"
+        :turn-active="running"
+        :working="sending || running"
       />
       <div v-if="showLoading" class="sc-loading" aria-hidden="true">
         <MoonSpinner />
diff --git a/apps/kimi-web/src/components/chat/StatusPanel.vue b/apps/kimi-web/src/components/chat/StatusPanel.vue
index cc95774c1..6d51e6148 100644
--- a/apps/kimi-web/src/components/chat/StatusPanel.vue
+++ b/apps/kimi-web/src/components/chat/StatusPanel.vue
@@ -6,6 +6,7 @@ import { computed, ref } from 'vue';
 import { useI18n } from 'vue-i18n';
 import type { ConversationStatus, PermissionMode } from '../../types';
 import type { ThinkingLevel } from '../../api/types';
+import { formatTokens } from '../../lib/formatTokens';
 import Dialog from '../ui/Dialog.vue';
 
 const { t } = useI18n();
@@ -28,15 +29,18 @@ const emit = defineEmits<{
 // button, which we forward to the parent.
 const open = ref(true);
 
-const pct = computed(() =>
-  props.status.ctxMax > 0 ? Math.round((props.status.ctxUsed / props.status.ctxMax) * 100) : 0,
-);
+// ceil (not round) so sub-0.5% usage still renders a visible bar sliver;
+// clamped to 0–100 — ctxUsed can momentarily exceed ctxMax (estimates).
+const pct = computed(() => {
+  if (props.status.ctxMax <= 0) return 0;
+  return Math.min(100, Math.max(0, Math.ceil((props.status.ctxUsed / props.status.ctxMax) * 100)));
+});
 
 const contextValue = computed(() =>
   props.status.ctxMax > 0
     ? t('status.statusContextValue', {
-        used: props.status.ctxUsed.toLocaleString(),
-        max: props.status.ctxMax.toLocaleString(),
+        used: formatTokens(props.status.ctxUsed),
+        max: formatTokens(props.status.ctxMax),
         pct: pct.value,
       })
     : t('status.statusNone'),
diff --git a/apps/kimi-web/src/components/chat/tool-calls/SwarmTool.vue b/apps/kimi-web/src/components/chat/tool-calls/SwarmTool.vue
index 15e0ce2ad..a970942cd 100644
--- a/apps/kimi-web/src/components/chat/tool-calls/SwarmTool.vue
+++ b/apps/kimi-web/src/components/chat/tool-calls/SwarmTool.vue
@@ -1,6 +1,7 @@
 <!-- apps/kimi-web/src/components/chat/tool-calls/SwarmTool.vue -->
 <!-- A single AgentSwarm tool call, rendered as one inline "operation card".
-     Defaults to collapsed; when opened the body shows a phase overview and a
+     Expanded by default while the swarm runs, collapsed once settled; when
+     opened the body shows a phase overview and a phase overview and a
      per-member accordion — each subagent is a collapsible row (state dot +
      name + one-line activity + phase) that expands on its own to reveal the
      full output. While the swarm runs the rows come from the AppTask store
@@ -120,8 +121,10 @@ const segments = computed<Segment[]>(() =>
   ),
 );
 
-// Collapsed by default — §04 tool rows expand on demand.
-const open = ref(false);
+// Running swarms start expanded so live progress is visible without a click;
+// settled cards (history, finished runs) stay collapsed — §04 tool rows
+// expand on demand. The default applies only at mount; manual toggles stick.
+const open = ref(status.value === 'running' || inProgress.value > 0);
 function toggle(): void {
   open.value = !open.value;
 }
diff --git a/apps/kimi-web/src/components/chatTurnRendering.ts b/apps/kimi-web/src/components/chatTurnRendering.ts
index f928adf2d..be57896bd 100644
--- a/apps/kimi-web/src/components/chatTurnRendering.ts
+++ b/apps/kimi-web/src/components/chatTurnRendering.ts
@@ -4,11 +4,9 @@
 // stateful copy/edit helpers.
 import type { ChatTurn, TurnBlock } from '../types';
 
-export function formatTokens(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
-  return String(n);
-}
+// Shared 1024-based token formatter (lib/formatTokens); re-exported so the
+// existing ChatPane import keeps working.
+export { formatTokens } from '../lib/formatTokens';
 
 export function formatDuration(ms: number): string {
   if (ms < 1000) return `${ms}ms`;
diff --git a/apps/kimi-web/src/components/dialogs/AddWorkspaceDialog.vue b/apps/kimi-web/src/components/dialogs/AddWorkspaceDialog.vue
index 3144b5982..26aeafec2 100644
--- a/apps/kimi-web/src/components/dialogs/AddWorkspaceDialog.vue
+++ b/apps/kimi-web/src/components/dialogs/AddWorkspaceDialog.vue
@@ -22,7 +22,6 @@ import Dialog from '../ui/Dialog.vue';
 import Button from '../ui/Button.vue';
 import IconButton from '../ui/IconButton.vue';
 import Spinner from '../ui/Spinner.vue';
-import Badge from '../ui/Badge.vue';
 import Icon from '../ui/Icon.vue';
 import Tooltip from '../ui/Tooltip.vue';
 
@@ -62,7 +61,7 @@ const entries = ref<FsBrowseEntry[]>([]);
 // dialog never resizes while searching.
 const filter = ref('');
 const searching = ref(false);
-interface SearchHit { path: string; name: string; rel: string; isGitRepo?: boolean; branch?: string }
+interface SearchHit { path: string; name: string; rel: string }
 const searchResults = ref<SearchHit[]>([]);
 const isSearching = computed(() => filter.value.trim().length > 0);
 let searchToken = 0;
@@ -137,7 +136,7 @@ async function runSearch(query: string): Promise<void> {
       if (!e.isDir) continue;
       const rel = e.path.startsWith(root) ? e.path.slice(root.length).replace(/^\/+/, '') : e.path;
       if (fuzzyMatch(q, rel || e.name)) {
-        hits.push({ path: e.path, name: e.name, rel: rel || e.name, isGitRepo: e.isGitRepo, branch: e.branch });
+        hits.push({ path: e.path, name: e.name, rel: rel || e.name });
         if (hits.length >= SEARCH_MAX_RESULTS) break;
       }
       if (node.depth + 1 < SEARCH_MAX_DEPTH) queue.push({ path: e.path, depth: node.depth + 1 });
@@ -419,9 +418,6 @@ onUnmounted(() => {
             >
               <Icon class="dir-icon" name="folder-closed" size="sm" />
               <span class="folder-name">{{ c.name }}</span>
-              <Badge v-if="c.isGitRepo" variant="info" size="sm">
-                {{ t('workspace.gitTag') }}<span v-if="c.branch" class="git-branch"> {{ c.branch }}</span>
-              </Badge>
             </button>
             <div v-if="pathCandidates.length === 0" class="fl-empty fl-error">
               {{ t('workspace.noPathMatch', { parent: pathParent }) }}
@@ -442,9 +438,6 @@ onUnmounted(() => {
           >
             <Icon class="dir-icon" name="folder-closed" size="sm" />
             <span class="folder-name search-rel">{{ hit.rel }}</span>
-            <Badge v-if="hit.isGitRepo" variant="info" size="sm">
-              {{ t('workspace.gitTag') }}<span v-if="hit.branch" class="git-branch"> {{ hit.branch }}</span>
-            </Badge>
           </button>
           <div v-if="!searching && searchResults.length === 0" class="fl-empty">{{ t('workspace.noFilterMatch', { q: filter.trim() }) }}</div>
           <div v-else-if="searching && searchResults.length === 0" class="fl-loading">{{ t('workspace.searching') }}</div>
@@ -460,9 +453,6 @@ onUnmounted(() => {
           >
             <Icon class="dir-icon" name="folder-closed" size="sm" />
             <span class="folder-name">{{ entry.name }}</span>
-            <Badge v-if="entry.isGitRepo" variant="info" size="sm">
-              {{ t('workspace.gitTag') }}<span v-if="entry.branch" class="git-branch"> {{ entry.branch }}</span>
-            </Badge>
           </button>
           <div v-if="entries.length === 0" class="fl-empty">{{ t('workspace.noSubfolders') }}</div>
         </template>
@@ -603,7 +593,6 @@ onUnmounted(() => {
   white-space: nowrap;
   color: var(--color-text);
 }
-.git-branch { color: var(--color-text-muted); }
 
 /* Degraded mode (daemon can't browse): compact hint under the input box. */
 .degraded-hint {
diff --git a/apps/kimi-web/src/components/dialogs/BottomSheet.vue b/apps/kimi-web/src/components/dialogs/BottomSheet.vue
index 9ed654d08..4435ffd8c 100644
--- a/apps/kimi-web/src/components/dialogs/BottomSheet.vue
+++ b/apps/kimi-web/src/components/dialogs/BottomSheet.vue
@@ -145,7 +145,7 @@ onUnmounted(() => {
   min-height: 0;
   overflow-y: auto;
   -webkit-overflow-scrolling: touch;
-  padding-bottom: max(10px, env(safe-area-inset-bottom));
+  padding-bottom: max(16px, var(--safe-bottom));
 }
 
 /* Slide-up + fade transition for the whole sheet (scrim fades, panel slides). */
diff --git a/apps/kimi-web/src/components/dialogs/ConfirmDialog.vue b/apps/kimi-web/src/components/dialogs/ConfirmDialog.vue
index a4ac057d1..508b0db68 100644
--- a/apps/kimi-web/src/components/dialogs/ConfirmDialog.vue
+++ b/apps/kimi-web/src/components/dialogs/ConfirmDialog.vue
@@ -3,18 +3,11 @@
      Dialog (height auto, right-aligned footer). The single confirmation surface
      for user actions — driven app-wide by useConfirmDialog(). -->
 <script setup lang="ts">
-import { onBeforeUnmount, ref } from 'vue';
+import { onBeforeUnmount } from 'vue';
 import { useI18n } from 'vue-i18n';
 import Dialog from '../ui/Dialog.vue';
 import Button from '../ui/Button.vue';
 
-const confirmButtonRef = ref<InstanceType<typeof Button> | null>(null);
-
-function confirmButtonElement(): HTMLElement | null {
-  const el = confirmButtonRef.value?.$el;
-  return el instanceof HTMLElement ? el : null;
-}
-
 const props = withDefaults(defineProps<{
   open: boolean;
   title: string;
@@ -37,6 +30,10 @@ const emit = defineEmits<{
 const { t } = useI18n();
 
 function onCancel(): void {
+  // While the confirm action runs (loading), every cancel path — Cancel
+  // button, header close, Esc, overlay click — is inert so the dialog can't
+  // be dismissed out from under the in-flight work.
+  if (props.loading) return;
   emit('update:open', false);
   emit('cancel');
 }
@@ -70,11 +67,17 @@ onBeforeUnmount(() => {
 </script>
 
 <template>
+  <!-- initial-focus uses a selector, not the Button component's $el: Button
+       has a template-root comment, so in dev builds it renders as a fragment
+       whose $el is a text node (unfocusable) — focus would fall back to the
+       header close button and Enter would cancel instead of confirm. -->
   <Dialog
     :open="open"
     :title="title"
     height="auto"
-    :initial-focus="confirmButtonElement"
+    initial-focus=".confirm-dialog__confirm"
+    :close-on-esc="!loading"
+    :close-on-overlay="!loading"
     @update:open="emit('update:open', $event)"
     @close="onCancel"
   >
@@ -84,7 +87,7 @@ onBeforeUnmount(() => {
         {{ cancelLabel ?? t('common.cancel') }}
       </Button>
       <Button
-        ref="confirmButtonRef"
+        class="confirm-dialog__confirm"
         :variant="variant"
         :loading="loading"
         @click="emit('confirm')"
diff --git a/apps/kimi-web/src/components/dialogs/ConfirmDialogHost.vue b/apps/kimi-web/src/components/dialogs/ConfirmDialogHost.vue
index d07e71692..ddb2e4ac6 100644
--- a/apps/kimi-web/src/components/dialogs/ConfirmDialogHost.vue
+++ b/apps/kimi-web/src/components/dialogs/ConfirmDialogHost.vue
@@ -5,7 +5,13 @@
 import { useConfirmDialog } from '../../composables/useConfirmDialog';
 import ConfirmDialog from './ConfirmDialog.vue';
 
-const { current, settle } = useConfirmDialog();
+const { current, busy, settle, runAction } = useConfirmDialog();
+
+// runAction never rejects (a failing action rejects the confirm() promise
+// instead), so the floating promise is safe to drop here.
+function onConfirm(): void {
+  void runAction();
+}
 </script>
 
 <template>
@@ -16,7 +22,8 @@ const { current, settle } = useConfirmDialog();
     :confirm-label="current?.confirmLabel"
     :cancel-label="current?.cancelLabel"
     :variant="current?.variant"
-    @confirm="settle(true)"
+    :loading="busy"
+    @confirm="onConfirm"
     @cancel="settle(false)"
   />
 </template>
diff --git a/apps/kimi-web/src/components/dialogs/LoginDialog.vue b/apps/kimi-web/src/components/dialogs/LoginDialog.vue
index 54cf17a2a..279b5f364 100644
--- a/apps/kimi-web/src/components/dialogs/LoginDialog.vue
+++ b/apps/kimi-web/src/components/dialogs/LoginDialog.vue
@@ -71,6 +71,9 @@ const props = defineProps<{
 
 type Step = 'starting' | 'device-code' | 'success' | 'expired' | 'error';
 const step = ref<Step>('starting');
+// True when the error step came from repeated poll failures (daemon gone)
+// rather than startOAuthLogin failing (unsupported endpoint) — picks the copy.
+const pollError = ref(false);
 
 interface FlowData {
   flowId: string;
@@ -87,6 +90,11 @@ const copied = ref(false);
 
 let pollTimer: ReturnType<typeof setTimeout> | null = null;
 let countdownTimer: ReturnType<typeof setInterval> | null = null;
+// Consecutive failed polls (onPollOAuthLogin returned null). A single null can
+// be a transient blip; several in a row means the daemon is gone and polling
+// forever would strand the user on "waiting for authorization".
+let consecutivePollFailures = 0;
+const MAX_CONSECUTIVE_POLL_FAILURES = 3;
 
 // -------------------------------------------------------------------------
 // Lifecycle
@@ -107,6 +115,8 @@ onUnmounted(() => {
 async function startFlow(): Promise<void> {
   stopTimers();
   flow.value = null;
+  pollError.value = false;
+  consecutivePollFailures = 0;
   step.value = 'starting';
 
   const result = await props.onStartOAuthLogin();
@@ -158,18 +168,32 @@ function scheduleNextPoll(intervalSec: number): void {
   if (pollTimer) clearTimeout(pollTimer);
   pollTimer = setTimeout(async () => {
     const result = await props.onPollOAuthLogin();
-    if (result?.status === 'authenticated') {
+    if (result === null) {
+      // Poll failed (or no active flow). Keep polling through transient
+      // blips, but give up with an explicit error after several in a row.
+      consecutivePollFailures += 1;
+      if (consecutivePollFailures >= MAX_CONSECUTIVE_POLL_FAILURES) {
+        stopTimers();
+        pollError.value = true;
+        step.value = 'error';
+        return;
+      }
+      scheduleNextPoll(intervalSec);
+      return;
+    }
+    consecutivePollFailures = 0;
+    if (result.status === 'authenticated') {
       stopTimers();
       step.value = 'success';
       setTimeout(() => {
         emit('success');
         emit('close');
       }, 1200);
-    } else if (result?.status === 'expired' || result?.status === 'cancelled') {
+    } else if (result.status === 'expired' || result.status === 'cancelled') {
       stopTimers();
       step.value = 'expired';
     } else {
-      // pending or null — keep polling
+      // pending — keep polling
       scheduleNextPoll(intervalSec);
     }
   }, intervalSec * 1000);
@@ -289,12 +313,16 @@ function formatSeconds(s: number): string {
       </div>
     </template>
 
-    <!-- Error (endpoint missing or network failure) -->
+    <!-- Error (endpoint missing, network failure, or repeated poll failures) -->
     <template v-else-if="step === 'error'">
       <div class="center-body">
         <AuthStateIcon kind="error" />
-        <span class="center-text warn-text">{{ t('login.errorTitle') }}</span>
-        <span class="center-hint">{{ t('login.errorHint') }}</span>
+        <span class="center-text warn-text">
+          {{ pollError ? t('login.pollErrorTitle') : t('login.errorTitle') }}
+        </span>
+        <span class="center-hint">
+          {{ pollError ? t('login.pollErrorHint') : t('login.errorHint') }}
+        </span>
       </div>
       <div class="actions">
         <Button variant="primary" @click="retryFlow">{{ t('login.retry') }}</Button>
diff --git a/apps/kimi-web/src/components/mobile/MobileSettingsSheet.vue b/apps/kimi-web/src/components/mobile/MobileSettingsSheet.vue
index a3c78524e..6e80a74fe 100644
--- a/apps/kimi-web/src/components/mobile/MobileSettingsSheet.vue
+++ b/apps/kimi-web/src/components/mobile/MobileSettingsSheet.vue
@@ -21,6 +21,7 @@ import {
 } from '../../lib/modelThinking';
 import BottomSheet from '../dialogs/BottomSheet.vue';
 import LanguageSwitcher from '../settings/LanguageSwitcher.vue';
+import { formatTokens } from '../../lib/formatTokens';
 import Button from '../ui/Button.vue';
 import Input from '../ui/Input.vue';
 import SegmentedControl from '../ui/SegmentedControl.vue';
@@ -106,15 +107,15 @@ const permSub = computed<string>(() => {
   return `${p} · ${desc}`;
 });
 
-const kFmt = (n: number): string => `${Math.round(n / 1000)}k`;
 const ctxPct = computed<number>(() =>
+  // ceil (not round) so sub-0.5% usage still renders a visible bar sliver.
   props.status.ctxMax > 0
-    ? Math.min(100, Math.max(0, Math.round((props.status.ctxUsed / props.status.ctxMax) * 100)))
+    ? Math.min(100, Math.max(0, Math.ceil((props.status.ctxUsed / props.status.ctxMax) * 100)))
     : 0,
 );
-// Same "12k/256k" format as the desktop toolbar ring.
+// Shared 1024-based formatter, same as the desktop tooltip / status panel.
 const ctxValue = computed<string>(() =>
-  props.status.ctxMax > 0 ? `${kFmt(props.status.ctxUsed)}/${kFmt(props.status.ctxMax)}` : t('status.statusNone'),
+  props.status.ctxMax > 0 ? `${formatTokens(props.status.ctxUsed)}/${formatTokens(props.status.ctxMax)}` : t('status.statusNone'),
 );
 
 function setThinkingSegment(value: string): void {
@@ -585,11 +586,11 @@ watch(
     align-items: flex-start;
     gap: 10px;
     min-width: 0;
-    padding: 14px max(14px, env(safe-area-inset-right)) 14px max(14px, env(safe-area-inset-left));
+    padding: 14px max(14px, var(--safe-right)) 14px max(14px, var(--safe-left));
   }
   .group-title {
-    padding-left: max(14px, env(safe-area-inset-left));
-    padding-right: max(14px, env(safe-area-inset-right));
+    padding-left: max(14px, var(--safe-left));
+    padding-right: max(14px, var(--safe-right));
   }
   .srow-main {
     flex: 1 1 auto;
diff --git a/apps/kimi-web/src/components/mobile/MobileSwitcherSheet.vue b/apps/kimi-web/src/components/mobile/MobileSwitcherSheet.vue
index 4a87b0cc0..1de3de426 100644
--- a/apps/kimi-web/src/components/mobile/MobileSwitcherSheet.vue
+++ b/apps/kimi-web/src/components/mobile/MobileSwitcherSheet.vue
@@ -1,7 +1,7 @@
 <!-- apps/kimi-web/src/components/mobile/MobileSwitcherSheet.vue -->
 <!-- Mobile switcher bottom sheet, mirroring the desktop sidebar: a "+ New
      chat" row, then collapsible workspace groups (folder icon + name +
-     branch/path sub-line + per-group "+") with their session rows beneath.
+     path sub-line + per-group "+") with their session rows beneath.
      Tapping a session selects it AND closes the sheet; tapping a group header
      folds it, same as the desktop sidebar. -->
 <script setup lang="ts">
@@ -9,7 +9,6 @@ import { ref } from 'vue';
 import { useI18n } from 'vue-i18n';
 import type { Session, WorkspaceGroup, WorkspaceView } from '../../types';
 import { copyTextToClipboard } from '../../lib/clipboard';
-import { useConfirmDialog } from '../../composables/useConfirmDialog';
 import BottomSheet from '../dialogs/BottomSheet.vue';
 import IconButton from '../ui/IconButton.vue';
 import Icon from '../ui/Icon.vue';
@@ -18,7 +17,6 @@ import MenuItem from '../ui/MenuItem.vue';
 import Tooltip from '../ui/Tooltip.vue';
 
 const { t } = useI18n();
-const { confirm } = useConfirmDialog();
 
 const props = withDefaults(
   defineProps<{
@@ -45,7 +43,7 @@ const emit = defineEmits<{
   addWorkspace: [];
   rename: [id: string, title: string];
   archive: [id: string];
-  /** NOTE: needs `@delete-workspace="client.deleteWorkspace($event)"` wiring in App.vue. */
+  /** NOTE: App.vue wires this to confirmDeleteWorkspace (modal confirm + async delete). */
   deleteWorkspace: [workspaceId: string];
   loadMore: [workspaceId: string];
 }>();
@@ -152,23 +150,16 @@ function onRename(s: Session): void {
   const title = next?.trim();
   if (title) emit('rename', s.id, title);
 }
-async function onArchive(id: string): Promise<void> {
+function onArchive(id: string): void {
   menuFor.value = null;
-  if (
-    await confirm({
-      title: t('sidebar.archive'),
-      message: t('sidebar.archiveConfirm'),
-      variant: 'danger',
-    })
-  ) {
-    emit('archive', id);
-  }
+  // The modal confirm + async archive live in App.vue (confirmArchiveSession).
+  emit('archive', id);
 }
 
 // ---------------------------------------------------------------------------
 // Per-workspace "…" menu: copy path + delete workspace. Copy path is handled
-// locally, like the desktop sidebar; delete is confirmed via modal then
-// emitted to the parent.
+// locally, like the desktop sidebar; delete is emitted to the parent (App.vue
+// owns the modal confirm + async delete).
 // ---------------------------------------------------------------------------
 const wsMenuFor = ref<string | null>(null);
 
@@ -180,17 +171,9 @@ function onCopyWsPath(ws: WorkspaceView): void {
   void copyTextToClipboard(ws.root);
   wsMenuFor.value = null;
 }
-async function onDeleteWorkspace(ws: WorkspaceView): Promise<void> {
+function onDeleteWorkspace(ws: WorkspaceView): void {
   wsMenuFor.value = null;
-  if (
-    await confirm({
-      title: t('sidebar.removeWorkspace'),
-      message: t('workspace.removeWorkspaceConfirm', { name: ws.name }),
-      variant: 'danger',
-    })
-  ) {
-    emit('deleteWorkspace', ws.id);
-  }
+  emit('deleteWorkspace', ws.id);
 }
 </script>
 
@@ -228,7 +211,7 @@ async function onDeleteWorkspace(ws: WorkspaceView): Promise<void> {
           <div class="mgh-main">
             <span class="mgh-name">{{ g.workspace.name }}</span>
             <Tooltip :text="g.workspace.root">
-              <span class="mgh-path">{{ g.workspace.branch || g.workspace.shortPath }}</span>
+              <span class="mgh-path">{{ g.workspace.shortPath }}</span>
             </Tooltip>
           </div>
 
@@ -274,7 +257,7 @@ async function onDeleteWorkspace(ws: WorkspaceView): Promise<void> {
             @click="onSelectSession(s.id)"
           >
             <div class="m">
-              <div class="t" :class="{ run: s.busy, aborted: s.status === 'aborted' }">{{ s.title }}</div>
+              <div class="t" :class="{ run: s.busy, aborted: !s.busy && (attentionBySession[s.id] ?? 0) === 0 && (s.lastTurnReason === 'cancelled' || s.lastTurnReason === 'failed') }">{{ s.title }}</div>
               <div class="s">{{ s.time }}</div>
             </div>
             <span v-if="(attentionBySession[s.id] ?? 0) > 0" class="att">{{ attentionBySession[s.id] }}</span>
diff --git a/apps/kimi-web/src/components/mobile/MobileTopBar.vue b/apps/kimi-web/src/components/mobile/MobileTopBar.vue
index 42303d0a9..df34d8fde 100644
--- a/apps/kimi-web/src/components/mobile/MobileTopBar.vue
+++ b/apps/kimi-web/src/components/mobile/MobileTopBar.vue
@@ -90,9 +90,11 @@ const statusText = computed<string>(() =>
   display: flex;
   align-items: center;
   gap: 10px;
-  height: 50px;
+  /* Grow the bar by the top inset so the 50px content row stays below the
+     status bar / notch in standalone PWA mode and landscape. */
+  height: calc(50px + var(--safe-top));
   flex: none;
-  padding: 0 12px;
+  padding: var(--safe-top) max(12px, var(--safe-right)) 0 max(12px, var(--safe-left));
   border-bottom: 1px solid var(--color-line);
   background: var(--color-bg);
   font-family: var(--font-ui);
diff --git a/apps/kimi-web/src/components/settings/ModelPicker.vue b/apps/kimi-web/src/components/settings/ModelPicker.vue
index d705511c0..16541ef64 100644
--- a/apps/kimi-web/src/components/settings/ModelPicker.vue
+++ b/apps/kimi-web/src/components/settings/ModelPicker.vue
@@ -5,6 +5,7 @@ import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import type { AppModel } from '../../api/types';
 import { useDialogFocus } from '../../composables/useDialogFocus';
+import { formatTokens } from '../../lib/formatTokens';
 import Dialog from '../ui/Dialog.vue';
 import Button from '../ui/Button.vue';
 import IconButton from '../ui/IconButton.vue';
@@ -197,7 +198,7 @@ function selectTab(tabId: string): void {
             </span>
           </span>
           <span class="model-provider">{{ m.provider }}</span>
-          <span class="model-ctx">{{ t('model.contextSuffix', { size: Math.round(m.maxContextSize / 1000) }) }}</span>
+          <span class="model-ctx">{{ t('model.contextSuffix', { size: formatTokens(m.maxContextSize) }) }}</span>
           <IconButton
             size="sm"
             :label="isStarred(m.id) ? t('model.unstarTitle') : t('model.starTitle')"
diff --git a/apps/kimi-web/src/components/settings/ProviderManager.vue b/apps/kimi-web/src/components/settings/ProviderManager.vue
index 46c593e24..e9316f6bd 100644
--- a/apps/kimi-web/src/components/settings/ProviderManager.vue
+++ b/apps/kimi-web/src/components/settings/ProviderManager.vue
@@ -14,10 +14,8 @@ import Input from '../ui/Input.vue';
 import Select from '../ui/Select.vue';
 import Icon from '../ui/Icon.vue';
 import Tooltip from '../ui/Tooltip.vue';
-import { useConfirmDialog } from '../../composables/useConfirmDialog';
 
 const { t } = useI18n();
-const { confirm } = useConfirmDialog();
 
 const dialogRef = ref<HTMLElement | null>(null);
 // Move focus into the dialog on open; restore it to the opener on close.
@@ -43,17 +41,10 @@ const emit = defineEmits<{
 // Delete confirmation
 // -------------------------------------------------------------------------
 
-// Delete confirmation — modal, consistent with remove-workspace.
-async function onDeleteProvider(id: string): Promise<void> {
-  if (
-    await confirm({
-      title: t('providers.delete'),
-      message: t('providers.confirmDelete'),
-      variant: 'danger',
-    })
-  ) {
-    emit('delete', id);
-  }
+// Delete — the modal confirm and the async delete live in App.vue
+// (confirmDeleteProvider); the manager only emits the intent.
+function onDeleteProvider(id: string): void {
+  emit('delete', id);
 }
 
 // -------------------------------------------------------------------------
diff --git a/apps/kimi-web/src/composables/client/eventBatcher.ts b/apps/kimi-web/src/composables/client/eventBatcher.ts
index a42d02836..1c0b0702e 100644
--- a/apps/kimi-web/src/composables/client/eventBatcher.ts
+++ b/apps/kimi-web/src/composables/client/eventBatcher.ts
@@ -1,13 +1,13 @@
 // apps/kimi-web/src/composables/client/eventBatcher.ts
-// Coalesce high-frequency streaming events onto the next animation frame.
+// Coalesce high-frequency streaming events and apply them in bounded slices.
 //
-// Pure logic (no Vue, no DOM) so it is unit-testable in isolation. See
-// useKimiWebClient.ts for where it is wired into the WS event pipeline.
+// Pure logic (no Vue) so the queue, ordering, and scheduler fallback can be
+// tested directly. See useKimiWebClient.ts for the WS pipeline wiring.
 
-import type { AppEvent } from '../../api/types';
+import type { AppEvent, KimiEventMeta } from '../../api/types';
 
 // Events that merely append a chunk to something already streaming. They can
-// arrive dozens to hundreds of times per second, so they are worth coalescing.
+// arrive dozens to hundreds of times per second, so they are worth batching.
 const RENDER_EVENT_TYPES: ReadonlySet<AppEvent['type']> = new Set<AppEvent['type']>([
   'assistantDelta',
   'agentDelta',
@@ -15,66 +15,316 @@ const RENDER_EVENT_TYPES: ReadonlySet<AppEvent['type']> = new Set<AppEvent['type
   'taskProgress',
 ]);
 
-/** True for high-frequency render-only events that are safe to delay to the
-    next animation frame. Everything else (lifecycle / control-flow) must apply
-    immediately so turn-end cleanup etc. is not delayed by a throttled rAF. */
+/** True for high-frequency render events. Lifecycle / control events remain
+    ordering barriers and are never merged with render events. */
 export function isRenderEvent(appEvent: AppEvent): boolean {
   return RENDER_EVENT_TYPES.has(appEvent.type);
 }
 
-function defaultScheduleFrame(cb: () => void): number {
-  return typeof requestAnimationFrame === 'function'
-    ? requestAnimationFrame(cb)
-    : (setTimeout(cb, 16) as unknown as number);
+export interface EventBatcherScheduler {
+  /** Request the next visual frame. Return null when frames are unavailable. */
+  requestFrame(callback: () => void): number | null;
+  cancelFrame(handle: number): void;
+  /** Request a task that still runs when animation frames are suspended. */
+  requestTask(callback: () => void): number;
+  cancelTask(handle: number): void;
+}
+
+const FALLBACK_TASK_DELAY_MS = 50;
+const DEFAULT_MAX_ITEMS_PER_SLICE = 100;
+/** Keep each append passed to the reducer small enough that concatenation and
+ *  Markdown invalidation remain bounded. Offsets use JS string lengths, so the
+ *  limit is measured in UTF-16 code units too. */
+const MAX_COALESCED_STREAM_CHARS = 32 * 1024;
+
+const defaultScheduler: EventBatcherScheduler = {
+  requestFrame(callback) {
+    return typeof requestAnimationFrame === 'function'
+      ? requestAnimationFrame(callback)
+      : null;
+  },
+  cancelFrame(handle) {
+    if (typeof cancelAnimationFrame === 'function') cancelAnimationFrame(handle);
+  },
+  requestTask(callback) {
+    return setTimeout(callback, FALLBACK_TASK_DELAY_MS) as unknown as number;
+  },
+  cancelTask(handle) {
+    clearTimeout(handle);
+  },
+};
+
+export interface EventBatcherOptions<T> {
+  /** Merge the new item into the last pending item, or return undefined. */
+  coalesce?: (previous: T, next: T) => T | undefined;
+  /** Maximum queued groups processed by one scheduled or synchronous slice. */
+  maxItemsPerSlice?: number;
+  scheduler?: EventBatcherScheduler;
 }
 
 /**
- * Coalesce batchable items onto a single scheduled callback, while applying
- * non-batchable items immediately.
- *
- * A non-batchable item first drains any pending batchable items (in arrival
- * order) so overall ordering is preserved — a lifecycle event never overtakes
- * the deltas that arrived before it.
- *
- * The returned handle is itself callable (enqueue) and also exposes `flush()`
- * to synchronously drain pending batchable items. Callers that replace state
- * authoritatively (e.g. applying a server snapshot) must `flush()` first so
- * stale queued deltas are not applied on top of the new state.
+ * Queue batchable items until the next frame (or task fallback), while keeping
+ * control events in arrival order. A control event triggers one bounded slice:
+ * short/coalesced queues still settle immediately, while a large queue resumes
+ * on later frames instead of becoming one long main-thread task.
  */
 export interface EventBatcher<T> {
   (item: T): void;
-  /** Synchronously drain any pending batchable items in arrival order. */
+  /** Synchronously drain every pending item. Reserved for authoritative state replacement. */
   flush(): void;
+  /** Drop queued items that no longer have a valid owner. */
+  discard(predicate: (item: T) => boolean): void;
+  /** Cancel scheduled work and permanently discard this batcher's queue. */
+  dispose(): void;
 }
 
 export function createEventBatcher<T>(
   process: (item: T) => void,
   isBatchable: (item: T) => boolean,
-  schedule: (cb: () => void) => number = defaultScheduleFrame,
+  options: EventBatcherOptions<T> = {},
 ): EventBatcher<T> {
-  let pending: T[] = [];
-  let handle: number | null = null;
+  const scheduler = options.scheduler ?? defaultScheduler;
+  const maxItemsPerSlice = Math.max(
+    1,
+    Math.floor(options.maxItemsPerSlice ?? DEFAULT_MAX_ITEMS_PER_SLICE),
+  );
+  const pending: T[] = [];
+  let head = 0;
+  let frameHandle: number | null = null;
+  let taskHandle: number | null = null;
+  let scheduleVersion = 0;
+  let disposed = false;
 
-  const drain = (): void => {
-    handle = null;
-    if (pending.length === 0) return;
-    const batch = pending;
-    pending = [];
-    for (const item of batch) process(item);
+  const countPending = (): number => pending.length - head;
+
+  const cancelScheduled = (): void => {
+    scheduleVersion += 1;
+    if (frameHandle !== null) {
+      scheduler.cancelFrame(frameHandle);
+      frameHandle = null;
+    }
+    if (taskHandle !== null) {
+      scheduler.cancelTask(taskHandle);
+      taskHandle = null;
+    }
+  };
+
+  const compactQueue = (): void => {
+    if (head === pending.length) {
+      pending.length = 0;
+      head = 0;
+    } else if (head >= 1024) {
+      pending.splice(0, head);
+      head = 0;
+    }
+  };
+
+  let drainSlice: () => void;
+
+  const scheduleDrain = (): void => {
+    if (
+      disposed ||
+      frameHandle !== null ||
+      taskHandle !== null ||
+      countPending() === 0
+    ) {
+      return;
+    }
+    const version = ++scheduleVersion;
+    const run = (): void => {
+      if (version !== scheduleVersion) return;
+      drainSlice();
+    };
+    frameHandle = scheduler.requestFrame(run);
+    taskHandle = scheduler.requestTask(run);
+  };
+
+  drainSlice = (): void => {
+    cancelScheduled();
+    let processed = 0;
+    while (!disposed && processed < maxItemsPerSlice && head < pending.length) {
+      const item = pending[head++]!;
+      process(item);
+      processed += 1;
+    }
+    compactQueue();
+    scheduleDrain();
   };
 
   const enqueue = ((item: T) => {
+    if (disposed) return;
     if (isBatchable(item)) {
-      pending.push(item);
-      if (handle === null) handle = schedule(drain);
+      const previous = pending.length > head ? pending.at(-1) : undefined;
+      const merged = previous === undefined ? undefined : options.coalesce?.(previous, item);
+      if (merged === undefined) pending.push(item);
+      else pending[pending.length - 1] = merged;
+      scheduleDrain();
       return;
     }
-    // Immediate item: flush pending batchables first to preserve order.
-    drain();
-    process(item);
+
+    if (countPending() === 0) {
+      process(item);
+      return;
+    }
+
+    // Keep the control event behind everything that arrived before it. Process
+    // one bounded slice now so a short/coalesced stream still completes without
+    // waiting for another frame; schedule the remainder when the budget is hit.
+    pending.push(item);
+    drainSlice();
   }) as EventBatcher<T>;
 
-  enqueue.flush = drain;
+  enqueue.flush = (): void => {
+    if (disposed) return;
+    cancelScheduled();
+    while (!disposed && head < pending.length) process(pending[head++]!);
+    compactQueue();
+  };
+  enqueue.discard = (predicate): void => {
+    if (disposed || countPending() === 0) return;
+    let write = head;
+    for (let read = head; read < pending.length; read += 1) {
+      const item = pending[read]!;
+      if (!predicate(item)) pending[write++] = item;
+    }
+    pending.length = write;
+    compactQueue();
+    if (countPending() === 0) cancelScheduled();
+    else scheduleDrain();
+  };
+  enqueue.dispose = (): void => {
+    if (disposed) return;
+    disposed = true;
+    cancelScheduled();
+    pending.length = 0;
+    head = 0;
+  };
 
   return enqueue;
 }
+
+export interface PendingAppEvent {
+  appEvent: AppEvent;
+  meta: KimiEventMeta;
+}
+
+interface AssistantChunk {
+  kind: 'text' | 'thinking';
+  value: string;
+}
+
+function assistantChunk(event: AppEvent): AssistantChunk | undefined {
+  if (event.type !== 'assistantDelta') return undefined;
+  if (event.delta.text !== undefined && event.delta.thinking === undefined) {
+    return { kind: 'text', value: event.delta.text };
+  }
+  if (event.delta.thinking !== undefined && event.delta.text === undefined) {
+    return { kind: 'thinking', value: event.delta.thinking };
+  }
+  return undefined;
+}
+
+/**
+ * A single server frame can already contain a large coalesced delta. Split it
+ * before enqueueing so the per-group cap also holds for that case. Every part
+ * keeps the wire seq and advances only the raw stream offset.
+ */
+export function splitOversizedAppRenderEvent(
+  item: PendingAppEvent,
+): readonly PendingAppEvent[] {
+  if (item.appEvent.type !== 'assistantDelta') return [item];
+  const appEvent = item.appEvent;
+  const stream = item.meta.stream;
+  const chunk = assistantChunk(appEvent);
+  if (
+    stream === undefined ||
+    chunk === undefined ||
+    stream.kind !== chunk.kind ||
+    chunk.value.length <= MAX_COALESCED_STREAM_CHARS
+  ) {
+    return [item];
+  }
+
+  const parts: PendingAppEvent[] = [];
+  let start = 0;
+  while (start < chunk.value.length) {
+    let end = Math.min(start + MAX_COALESCED_STREAM_CHARS, chunk.value.length);
+    // Do not expose an unpaired surrogate in an intermediate render. Moving
+    // the boundary back by one still preserves offset continuity because raw
+    // offsets are counted in UTF-16 code units.
+    if (
+      end < chunk.value.length &&
+      end > start &&
+      /[\uD800-\uDBFF]/u.test(chunk.value[end - 1]!) &&
+      /[\uDC00-\uDFFF]/u.test(chunk.value[end]!)
+    ) {
+      end -= 1;
+    }
+    const value = chunk.value.slice(start, end);
+    parts.push({
+      appEvent: {
+        ...appEvent,
+        delta: chunk.kind === 'text' ? { text: value } : { thinking: value },
+      },
+      meta: {
+        ...item.meta,
+        stream: { ...stream, offset: stream.offset + start },
+      },
+    });
+    start = end;
+  }
+  return parts;
+}
+
+/**
+ * Merge adjacent main-assistant text/thinking deltas only when their complete
+ * stream identity and offsets prove that concatenation is lossless.
+ *
+ * Protocol/stub events without raw stream metadata deliberately stay separate.
+ * Control events and other render-event types are never merged.
+ */
+export function coalesceAppRenderEvents(
+  previous: PendingAppEvent,
+  next: PendingAppEvent,
+): PendingAppEvent | undefined {
+  if (previous.appEvent.type !== 'assistantDelta' || next.appEvent.type !== 'assistantDelta') {
+    return undefined;
+  }
+  const previousStream = previous.meta.stream;
+  const nextStream = next.meta.stream;
+  const previousChunk = assistantChunk(previous.appEvent);
+  const nextChunk = assistantChunk(next.appEvent);
+  if (
+    previousStream === undefined ||
+    nextStream === undefined ||
+    previousChunk === undefined ||
+    nextChunk === undefined ||
+    previous.meta.sessionId !== next.meta.sessionId ||
+    previous.appEvent.sessionId !== next.appEvent.sessionId ||
+    previous.appEvent.messageId !== next.appEvent.messageId ||
+    previous.appEvent.contentIndex !== next.appEvent.contentIndex ||
+    previousStream.turnId !== nextStream.turnId ||
+    previousStream.kind !== nextStream.kind ||
+    previousChunk.kind !== nextChunk.kind ||
+    previousStream.kind !== previousChunk.kind ||
+    nextStream.kind !== nextChunk.kind ||
+    nextStream.offset !== previousStream.offset + previousChunk.value.length ||
+    previousChunk.value.length + nextChunk.value.length > MAX_COALESCED_STREAM_CHARS
+  ) {
+    return undefined;
+  }
+
+  const value = previousChunk.value + nextChunk.value;
+  return {
+    appEvent: {
+      ...previous.appEvent,
+      delta: previousChunk.kind === 'text' ? { text: value } : { thinking: value },
+    },
+    // Advance the durable watermark with the newest frame while preserving the
+    // first offset of the merged chunk for the next continuity check.
+    meta: {
+      ...next.meta,
+      stream: { ...previousStream },
+    },
+  };
+}
diff --git a/apps/kimi-web/src/composables/client/useModelProviderState.ts b/apps/kimi-web/src/composables/client/useModelProviderState.ts
index 5a0592182..4c56916c3 100644
--- a/apps/kimi-web/src/composables/client/useModelProviderState.ts
+++ b/apps/kimi-web/src/composables/client/useModelProviderState.ts
@@ -69,7 +69,6 @@ export interface UseModelProviderStateDeps {
   refreshSessionStatus: (sessionId: string) => Promise<void>;
   persistSessionProfile: (patch: PersistSessionProfilePatch, sessionId?: string) => Promise<void>;
   activity: ComputedRef<ActivityState>;
-  inFlightPromptSessions: Set<string>;
   saveThinkingToStorage: (v: ThinkingLevel) => void;
   /** Replace one session in place (matched by id). Owned by the facade so the
    *  model module never assigns rawState.sessions directly. */
@@ -90,7 +89,6 @@ export function useModelProviderState(
     refreshSessionStatus,
     persistSessionProfile,
     activity,
-    inFlightPromptSessions,
     saveThinkingToStorage,
     updateSession,
     updateSessionMessages,
@@ -194,19 +192,6 @@ export function useModelProviderState(
     }
   }
 
-  async function refreshOAuthProviderModels(): Promise<void> {
-    try {
-      const result = await getKimiWebApi().refreshOAuthProviderModels();
-      for (const failure of result.failed) {
-        pushOperationFailure('refreshOAuthProviderModels', new Error(failure.reason), {
-          message: failure.provider,
-        });
-      }
-    } catch {
-      // Older daemons may not expose this endpoint; model listing still works.
-    }
-  }
-
   /** Load providers */
   async function loadProviders(): Promise<void> {
     try {
@@ -306,15 +291,14 @@ export function useModelProviderState(
   async function activateSkill(skillName: string, args?: string, sessionId?: string): Promise<void> {
     const sid = sessionId ?? rawState.activeSessionId;
     if (!sid) return;
-    const guarded = activity.value === 'idle' && !inFlightPromptSessions.has(sid);
+    const guarded = activity.value === 'idle' && !rawState.inFlightBySession[sid];
     const tempId = `msg_skill_opt_${Date.now().toString(36)}`;
 
     const localTurnToken = guarded ? beginLocalTurn(sid) : undefined;
     if (guarded) {
       // Share the local-turn-start lifecycle with prompt submits: a racing
       // terminal snapshot must not clear this skill's turn either.
-      inFlightPromptSessions.add(sid);
-      rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: true };
+      rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: true };
       const optimisticMsg: AppMessage = {
         id: tempId,
         sessionId: sid,
@@ -338,8 +322,7 @@ export function useModelProviderState(
       await getKimiWebApi().activateSkill(sid, skillName, args);
     } catch (err) {
       if (guarded) {
-        inFlightPromptSessions.delete(sid);
-        rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: false };
+        rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: false };
         updateSessionMessages(sid, (msgs) => msgs.filter((m) => m.id !== tempId));
       }
       pushOperationFailure('activateSkill', err, { sessionId: sid });
@@ -426,7 +409,10 @@ export function useModelProviderState(
     try {
       const api = getKimiWebApi();
       return await api.pollOAuthLogin();
-    } catch {
+    } catch (err) {
+      // The dialog counts consecutive nulls and gives up after a few; keep the
+      // cause in the log so a dead daemon is diagnosable.
+      console.warn('[kimi-web] pollOAuthLogin failed', err);
       return null;
     }
   }
@@ -461,7 +447,6 @@ export function useModelProviderState(
     loadSkillsForSession,
     loadSkillsForWorkspace,
     loadModels,
-    refreshOAuthProviderModels,
     loadProviders,
     setModel,
     toggleStarModel,
diff --git a/apps/kimi-web/src/composables/client/useTaskPoller.ts b/apps/kimi-web/src/composables/client/useTaskPoller.ts
index 2141d93da..f4c9dfa97 100644
--- a/apps/kimi-web/src/composables/client/useTaskPoller.ts
+++ b/apps/kimi-web/src/composables/client/useTaskPoller.ts
@@ -78,10 +78,11 @@ export function useTaskPoller(
               bytes: withOutput.outputBytes,
             });
           }
+          // Only a definitive response marks the task as fetched — a transient
+          // failure must leave it eligible for a later backfill.
+          fetchedTerminalTaskOutputIds.add(task.id);
         } catch {
           // Task may have finished between listTasks and getTask; ignore.
-        } finally {
-          fetchedTerminalTaskOutputIds.add(task.id);
         }
       }),
     );
@@ -92,7 +93,15 @@ export function useTaskPoller(
     rawState.tasksBySession = {
       ...rawState.tasksBySession,
       [sessionId]: existing.map((t) => {
-        const polled = outputByTaskId.get(t.id);
+        // Output was fetched by REST task id; a background subagent row folded
+        // into its WS agent-id row (keepLiveSubagents) is matched via
+        // backgroundTaskId, otherwise its final output would be dropped here
+        // and never refetched (the REST id is already marked as fetched).
+        const polled =
+          outputByTaskId.get(t.id) ??
+          (t.backgroundTaskId !== undefined
+            ? outputByTaskId.get(t.backgroundTaskId)
+            : undefined);
         if (!polled) return t;
         return { ...t, outputPreview: polled.preview, outputBytes: polled.bytes };
       }),
@@ -145,12 +154,13 @@ export function useTaskPoller(
               bytes: withOutput.outputBytes,
             });
           }
-        } catch {
-          // Task may have finished between listTasks and getTask; ignore.
-        } finally {
+          // Mark as fetched only on a definitive response; a transient failure
+          // stays eligible for the next poll.
           if (isTerminal) {
             fetchedTerminalTaskOutputIds.add(task.id);
           }
+        } catch {
+          // Task may have finished between listTasks and getTask; ignore.
         }
       }),
     );
diff --git a/apps/kimi-web/src/composables/client/useWorkspaceState.ts b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
index cc7fde10a..8c0c13db5 100644
--- a/apps/kimi-web/src/composables/client/useWorkspaceState.ts
+++ b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
@@ -19,7 +19,6 @@ import type {
   AppInFlightTurn,
   AppMessage,
   AppSession,
-  AppSessionStatus,
   AppWorkspace,
   ApprovalDecision,
   ApprovalResponse,
@@ -83,7 +82,7 @@ function isTaskAlreadyFinishedError(err: unknown): boolean {
  * action kind. Drives the card's loading state and guards against a duplicate
  * submit while the first request is still in flight (the server would reject
  * the second resolve with 40902). Module-level singleton — matches
- * `inFlightPromptSessions` in the facade.
+ * `inFlightBySession` on rawState.
  */
 const pendingQuestionActions = reactive<Record<string, 'answer' | 'dismiss'>>({});
 /** Approval ids with an in-flight respond, keyed by approvalId. */
@@ -94,8 +93,8 @@ const pendingTaskCancellations = reactive<Record<string, true>>({});
  * Workspace ids whose empty-session first prompt is currently being created +
  * submitted. The empty-composer path (`startSessionAndSendPrompt`) awaits
  * `createDraftSession` (addWorkspace + createSession + selectSession) before
- * the session id exists, so the per-session `inFlightPromptSessions` guard
- * cannot cover that window — a second Enter / send-button click during it
+ * the session id exists, so the per-session prompt-in-flight guard cannot
+ * cover that window — a second Enter / send-button click during it
  * would otherwise fire a second concurrent POST and trip the daemon's
  * `turn.agent_busy` race. Module-level singleton — matches the other
  * `pending*Actions` guards above.
@@ -111,7 +110,7 @@ const startingFirstPromptWorkspaces = reactive(new Set<string>());
  *  - pending: set while the start request (POST /prompts or skill
  *    activation) has not been acknowledged by the daemon — a snapshot
  *    requested in that window cannot reflect the turn server-side either.
- * Module-level singleton — matches `inFlightPromptSessions` in the facade.
+ * Module-level singleton — matches `inFlightBySession` on rawState.
  */
 const promptGenerationBySession = new Map<string, number>();
 const pendingLocalTurnStarts = new Map<string, Set<number>>();
@@ -200,7 +199,6 @@ export interface UseWorkspaceStateDeps {
     opts?: { title?: string; message?: string; sessionId?: string },
   ) => void;
   activity: ComputedRef<ActivityState>;
-  inFlightPromptSessions: Set<string>;
   sessionsKnownEmpty: Set<string>;
   // rawState.sessions mutation funnel, owned by the facade. This module never
   // assigns rawState.sessions directly — it goes through these.
@@ -258,7 +256,6 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     modelProvider,
     pushOperationFailure,
     activity,
-    inFlightPromptSessions,
     sessionsKnownEmpty,
     setSessions,
     updateSession,
@@ -490,22 +487,34 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
 
   /** Drain every page of sessions, newest first. A single global walk (instead of
    *  per-workspace) so sessions whose cwd is not a registered workspace root are
-   *  still reachable after a refresh. */
-  async function listAllSessionsGlobal(): Promise<AppSession[]> {
+   *  still reachable after a refresh. A later-page failure returns the pages
+   *  already fetched plus the error; only a first-page failure rejects. */
+  async function listAllSessionsGlobal(): Promise<{
+    sessions: AppSession[];
+    error?: unknown;
+  }> {
     const api = getKimiWebApi();
     const items: AppSession[] = [];
     let beforeId: string | undefined;
+    let continuationError: unknown;
     for (;;) {
-      const page = await api.listSessions({
-        pageSize: SESSION_PAGE_SIZE,
-        beforeId,
-        excludeEmpty: true,
-      });
+      let page: { items: AppSession[]; hasMore: boolean };
+      try {
+        page = await api.listSessions({
+          pageSize: SESSION_PAGE_SIZE,
+          beforeId,
+          excludeEmpty: true,
+        });
+      } catch (error) {
+        if (items.length === 0) throw error;
+        continuationError = error;
+        break;
+      }
       items.push(...page.items);
       if (!page.hasMore || page.items.length === 0) break;
       beforeId = page.items[page.items.length - 1]!.id;
     }
-    return items;
+    return { sessions: items, error: continuationError };
   }
 
   /**
@@ -528,6 +537,20 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     );
   }
 
+  /** Keep fresh rows authoritative while retaining cached rows a partial list
+   *  request never reached. */
+  function mergePartialSessionsWithCached(sessions: AppSession[]): AppSession[] {
+    const merged = [...sessions];
+    const loadedIds = new Set(merged.map((session) => session.id));
+    for (const session of rawState.sessions) {
+      if (loadedIds.has(session.id)) continue;
+      merged.push(session);
+      loadedIds.add(session.id);
+    }
+    merged.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    return merged;
+  }
+
   /** Load the initial page of sessions for one workspace, then keep fetching
    *  older pages while the oldest loaded session is still within
    *  SESSIONS_RECENT_WINDOW_MS. Every page (including continuations) uses the
@@ -536,7 +559,11 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
    *  keeping only up to the first session that falls outside the window. */
   async function loadInitialSessionsForWorkspace(
     workspaceId: string,
-  ): Promise<{ workspaceId: string; page: { items: AppSession[]; hasMore: boolean } }> {
+  ): Promise<{
+    workspaceId: string;
+    page: { items: AppSession[]; hasMore: boolean };
+    error?: unknown;
+  }> {
     const api = getKimiWebApi();
     const items: AppSession[] = [];
     const now = Date.now();
@@ -544,6 +571,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     let beforeId: string | undefined;
     let hasMore = false;
     let isFirstPage = true;
+    let continuationError: unknown;
     for (;;) {
       let page: { items: AppSession[]; hasMore: boolean };
       try {
@@ -555,9 +583,10 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
         });
       } catch (error) {
         // A failed continuation page must not discard sessions already loaded
-        // from earlier pages; only a page-1 failure propagates (the caller then
-        // falls back to an empty page for that workspace).
+        // from earlier pages; only a page-1 failure rejects the workspace load.
         if (isFirstPage) throw error;
+        continuationError = error;
+        hasMore = true;
         break;
       }
       hasMore = page.hasMore;
@@ -584,39 +613,97 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
       if (!page.hasMore || oldestBeyondWindow) break;
       beforeId = oldest.id;
     }
-    return { workspaceId, page: { items, hasMore } };
+    return { workspaceId, page: { items, hasMore }, error: continuationError };
   }
 
   /** Fetch the first page of sessions for every known workspace concurrently.
-   *  Returns the merged, recency-sorted list and seeds per-workspace hasMore. */
-  async function loadInitialSessionsByWorkspace(): Promise<AppSession[]> {
+   *  Returns the merged, recency-sorted list and seeds per-workspace hasMore.
+   *  When every workspace request fails, returns undefined so the caller keeps
+   *  the previously loaded sessions instead of committing a false empty list. */
+  async function loadInitialSessionsByWorkspace(): Promise<AppSession[] | undefined> {
     const workspaces = rawState.workspaces;
     if (workspaces.length === 0) {
       // /workspaces may be unavailable or empty on older / partially-failing
       // daemons while /sessions still works. Fall back to the legacy global
       // walk so history still shows and mergedWorkspaces can derive workspaces
       // from session cwds, instead of rendering a blank sidebar.
-      const fallback = await listAllSessionsGlobal().catch(() => [] as AppSession[]);
+      const fallback = await listAllSessionsGlobal();
+      const sessions =
+        fallback.error === undefined
+          ? fallback.sessions
+          : mergePartialSessionsWithCached(fallback.sessions);
       rawState.sessionsHasMoreByWorkspace = {};
       rawState.sessionsCursorByWorkspace = {};
       rawState.sessionsInitialCountByWorkspace = {};
-      rawState.sessionsFullyLoaded = true;
-      return fallback;
+      rawState.sessionsFullyLoaded = fallback.error === undefined;
+      if (fallback.error !== undefined) pushOperationFailure('load', fallback.error);
+      return sessions;
     }
-    const pages = await Promise.all(
-      workspaces.map((w) =>
-        loadInitialSessionsForWorkspace(w.id).catch(() => ({
-          workspaceId: w.id,
-          page: { items: [] as AppSession[], hasMore: false },
-        })),
-      ),
+    const results = await Promise.allSettled(
+      workspaces.map((w) => loadInitialSessionsForWorkspace(w.id)),
     );
     const loaded: AppSession[] = [];
+    const loadedIds = new Set<string>();
+    const successfulPages = new Map<string, { items: AppSession[]; hasMore: boolean }>();
+    const failedWorkspaceIds = new Set<string>();
+    let firstError: unknown;
+    for (let index = 0; index < results.length; index++) {
+      const result = results[index]!;
+      if (result.status === 'fulfilled') {
+        successfulPages.set(result.value.workspaceId, result.value.page);
+        if (result.value.error !== undefined) {
+          if (failedWorkspaceIds.size === 0) firstError = result.value.error;
+          failedWorkspaceIds.add(result.value.workspaceId);
+        }
+        for (const session of result.value.page.items) {
+          if (loadedIds.has(session.id)) continue;
+          loaded.push(session);
+          loadedIds.add(session.id);
+        }
+        continue;
+      }
+      if (failedWorkspaceIds.size === 0) firstError = result.reason;
+      failedWorkspaceIds.add(workspaces[index]!.id);
+    }
+
+    // One failed workspace must not erase another workspace's successful page,
+    // nor the failed workspace's last usable rows. If every request failed,
+    // leave both sessions and pagination state untouched for a natural retry.
+    if (successfulPages.size === 0) {
+      pushOperationFailure('load', firstError);
+      return undefined;
+    }
+    const failedWorkspaceRoots = new Set(
+      workspaces
+        .filter((workspace) => failedWorkspaceIds.has(workspace.id))
+        .map((workspace) => workspace.root),
+    );
+    const registeredWorkspaceIds = new Set(workspaces.map((workspace) => workspace.id));
+    for (const session of rawState.sessions) {
+      const belongsToFailedWorkspace =
+        session.workspaceId !== undefined && registeredWorkspaceIds.has(session.workspaceId)
+          ? failedWorkspaceIds.has(session.workspaceId)
+          : failedWorkspaceRoots.has(session.cwd) ||
+            failedWorkspaceIds.has(workspaceIdForSession(session));
+      if (!belongsToFailedWorkspace || loadedIds.has(session.id)) continue;
+      loaded.push(session);
+      loadedIds.add(session.id);
+    }
+
     const hasMore: Record<string, boolean> = {};
     const cursors: Record<string, string | undefined> = {};
     const counts: Record<string, number> = {};
-    for (const { workspaceId, page } of pages) {
-      loaded.push(...page.items);
+    for (const { id: workspaceId } of workspaces) {
+      const page = successfulPages.get(workspaceId);
+      if (page === undefined) {
+        const previousHasMore = rawState.sessionsHasMoreByWorkspace[workspaceId];
+        const previousCursor = rawState.sessionsCursorByWorkspace[workspaceId];
+        const previousCount = rawState.sessionsInitialCountByWorkspace[workspaceId];
+        if (previousHasMore !== undefined) hasMore[workspaceId] = previousHasMore;
+        if (previousCursor !== undefined) cursors[workspaceId] = previousCursor;
+        if (previousCount !== undefined) counts[workspaceId] = previousCount;
+        continue;
+      }
       // Trust the server's hasMore — the per-workspace session_count is only a
       // (possibly stale) label total, not an authority on whether more pages exist.
       hasMore[workspaceId] = page.hasMore;
@@ -640,6 +727,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     // Keep rawState.sessions newest-first for readers that pick sessions[0]
     // (e.g. auto-selecting the most recent session on first load).
     loaded.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    if (failedWorkspaceIds.size > 0) pushOperationFailure('load', firstError);
     return loaded;
   }
 
@@ -693,10 +781,18 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
    *  first search; a no-op once the full list is loaded. */
   async function loadAllSessions(): Promise<void> {
     if (rawState.sessionsFullyLoaded) return;
-    const sessions = await listAllSessionsGlobal().catch(() => null);
-    if (sessions === null) return;
+    const result = await listAllSessionsGlobal().catch((err) => {
+      console.warn('[kimi-web] loadAllSessions failed; search covers only loaded sessions', err);
+      return null;
+    });
+    if (result === null) return;
+    const sessions =
+      result.error === undefined
+        ? result.sessions
+        : mergePartialSessionsWithCached(result.sessions);
     setSessionsPreservingLiveUsage(sessions);
-    rawState.sessionsFullyLoaded = true;
+    rawState.sessionsFullyLoaded = result.error === undefined;
+    if (result.error !== undefined) return;
     const cleared: Record<string, boolean> = {};
     for (const w of rawState.workspaces) cleared[w.id] = false;
     rawState.sessionsHasMoreByWorkspace = cleared;
@@ -755,8 +851,9 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
       // the old full global walk: the sidebar now truncates by loading, not by
       // hiding already-fetched rows.
       await loadWorkspaces();
-      const sessions = await loadInitialSessionsByWorkspace();
-      setSessionsPreservingLiveUsage(sessions);
+      const loadedSessions = await loadInitialSessionsByWorkspace();
+      const sessions = loadedSessions ?? rawState.sessions;
+      if (loadedSessions !== undefined) setSessionsPreservingLiveUsage(loadedSessions);
 
       // First load: pick the workspace of the most-recent session, unless the
       // user already has a persisted active workspace that still exists.
@@ -1024,7 +1121,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
   ): Promise<void> {
     // Guard the whole "create draft session + submit first prompt" flow: the
     // session id doesn't exist until `createDraftSession` resolves, so the
-    // per-session `inFlightPromptSessions` guard can't cover this window. A
+    // per-session in-flight guard can't cover this window. A
     // second Enter / send-button click in that window would otherwise fire a
     // concurrent first POST for the same new session and trip the daemon's
     // `turn.agent_busy` race.
@@ -1140,7 +1237,9 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
       upsertWorkspacePreserveOrder(ws);
       openWorkspaceDraft(ws.id);
       return true;
-    } catch {
+    } catch (err) {
+      // The caller shows an inline error in the picker; keep the cause in the log.
+      console.warn('[kimi-web] addWorkspaceByPath failed for', trimmed, err);
       return false;
     }
   }
@@ -1309,13 +1408,12 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
       Returns true when the daemon accepted the prompt. */
   async function submitPromptInternal(sid: string, text: string, attachments?: PromptAttachment[]): Promise<boolean> {
     // Mark this session as having a prompt in flight BEFORE any await, so a racing
-    // sendPrompt sees it and enqueues. Cleared when activity returns to idle.
-    // beginLocalTurn also bumps the snapshot generation and marks the submit
-    // pending, so a racing terminal snapshot can't clear this prompt (see
-    // handleSessionSnapshot).
+    // sendPrompt sees it and enqueues. Cleared when the main turn ends (or the
+    // prompt dies without one). beginLocalTurn also bumps the snapshot generation
+    // and marks the submit pending, so a racing terminal snapshot can't clear
+    // this prompt (see handleSessionSnapshot).
     const localTurnToken = beginLocalTurn(sid);
-    inFlightPromptSessions.add(sid);
-    rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: true };
+    rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: true };
     const tempId = nextOptimisticMsgId();
     try {
       const api = getKimiWebApi();
@@ -1323,11 +1421,18 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
       if (text) content.push({ type: 'text', text });
       for (const att of attachments ?? []) {
         if (att.kind === 'video') content.push({ type: 'video', source: { kind: 'file', fileId: att.fileId } });
-        else content.push({ type: 'image', source: { kind: 'file', fileId: att.fileId } });
+        else if (att.kind === 'file') {
+          content.push({
+            type: 'file',
+            fileId: att.fileId,
+            name: att.name ?? '',
+            mediaType: att.mediaType || 'application/octet-stream',
+            size: att.size ?? 0,
+          });
+        } else content.push({ type: 'image', source: { kind: 'file', fileId: att.fileId } });
       }
       if (content.length === 0) {
-        inFlightPromptSessions.delete(sid);
-        rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: false };
+        rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: false };
         return false;
       }
 
@@ -1365,8 +1470,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
           await api.updateSession(sid, { goalObjective: text.trim() });
         } catch (err) {
           pushOperationFailure('createGoal', err, { sessionId: sid });
-          inFlightPromptSessions.delete(sid);
-          rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: false };
+          rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: false };
           updateSessionMessages(sid, (msgs) =>
             msgs.some((m) => m.id === tempId) ? msgs.filter((m) => m.id !== tempId) : msgs,
           );
@@ -1425,8 +1529,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
       // queued forever (turn.ended will never arrive), and roll back the
       // optimistic user message so the transcript doesn't show a delivered-
       // looking message the daemon never received.
-      inFlightPromptSessions.delete(sid);
-      rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: false };
+      rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: false };
       updateSessionMessages(sid, (msgs) =>
         msgs.some((m) => m.id === tempId) ? msgs.filter((m) => m.id !== tempId) : msgs,
       );
@@ -1444,10 +1547,10 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     if (!sid) return;
 
     // If the session is not idle OR a prompt is already in flight (submitted but
-    // the WS turn.started hasn't flipped activity to 'running' yet), enqueue
-    // instead of submitting directly. Gating on inFlightPromptSessions closes the
-    // window where two rapid prompts would both submit and race.
-    if (activity.value !== 'idle' || inFlightPromptSessions.has(sid)) {
+    // the WS turn.started hasn't arrived yet), enqueue instead of submitting
+    // directly. The in-flight flag closes the window where two rapid prompts
+    // would both submit and race.
+    if (activity.value !== 'idle' || rawState.inFlightBySession[sid]) {
       enqueue(text, attachments);
       return;
     }
@@ -1485,7 +1588,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     const merged = parts.join('\n\n');
 
     // Idle and nothing in flight — there is no turn to steer into; normal send.
-    if (activity.value === 'idle' && !inFlightPromptSessions.has(sid)) {
+    if (activity.value === 'idle' && !rawState.inFlightBySession[sid]) {
       await submitPromptInternal(sid, merged, mergedAttachments);
       return;
     }
@@ -1495,7 +1598,15 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     if (merged) content.push({ type: 'text', text: merged });
     for (const att of mergedAttachments) {
       if (att.kind === 'video') content.push({ type: 'video', source: { kind: 'file', fileId: att.fileId } });
-      else content.push({ type: 'image', source: { kind: 'file', fileId: att.fileId } });
+      else if (att.kind === 'file') {
+        content.push({
+          type: 'file',
+          fileId: att.fileId,
+          name: att.name ?? '',
+          mediaType: att.mediaType || 'application/octet-stream',
+          size: att.size ?? 0,
+        });
+      } else content.push({ type: 'image', source: { kind: 'file', fileId: att.fileId } });
     }
     const tempId = nextOptimisticMsgId();
     const optimisticMsg: AppMessage = {
@@ -1589,12 +1700,12 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
   }
 
   /**
-   * Shared prompt-finish cleanup, used by BOTH the WS idle/aborted event path
-   * (facade `onSessionIdle`) and the authoritative-snapshot path
+   * Shared prompt-finish cleanup, used by BOTH the main-turn-ended path
+   * (facade `onMainTurnEnd`) and the authoritative-snapshot path
    * (handleSessionSnapshot below). Returns whether this call actually flipped
    * an in-flight prompt to finished.
    *
-   * Clears the local in-flight/sending/prompt-id state and drains exactly ONE
+   * Clears the local in-flight/prompt-id state and drains exactly ONE
    * queued message — the resubmitted prompt re-arms the in-flight flag, and
    * its own finish drains the following one. Repeat calls (e.g. a late
    * duplicate idle event) therefore cannot drain more than one message per
@@ -1602,8 +1713,8 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
    * unread) on top; the snapshot path deliberately adds none.
    */
   function finishPromptLocal(sid: string): boolean {
-    const wasInFlight = inFlightPromptSessions.delete(sid);
-    rawState.sendingBySession = { ...rawState.sendingBySession, [sid]: false };
+    const wasInFlight = rawState.inFlightBySession[sid] === true;
+    rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: false };
     // Drop any cached prompt_id so a later skill activation (which has no
     // prompt_id) doesn't accidentally reuse this stale id for :abort.
     if (rawState.promptIdBySession[sid] !== undefined) {
@@ -1649,10 +1760,13 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
    */
   function handleSessionSnapshot(
     sid: string,
-    snapshot: { inFlightTurn: AppInFlightTurn | null; status: AppSessionStatus },
+    snapshot: { inFlightTurn: AppInFlightTurn | null; busy: boolean },
   ): void {
-    if (snapshot.inFlightTurn !== null) return;
-    if (snapshot.status !== 'idle' && snapshot.status !== 'aborted') return;
+    // inFlightTurn tracks only the main agent, while busy aggregates all
+    // agents and background work. Keep the local prompt alive only when both
+    // facts still support a running main turn. Either terminal fact may also
+    // reconcile the other tracker when a snapshot catches it stale.
+    if (snapshot.inFlightTurn !== null && snapshot.busy) return;
     finishPromptLocal(sid);
   }
 
@@ -1812,7 +1926,11 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     pendingTaskCancellations[taskId] = true;
     try {
       const api = getKimiWebApi();
-      await api.cancelTask(sid, taskId);
+      // A background subagent row is keyed by agent id, but REST `/tasks` only
+      // knows its background-task id.
+      const restTaskId = (rawState.tasksBySession[sid] ?? []).find((t) => t.id === taskId)
+        ?.backgroundTaskId;
+      await api.cancelTask(sid, restTaskId ?? taskId);
       // Update task status locally
       const list = rawState.tasksBySession[sid] ?? [];
       rawState.tasksBySession = {
@@ -2079,8 +2197,9 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     // Best-effort registry cleanup; ignore failures (the hide already took effect).
     try {
       await getKimiWebApi().deleteWorkspace(id);
-    } catch {
+    } catch (err) {
       // registry delete is optional — the sidebar hide is what the user sees.
+      console.warn('[kimi-web] deleteWorkspace registry cleanup failed for', id, err);
     }
     rawState.workspaces = rawState.workspaces.filter((w) => w.id !== id && w.root !== root);
     if (removingActiveWorkspace || activeSessionInRemovedWorkspace) {
@@ -2374,7 +2493,8 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
         size: result.size,
         lineCount: result.lineCount,
       };
-    } catch {
+    } catch (err) {
+      console.warn('[kimi-web] readFileContent failed for', path, err);
       return null;
     }
   }
diff --git a/apps/kimi-web/src/composables/messagesToTurns.ts b/apps/kimi-web/src/composables/messagesToTurns.ts
index a08e584b1..aaa2a67a9 100644
--- a/apps/kimi-web/src/composables/messagesToTurns.ts
+++ b/apps/kimi-web/src/composables/messagesToTurns.ts
@@ -11,7 +11,7 @@
 
 import type { AppMessage, AppApprovalRequest, AppTask, CompactionMarkerMetadata } from '../api/types';
 import { COMPACTION_MARKER_METADATA_KEY } from '../api/types';
-import type { AgentMember, ApprovalBlock, ChatTurn, CronTurnData, DiffLine, ToolCall, ToolMedia, TurnBlock } from '../types';
+import type { AgentMember, ApprovalBlock, ChatTurn, CronTurnData, DiffLine, ToolCall, ToolMedia, TurnAttachment, TurnBlock } from '../types';
 
 const READ_MEDIA_TOOL_RE = /^read[_-]?media(?:file)?$/i;
 const DATA_URL_RE = /^data:([^;]+);base64,(.*)$/s;
@@ -66,8 +66,17 @@ function mediaPathTag(text: string): { kind: 'image' | 'video' | 'audio'; path:
  *  recover the fileId from the cache filename to build a playable URL. Returns
  *  undefined when the basename isn't shaped like a file-store id (`f_…`) — e.g.
  *  TUI cache names (`<uuid>-<label>`) or legacy `/tmp/foo.mp4` paths — so the
- *  caller leaves the raw tag as text instead of fabricating a broken /files url. */
-const FILE_STORE_ID_RE = /^f_[A-Za-z0-9]{10,}$/;
+ *  caller leaves the raw tag as text instead of fabricating a broken /files url.
+ *
+ *  File-store ids come in two shapes: v1 `f_`<26-char ULID> (no hyphens) and
+ *  v2 `f_`<randomUUID> (32 hex chars + 4 hyphens). */
+const FILE_STORE_ID_RE =
+  /^f_(?:[0-9A-Za-z]{26}|[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})$/;
+/** Same two id shapes, anchored at the start of a `<fileId>-<name>` basename.
+    Splitting on the first '-' instead would truncate v2 UUID ids at their
+    first inner hyphen. */
+const FILE_STORE_ID_AT_START_RE =
+  /^f_(?:[0-9A-Za-z]{26}|[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})(?=-)/;
 function fileIdFromCachePath(p: string): string | undefined {
   const base = p.split(/[\\/]/).at(-1) ?? '';
   const dot = base.lastIndexOf('.');
@@ -75,6 +84,32 @@ function fileIdFromCachePath(p: string): string | undefined {
   return FILE_STORE_ID_RE.test(id) ? id : undefined;
 }
 
+/** A generic file attachment comes back from the server as a text notice (see
+ *  resolvePromptMediaFiles in the kap-server prompts route):
+ *    Attached file "<name>" (<mime>, <n> bytes): <dir>/<fileId>-<name> — open it with the Read tool
+ *  Recover the chip from the notice instead of dumping it — absolute server
+ *  path and all — into the bubble. The fileId is matched by shape at the start
+ *  of the basename (ULID or UUID, see FILE_STORE_ID_AT_START_RE). Inline-base64
+ *  attachments are content-hash named (no fileId): they still become a chip so
+ *  the notice stays hidden, just without bytes to open. */
+const ATTACHED_FILE_NOTICE_RE =
+  /^Attached file "(.+)" \(([^,]+), (\d+) bytes\): (.+) — open it with the Read tool$/;
+
+function attachedFileNotice(
+  text: string,
+): { name: string; mediaType: string; size: number; fileId?: string } | null {
+  const m = ATTACHED_FILE_NOTICE_RE.exec(text.trim());
+  if (!m) return null;
+  const base = (m[4] ?? '').split(/[\\/]/).at(-1) ?? '';
+  const id = FILE_STORE_ID_AT_START_RE.exec(base)?.[0];
+  return {
+    name: m[1]!,
+    mediaType: m[2]!,
+    size: Number(m[3]),
+    fileId: id !== undefined && FILE_STORE_ID_RE.test(id) ? id : undefined,
+  };
+}
+
 function bytesFromBase64(b64: string): number {
   if (b64.length === 0) return 0;
   const padding = b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0;
@@ -765,7 +800,7 @@ export function messagesToTurns(
         origin?.kind === 'plugin_command' && origin?.trigger === 'user-slash';
 
       const textParts: string[] = [];
-      const images: { url: string; alt?: string; kind: 'image' | 'video'; fileId?: string }[] = [];
+      const attachments: TurnAttachment[] = [];
       for (const c of msg.content) {
         if (c.type === 'text') {
           if (isSkillActivation) {
@@ -786,24 +821,60 @@ export function messagesToTurns(
             if (tag && (tag.kind === 'video' || tag.kind === 'image') && getFileUrl) {
               const fileId = fileIdFromCachePath(tag.path);
               if (fileId) {
-                images.push({ url: getFileUrl(fileId), kind: tag.kind, alt: fileId, fileId });
+                attachments.push({ url: getFileUrl(fileId), kind: tag.kind, fileId });
                 continue;
               }
             }
+            // A generic file upload comes back as an "Attached file …" notice;
+            // recover the chip the same way (see attachedFileNotice).
+            const attached = attachedFileNotice(c.text);
+            if (attached) {
+              attachments.push({
+                kind: 'file',
+                // No recoverable fileId (inline-base64 upload) → no URL: the
+                // chip renders name/size but stays non-clickable.
+                url: attached.fileId && getFileUrl ? getFileUrl(attached.fileId) : '',
+                fileId: attached.fileId,
+                name: attached.name,
+                mediaType: attached.mediaType,
+                size: attached.size,
+              });
+              continue;
+            }
             const stripped = stripImageCompressionCaptions(c.text);
             if (stripped !== c.text && stripped.trim().length === 0) continue;
             textParts.push(stripped);
           }
         }
         const media = resolveMediaUrl(c);
-        if (media) images.push({ url: media.url, kind: media.kind, alt: c.type === 'file' ? c.name : undefined, fileId: media.fileId });
+        if (media) {
+          attachments.push({
+            url: media.url,
+            kind: media.kind,
+            name: c.type === 'file' ? c.name : undefined,
+            fileId: media.fileId,
+          });
+          continue;
+        }
+        // Non-media files (pdf/zip/yaml/…) carry no playable URL, but the chip
+        // still renders them with name/size and a download action.
+        if (c.type === 'file' && getFileUrl) {
+          attachments.push({
+            kind: 'file',
+            url: getFileUrl(c.fileId),
+            fileId: c.fileId,
+            name: c.name,
+            mediaType: c.mediaType || undefined,
+            size: c.size,
+          });
+        }
       }
       turns.push({
         id: msg.id,
         role: 'user',
         no: no++,
         text: textParts.join('\n'),
-        images: images.length > 0 ? images : undefined,
+        attachments: attachments.length > 0 ? attachments : undefined,
         skillActivation: isSkillActivation
           ? { name: origin.skillName!, args: origin.skillArgs }
           : undefined,
diff --git a/apps/kimi-web/src/composables/useAttachmentUpload.ts b/apps/kimi-web/src/composables/useAttachmentUpload.ts
index 771b25d54..2c97c4d6c 100644
--- a/apps/kimi-web/src/composables/useAttachmentUpload.ts
+++ b/apps/kimi-web/src/composables/useAttachmentUpload.ts
@@ -1,6 +1,8 @@
 // apps/kimi-web/src/composables/useAttachmentUpload.ts
-// Image/video attachment handling for the composer: file picker, paste, drag &
-// drop, the upload machinery, the chip strip, and the preview lightbox.
+// Attachment handling for the composer: file picker, paste, drag & drop, the
+// upload machinery, the chip strip, and the preview lightbox. Images and
+// videos get media chips with thumbnails; any other file type attaches as a
+// generic file chip (an icon + name, no thumbnail) and is sent as a file part.
 //
 // Pending attachments are scoped per session (keyed by session id) so switching
 // sessions can't leak one session's unsent attachments into another session's
@@ -17,10 +19,14 @@ export interface Attachment {
   localId: string;
   /** File name */
   name: string;
-  /** image or video — drives the chip preview and the content-block type. */
-  kind: 'image' | 'video';
-  /** Object URL for the thumbnail preview */
-  previewUrl: string;
+  /** image, video, or any other file — drives the chip preview and the content-block type. */
+  kind: 'image' | 'video' | 'file';
+  /** Object URL for the thumbnail preview (unset for file attachments — those render an icon chip). */
+  previewUrl?: string;
+  /** Local MIME of the picked file — echoed into the wire file part. */
+  mediaType?: string;
+  /** Local byte size of the picked file — echoed into the wire file part. */
+  size?: number;
   /** True while uploading */
   uploading: boolean;
   /** Resolved daemon file id (set after upload completes) */
@@ -61,13 +67,15 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
   }
 
   function revokeAttachment(att: Attachment): void {
+    if (att.previewUrl === undefined) return;
     try { URL.revokeObjectURL(att.previewUrl); } catch { /* ignore */ }
   }
 
-  function mediaKind(mime: string): 'image' | 'video' | null {
+  function attachmentKind(mime: string): 'image' | 'video' | 'file' {
     if (mime.startsWith('image/')) return 'image';
     if (mime.startsWith('video/')) return 'video';
-    return null;
+    // Everything else — including an empty/unknown MIME — attaches as a file.
+    return 'file';
   }
 
   async function addFiles(files: File[]): Promise<void> {
@@ -76,15 +84,24 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
     // Capture the session at upload time; async completion must update the same
     // session even if the user has since switched away.
     const sid = sessionId() ?? '';
-    const media = files
-      .map((file) => ({ file, kind: mediaKind(file.type) }))
-      .filter((m): m is { file: File; kind: 'image' | 'video' } => m.kind !== null);
-    if (media.length === 0) return;
+    if (files.length === 0) return;
 
-    for (const { file, kind } of media) {
+    for (const file of files) {
+      const kind = attachmentKind(file.type);
       const localId = nextLocalId();
-      const previewUrl = URL.createObjectURL(file);
-      const att: Attachment = { localId, name: file.name, kind, previewUrl, uploading: true };
+      // Only media gets a thumbnail object URL; files render an icon chip.
+      const previewUrl = kind === 'file' ? undefined : URL.createObjectURL(file);
+      const att: Attachment = {
+        localId,
+        name: file.name,
+        kind,
+        previewUrl,
+        // Extensionless/unknown files report an empty MIME — normalize now so
+        // the wire file part's required non-empty media_type never sees ''.
+        mediaType: file.type || 'application/octet-stream',
+        size: file.size,
+        uploading: true,
+      };
       setForSession(sid, [...(attachmentsBySession.value[sid] ?? []), att]);
 
       // Upload in background; update the attachment when done.
@@ -94,7 +111,15 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
           sid,
           current.map((a) =>
             a.localId === localId
-              ? { ...a, uploading: false, fileId: result?.fileId, error: result === null }
+              ? {
+                  ...a,
+                  uploading: false,
+                  fileId: result?.fileId,
+                  // Adopt the server-recorded MIME when available — the
+                  // server's file meta is what the prompt route reads.
+                  mediaType: result?.mediaType ?? a.mediaType,
+                  error: result === null,
+                }
               : a,
           ),
         );
@@ -144,7 +169,7 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
     const cd = e.clipboardData;
     if (!cd) return;
 
-    // Collect image files from both .items and .files to cover all browsers/OS.
+    // Collect attached files from both .items and .files to cover all browsers/OS.
     const files: File[] = [];
     const seenKeys = new Set<string>();
 
@@ -159,7 +184,7 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
 
     // From DataTransferItemList.
     for (const item of Array.from(cd.items)) {
-      if (item.kind === 'file' && mediaKind(item.type)) {
+      if (item.kind === 'file') {
         const blob = item.getAsFile();
         if (blob) addBlob(blob, blob.name || `paste-${Date.now()}.${item.type.split('/')[1] ?? 'png'}`);
       }
@@ -167,23 +192,27 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
 
     // From FileList (some browsers/OS put screenshots here directly).
     for (const file of Array.from(cd.files)) {
-      if (mediaKind(file.type)) {
-        addBlob(file, file.name);
-      }
+      addBlob(file, file.name);
     }
 
-    if (files.length === 0) return; // No media — let normal text paste proceed unmodified.
+    if (files.length === 0) return; // No files — let normal text paste proceed unmodified.
 
     e.preventDefault();
     void addFiles(files);
   }
 
-  // Drag-drop handlers.
+  // Drag-drop handlers. WindowDragDepth tracks nested dragenter/dragleave pairs
+  // for the document-level listeners below (declared here so the composer
+  // handlers can reset it on their own drop).
+  let windowDragDepth = 0;
+
   function handleDragOver(e: DragEvent): void {
     if (!uploadImage()) return;
     const hasFiles = Array.from(e.dataTransfer?.items ?? []).some((item) => item.kind === 'file');
     if (!hasFiles) return;
+    // Stop the document-level handler from double-counting this as a new enter.
     e.preventDefault();
+    e.stopPropagation();
     isDragOver.value = true;
   }
 
@@ -192,6 +221,45 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
   }
 
   function handleDrop(e: DragEvent): void {
+    windowDragDepth = 0;
+    isDragOver.value = false;
+    if (!uploadImage()) return;
+    // Stop the document-level drop handler from adding the same files twice.
+    e.preventDefault();
+    e.stopPropagation();
+    const files = Array.from(e.dataTransfer?.files ?? []);
+    void addFiles(files);
+  }
+
+  // Window-level drag & drop. Without a document-wide handler, dropping a file
+  // anywhere outside the small composer box makes the browser navigate away to
+  // the file. Nested dragenter/dragleave pairs fire while moving across child
+  // elements, so the overlay is driven by a counter, not by single events.
+  function windowDragHasFiles(e: DragEvent): boolean {
+    return Array.from(e.dataTransfer?.items ?? []).some((item) => item.kind === 'file');
+  }
+
+  function handleWindowDragEnter(e: DragEvent): void {
+    if (!uploadImage() || !windowDragHasFiles(e)) return;
+    e.preventDefault();
+    windowDragDepth += 1;
+    isDragOver.value = true;
+  }
+
+  function handleWindowDragOver(e: DragEvent): void {
+    if (!uploadImage() || !windowDragHasFiles(e)) return;
+    // Keep the browser from navigating away when the drop lands outside the composer.
+    e.preventDefault();
+  }
+
+  function handleWindowDragLeave(e: DragEvent): void {
+    if (!uploadImage() || !windowDragHasFiles(e)) return;
+    windowDragDepth = Math.max(0, windowDragDepth - 1);
+    if (windowDragDepth === 0) isDragOver.value = false;
+  }
+
+  function handleWindowDrop(e: DragEvent): void {
+    windowDragDepth = 0;
     isDragOver.value = false;
     if (!uploadImage()) return;
     e.preventDefault();
@@ -231,7 +299,7 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
    *  fetch an authenticated blob URL so the thumbnail doesn't 401. Replaces any
    *  unsent draft attachments (mirroring loadForEdit(text), which overwrites) so
    *  a later submit sends exactly the edited message's files, not a mix. */
-  function loadAttachments(atts: { fileId?: string; kind: 'image' | 'video'; url: string; name?: string }[]): void {
+  function loadAttachments(atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
     const sid = sessionId() ?? '';
     for (const existing of attachmentsBySession.value[sid] ?? []) revokeAttachment(existing);
     setForSession(sid, []);
@@ -243,16 +311,17 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
 
       if (att.fileId) {
         // Ready as-is; fetch an authenticated thumbnail for protected URLs.
+        // File attachments have no thumbnail — nothing to fetch or revoke.
         const entry: Attachment = {
           localId,
           name,
           kind: att.kind,
-          previewUrl: att.url,
+          previewUrl: att.kind === 'file' ? undefined : att.url,
           uploading: false,
           fileId: att.fileId,
         };
         setForSession(sid, [...(attachmentsBySession.value[sid] ?? []), entry]);
-        if (!isData && !isBlob) {
+        if (att.kind !== 'file' && !isData && !isBlob) {
           void getKimiWebApi().getFileBlob(att.fileId).then((blob) => {
             const blobUrl = URL.createObjectURL(blob);
             const current = attachmentsBySession.value[sid] ?? [];
@@ -271,6 +340,10 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
         // actually resendable — otherwise handleSubmit silently drops it. If the
         // URL can't be fetched (CORS / non-2xx) or upload is unavailable, skip
         // the chip rather than show a misleading ready attachment.
+        // No URL at all (the non-clickable chip rebuilt from an inline-base64
+        // notice): skip too — fetch('') would resolve to the current page and
+        // upload the web app's HTML as the attachment.
+        if (!att.url) continue;
         const upload = uploadImage();
         if (!upload) continue;
         const entry: Attachment = {
@@ -310,11 +383,19 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
 
   onMounted(() => {
     document.addEventListener('paste', handleDocumentPaste);
+    document.addEventListener('dragenter', handleWindowDragEnter);
+    document.addEventListener('dragover', handleWindowDragOver);
+    document.addEventListener('dragleave', handleWindowDragLeave);
+    document.addEventListener('drop', handleWindowDrop);
   });
 
   // Revoke all object URLs (every session) and remove the global listener on unmount.
   onUnmounted(() => {
     document.removeEventListener('paste', handleDocumentPaste);
+    document.removeEventListener('dragenter', handleWindowDragEnter);
+    document.removeEventListener('dragover', handleWindowDragOver);
+    document.removeEventListener('dragleave', handleWindowDragLeave);
+    document.removeEventListener('drop', handleWindowDrop);
     for (const atts of Object.values(attachmentsBySession.value)) {
       for (const att of atts) revokeAttachment(att);
     }
diff --git a/apps/kimi-web/src/composables/useConfirmDialog.ts b/apps/kimi-web/src/composables/useConfirmDialog.ts
index 72b3c4e57..b638b1b66 100644
--- a/apps/kimi-web/src/composables/useConfirmDialog.ts
+++ b/apps/kimi-web/src/composables/useConfirmDialog.ts
@@ -13,34 +13,71 @@ export type ConfirmOptions = {
   confirmLabel?: string;
   cancelLabel?: string;
   variant?: ConfirmVariant;
+  /** Async work started when the user confirms. While it runs, the dialog
+   *  stays open with the confirm button in a loading state (cancel / Esc /
+   *  overlay-click are suppressed), then closes and resolves true. A
+   *  rejection closes the dialog and rethrows to the confirm() caller. */
+  action?: () => unknown;
 };
 
 type ConfirmRequest = ConfirmOptions & {
   resolve: (ok: boolean) => void;
+  reject: (err: unknown) => void;
 };
 
 const current = ref<ConfirmRequest | null>(null);
+/** True while a confirmed request's `action` is still running. */
+const busy = ref(false);
 
 function settle(ok: boolean): void {
   const req = current.value;
-  if (!req) return;
+  if (!req || busy.value) return;
   current.value = null;
   req.resolve(ok);
 }
 
+/** Invoked by the host when the user confirms. Runs the request's `action`
+ *  (keeping the dialog open with a loading state until it settles), or just
+ *  resolves true when the request has none. Never rejects. */
+async function runAction(): Promise<void> {
+  const req = current.value;
+  if (!req || busy.value) return;
+  if (!req.action) {
+    settle(true);
+    return;
+  }
+  busy.value = true;
+  try {
+    await req.action();
+    if (current.value === req) current.value = null;
+    req.resolve(true);
+  } catch (error) {
+    if (current.value === req) current.value = null;
+    req.reject(error);
+  } finally {
+    busy.value = false;
+  }
+}
+
 function confirm(options: ConfirmOptions): Promise<boolean> {
+  // A confirmed action is still in flight: a second dialog can't supersede the
+  // busy one (it would inherit the global busy state and open inert), so the
+  // new request resolves unconfirmed instead.
+  if (busy.value) return Promise.resolve(false);
   // If a confirm is already open, treat it as cancelled before showing the new
   // one so its caller isn't left hanging.
   if (current.value) settle(false);
-  return new Promise<boolean>((resolve) => {
-    current.value = { ...options, resolve };
+  return new Promise<boolean>((resolve, reject) => {
+    current.value = { ...options, resolve, reject };
   });
 }
 
 export function useConfirmDialog(): {
   current: typeof current;
+  busy: typeof busy;
   confirm: typeof confirm;
   settle: typeof settle;
+  runAction: typeof runAction;
 } {
-  return { current, confirm, settle };
+  return { current, busy, confirm, settle, runAction };
 }
diff --git a/apps/kimi-web/src/composables/useFilePreview.ts b/apps/kimi-web/src/composables/useFilePreview.ts
index 162781ee7..dea317f48 100644
--- a/apps/kimi-web/src/composables/useFilePreview.ts
+++ b/apps/kimi-web/src/composables/useFilePreview.ts
@@ -134,14 +134,10 @@ export function useFilePreview({ client, detailTarget }: UseFilePreviewOptions)
       if (result) {
         previewFile.value = { ...result, path: result.path || normalized.path };
       } else {
-        previewFile.value = {
-          path: normalized.path,
-          content: '',
-          encoding: 'utf-8',
-          mime: 'text/plain',
-          isBinary: false,
-          size: 0,
-        };
+        // readFileContent swallows daemon failures into null — show the error
+        // state instead of a misleading 0-byte "empty file" (the cause is
+        // already console.warn'd in readFileContent).
+        previewError.value = t('filePreview.errors.loadFailed');
       }
     } catch (err) {
       if (requestSeq !== previewRequestSeq) return;
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index aac2b903f..b9614091c 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -29,7 +29,13 @@ import {
   saveWorkspaceSort,
   STORAGE_KEYS,
 } from '../lib/storage';
-import { createEventBatcher, isRenderEvent } from './client/eventBatcher';
+import {
+  coalesceAppRenderEvents,
+  createEventBatcher,
+  isRenderEvent,
+  splitOversizedAppRenderEvent,
+  type PendingAppEvent,
+} from './client/eventBatcher';
 import { useAppearance } from './client/useAppearance';
 import { useNotification, shouldNotifyCompletion } from './client/useNotification';
 import { useSoundNotification } from './client/useSoundNotification';
@@ -64,6 +70,7 @@ import type {
   AppWorkspace,
   ApprovalDecision,
   KimiEventConnection,
+  KimiEventMeta,
   ThinkingLevel,
 } from '../api/types';
 import { createInitialState, reduceAppEvent, type CompactionStatus, type KimiClientState } from '../api/daemon/eventReducer';
@@ -277,8 +284,17 @@ interface GitStatusEntry {
 }
 
 /** An uploaded attachment to send with a prompt. `kind` drives the content-block
-    type (image vs video) so a still and a clip resolve to the right wire shape. */
-export type PromptAttachment = { fileId: string; kind: 'image' | 'video' };
+    type: images/videos become media parts; any other kind becomes a file part
+    the server materializes and hands to the model as a path reference.
+    name/mediaType/size feed the wire file shape (the server's file-store meta
+    stays authoritative, so a chip reloaded from history may omit them). */
+export type PromptAttachment = {
+  fileId: string;
+  kind: 'image' | 'video' | 'file';
+  name?: string;
+  mediaType?: string;
+  size?: number;
+};
 
 /** A prompt waiting for the session to go idle. Keeps the uploaded
     fileIds so attachments survive queueing (not just the text). */
@@ -326,8 +342,13 @@ export interface ExtendedState extends KimiClientState {
   // AUTHORITATIVE id for :abort — the event projector synthesizes a `pr_…` id
   // when turn.started races ahead of binding, which the daemon rejects.
   promptIdBySession: Record<string, string>;
-  // True while a prompt is in flight but the assistant reply hasn't started yet.
-  sendingBySession: Record<string, boolean>;
+  // A prompt this client submitted (or skill-activated) has not reached its
+  // terminal state yet — the OPTIMISTIC half of the working moon, covering the
+  // window before the turn.started round-trips (and the queue-drain re-arm).
+  // Set at every local turn entry point; cleared by finishPromptLocal, the
+  // entry points' own error paths, the authoritative-quiet fallback, or session
+  // forget. `turnActiveBySession` owns everything from turn.started on.
+  inFlightBySession: Record<string, boolean>;
   // True when a BACKGROUND session finished a turn the user hasn't opened since
   // (drives the unread blue dot in the sidebar). Set on idle for a non-active
   // session, cleared when the session is selected.
@@ -392,7 +413,7 @@ const rawState: ExtendedState = reactive({
   queuedBySession: {},
   gitStatusBySession: {},
   promptIdBySession: {},
-  sendingBySession: {},
+  inFlightBySession: {},
   unreadBySession: loadUnread(),
   authReady: false,
   defaultModel: null,
@@ -575,13 +596,11 @@ function forgetSession(sessionId: string): void {
   // per-session maps we are about to delete.
   eventConn?.unsubscribe(sessionId);
   dropWsSubscription(sessionId);
-  // Drain the streaming-event batcher too. unsubscribe() stops future server
-  // frames, but events already queued for the next animation frame would
-  // otherwise survive and be reduced AFTER the maps below are cleared —
-  // recreating entries like messagesBySession[id] and lastSeqBySession[id].
-  // That would make hasLoadedMessages() treat the stale empty cache as
-  // authoritative and skip the next snapshot fetch for this id.
-  enqueueEvent.flush();
+  // Drop this session's queued render AND control events. Flushing them here is
+  // unsafe: a delayed idle event can drain a queued prompt into the session
+  // after the archive request succeeded. Other sessions keep their own ordered
+  // backlog and scheduled continuation.
+  enqueueEvent.discard(({ meta }) => meta.sessionId === sessionId);
   removeSession(sessionId);
   removeSessionMessages(sessionId);
   delete rawState.approvalsBySession[sessionId];
@@ -600,13 +619,13 @@ function forgetSession(sessionId: string): void {
   sessionsKnownEmpty.delete(sessionId);
   // In-flight / queued prompt state: drop these too so a queued follow-up
   // can't be submitted to a session that was just archived when its turn later
-  // goes idle (onSessionIdle drains queuedBySession[sid] without re-checking
+  // ends (onMainTurnEnd drains queuedBySession[sid] without re-checking
   // that the session still exists).
-  inFlightPromptSessions.delete(sessionId);
   forgetLocalTurnState(sessionId);
   delete rawState.queuedBySession[sessionId];
   delete rawState.promptIdBySession[sessionId];
-  delete rawState.sendingBySession[sessionId];
+  delete rawState.inFlightBySession[sessionId];
+  delete rawState.turnActiveBySession[sessionId];
   // Drop per-session mode toggles and re-persist so a deleted session's entry
   // doesn't linger in localStorage.
   delete rawState.planModeBySession[sessionId];
@@ -699,10 +718,12 @@ async function refreshSessionGoal(sessionId: string): Promise<void> {
  *  session and immediately persisting its draft modes, so a concurrent session
  *  switch can't write the patch to the wrong session.
  *
- *  Returns the update promise (errors swallowed — the UI already updated
- *  optimistically). Most callers fire-and-forget via `void persistSessionProfile(...)`;
- *  call sites that must order strictly after the profile (e.g. a skill
- *  activation that can't carry its own modes) await it. */
+ *  Returns the update promise. Failures are surfaced via pushOperationFailure
+ *  (the UI already updated optimistically, so the user must be told when the
+ *  daemon did not apply the change); the promise itself never rejects. Most
+ *  callers fire-and-forget via `void persistSessionProfile(...)`; call sites
+ *  that must order strictly after the profile (e.g. a skill activation that
+ *  can't carry its own modes) await it. */
 function persistSessionProfile(patch: {
   model?: string;
   permissionMode?: string;
@@ -717,8 +738,10 @@ function persistSessionProfile(patch: {
   // Promise.resolve wrap: tolerate a sync/undefined return (e.g. test mocks).
   return Promise.resolve(getKimiWebApi().updateSession(sid, patch))
     .then(() => refreshSessionStatus(sid))
-    .catch(() => {
-      /* ignore — local state already reflects the change */
+    .catch((err) => {
+      // Local state already reflects the change; tell the user (and the log)
+      // that the daemon did not persist it.
+      pushOperationFailure('persistSessionProfile', err, { sessionId: sid });
     });
 }
 
@@ -785,13 +808,6 @@ function nextOptimisticMsgId(): string {
   return `msg_opt_${Date.now().toString(36)}_${optimisticMsgSeq}`;
 }
 
-// Per-session "a prompt is in flight" flag. Flipped SYNCHRONOUSLY the moment we
-// decide to submit (before any await), and cleared when the session returns to
-// idle. This gates concurrent prompts: `activity` only turns 'running' after the
-// WS turn.started round-trips, so a fast second sendPrompt would otherwise race
-// past the queue check and clobber promptIdBySession (breaking abort).
-const inFlightPromptSessions = new Set<string>();
-
 // Helper: mutate rawState by applying a reducer on a snapshot then re-assigning fields
 function applyEvent(event: ReturnType<typeof toAppEvent>, sessionId: string, seq: number): void {
   const snapshot: KimiClientState = {
@@ -805,6 +821,7 @@ function applyEvent(event: ReturnType<typeof toAppEvent>, sessionId: string, seq
     goalBySession: rawState.goalBySession,
     goalVersionBySession: rawState.goalVersionBySession,
     lastSeqBySession: rawState.lastSeqBySession,
+    turnActiveBySession: rawState.turnActiveBySession,
     compactionBySession: rawState.compactionBySession,
     config: rawState.config,
     warnings: rawState.warnings,
@@ -821,6 +838,7 @@ function applyEvent(event: ReturnType<typeof toAppEvent>, sessionId: string, seq
   rawState.goalBySession = next.goalBySession;
   rawState.goalVersionBySession = next.goalVersionBySession;
   rawState.lastSeqBySession = next.lastSeqBySession;
+  rawState.turnActiveBySession = next.turnActiveBySession;
   rawState.compactionBySession = next.compactionBySession;
   rawState.config = next.config ?? null;
   rawState.warnings = next.warnings;
@@ -856,22 +874,19 @@ function applyEvent(event: ReturnType<typeof toAppEvent>, sessionId: string, seq
 // synchronously triggers a full Vue re-render per event, which saturates the
 // main thread and makes the stream look janky (see messagesToTurns / Markdown).
 //
-// We coalesce those render-only events onto the next animation frame so Vue
-// commits a single render per frame. Lifecycle / control-flow events
-// (sessionStatusChanged, messageCreated, approval*, question*, ...) are applied
-// immediately: they are infrequent, and some (e.g. sessionStatusChanged idle)
-// drive turn-end cleanup that must not be delayed by a throttled rAF in a
-// background tab. Ordering is preserved by draining any pending render events
-// before applying an immediate event.
+// Adjacent, offset-contiguous assistant/thinking deltas are merged before they
+// reach the reducer. The remaining ordered groups are processed with a fixed
+// per-frame budget and a task fallback, so a hidden tab cannot turn the entire
+// backlog into one unbounded rAF drain. Lifecycle / control-flow events remain
+// strict ordering barriers and are never dropped or merged.
 
-type PendingEvent = { appEvent: AppEvent; meta: { sessionId: string; seq: number } };
-
-function processEvent(appEvent: AppEvent, meta: { sessionId: string; seq: number }): void {
+function processEvent(appEvent: AppEvent, meta: KimiEventMeta): void {
   // Capture BEFORE applyEvent advances lastSeqBySession: turn-end side
   // effects below only run when this event actually moves the durable cursor
   // forward. A late duplicate idle (e.g. replayed after a snapshot already
   // advanced past it) must not drain a second queued message.
   const prevSeq = rawState.lastSeqBySession[meta.sessionId] ?? 0;
+  const wasMainTurnActive = rawState.turnActiveBySession[meta.sessionId] ?? false;
   // meta carries wire-level seq/sessionId so the reducer can advance
   // lastSeqBySession[sessionId] = seq. Compaction completion appends a
   // persistent divider marker in the reducer (TUI parity: the scrollback
@@ -916,20 +931,52 @@ function processEvent(appEvent: AppEvent, meta: { sessionId: string; seq: number
     appearance.recordMoonDelta((appEvent.delta.text?.length ?? 0) + (appEvent.delta.thinking?.length ?? 0));
   }
 
-  // Turn-end cleanup for the session the event belongs to — including
-  // sessions running in the background (see onSessionIdle).
-  // Turn-end: both 'idle' and 'aborted' mean the prompt is no longer in
-  // flight, so both must flush in-flight/queued state. (Awaiting-* is still
-  // in flight — it's waiting on the user — and must NOT flush.)
-  // Gated on the durable cursor advancing: a late duplicate of an idle we
-  // already consumed (directly or via a snapshot past it) must not run the
-  // side effects again — above all, it must not drain another queued message.
+  // Prompt-end cleanup. The MAIN agent's turn boundary is the authoritative
+  // "the prompt is done" signal: it drives the in-flight/moon cleanup, the
+  // queued-message drain, and the completion side effects. The session may
+  // stay busy afterwards (background subagents / BTW) — that must NOT hold
+  // any of these. The session's idle/aborted status is only a fallback quiet
+  // signal (a turn.ended can be lost on abrupt agent disposal): it clears the
+  // boolean liveness flags, but drain/notify stay single-owned by the
+  // turn-boundary path. Both are gated on the durable cursor advancing so a
+  // late duplicate cannot fire twice.
   if (
-    appEvent.type === 'sessionStatusChanged' &&
-    (appEvent.status === 'idle' || appEvent.status === 'aborted') &&
+    appEvent.type === 'turnActiveChanged' &&
+    !appEvent.active &&
     meta.seq > prevSeq
   ) {
-    onSessionIdle(appEvent.sessionId, appEvent.status);
+    const reason = appEvent.reason;
+    onMainTurnEnd(
+      appEvent.sessionId,
+      reason === 'cancelled' || reason === 'failed' || reason === 'blocked' ? 'aborted' : 'idle',
+    );
+  }
+
+  if (
+    appEvent.type === 'sessionWorkChanged' &&
+    ((appEvent.mainTurnActive === false && wasMainTurnActive) ||
+      (appEvent.mainTurnActive === undefined && !appEvent.busy)) &&
+    meta.seq > prevSeq
+  ) {
+    clearWorkingFlags(appEvent.sessionId);
+  }
+
+  // A prompt that never produced a turn gets no turn.ended and no session
+  // status flip: a QUEUED prompt aborted before launch (prompt.aborted), or a
+  // prompt blocked by a pre-submit hook (prompt.completed with reason
+  // 'blocked'). Without this the local in-flight flag — and the working moon —
+  // would stick forever. Keyed on the promptId captured at submit: a normal
+  // turn's prompt.completed/aborted arrives AFTER its status_changed (which
+  // already cleared the id), so it no-ops; another client's prompt never
+  // matches. Only fires when the event moves the durable cursor forward, same
+  // as the status path above.
+  if (
+    (appEvent.type === 'promptAborted' ||
+      (appEvent.type === 'promptCompleted' && appEvent.reason === 'blocked')) &&
+    meta.seq > prevSeq &&
+    rawState.promptIdBySession[appEvent.sessionId] === appEvent.promptId
+  ) {
+    workspaceState.finishPromptLocal(appEvent.sessionId);
   }
 
   // The agent asked a question and is waiting for an answer — surface it so
@@ -946,9 +993,10 @@ function processEvent(appEvent: AppEvent, meta: { sessionId: string; seq: number
   }
 }
 
-const enqueueEvent = createEventBatcher<PendingEvent>(
+const enqueueEvent = createEventBatcher<PendingAppEvent>(
   ({ appEvent, meta }) => processEvent(appEvent, meta),
   ({ appEvent }) => isRenderEvent(appEvent),
+  { coalesce: coalesceAppRenderEvents },
 );
 
 // ---------------------------------------------------------------------------
@@ -979,10 +1027,11 @@ function connectEventsIfNeeded(): void {
         return;
       }
 
-      // Coalesce high-frequency render events onto the next animation frame;
-      // everything else is applied immediately. See createEventBatcher /
-      // processEvent above.
-      enqueueEvent({ appEvent, meta });
+      // Merge safe streaming chunks, then process the ordered queue in bounded
+      // slices. See createEventBatcher / processEvent above.
+      for (const pendingEvent of splitOversizedAppRenderEvent({ appEvent, meta })) {
+        enqueueEvent(pendingEvent);
+      }
     },
 
     onResync(sessionId: string, currentSeq: number, epoch?: string) {
@@ -1231,6 +1280,21 @@ function pushOperationFailure(
   err: unknown,
   opts?: { title?: string; message?: string; sessionId?: string },
 ): void {
+  // Always-on logging: a surfaced failure must be diagnosable from the console
+  // and from the exported web log (session export), not just from the toast.
+  console.error(`[kimi-web] operation failed: ${operation}`, err);
+  const api = isDaemonApiError(err);
+  const network = isDaemonNetworkError(err);
+  traceKeyEvent('operation:failed', {
+    sessionId: opts?.sessionId,
+    status: 'failed',
+    operation,
+    errorName: err instanceof Error ? err.name : typeof err,
+    errorCode: api ? err.code : undefined,
+    requestId: api || network ? err.requestId : undefined,
+    phase: network ? err.phase : undefined,
+    httpStatus: network ? err.status : undefined,
+  });
   pushWarning(operationFailureNotice(operation, err, opts));
 }
 
@@ -1387,12 +1451,27 @@ async function syncSessionFromSnapshot(sessionId: string): Promise<SyncSessionRe
     sessionsRetryingStaleSnapshot.delete(sessionId);
 
     // Resync replaces the missed event stream, so a terminal snapshot must
-    // also clear the local sending flag that normally ends on a WS idle event.
+    // also clear the local in-flight flag that normally ends with the turn.
     workspaceState.handleSessionSnapshot(
       sessionId,
-      { inFlightTurn: snap.inFlightTurn, status: snap.session.status },
+      { inFlightTurn: snap.inFlightTurn, busy: snap.session.busy },
     );
 
+    // The snapshot's inFlightTurn is main-agent-only — seed the moon's
+    // liveness flag from it (the projector was reset by the resync, so no
+    // turn.ended may ever arrive for a turn that was live before it). Gated
+    // on the snapshot's busy fact: the live tracker can hold a stale turn
+    // whose turn.ended was lost (abrupt agent disposal) — the server-side
+    // busy read is the reconciler, so a dead turn never relights the moon.
+    {
+      const next = { ...rawState.turnActiveBySession };
+      const mainTurnActive =
+        snap.session.mainTurnActive ?? (snap.inFlightTurn !== null && snap.session.busy);
+      if (mainTurnActive) next[sessionId] = true;
+      else delete next[sessionId];
+      rawState.turnActiveBySession = next;
+    }
+
     connectEventsIfNeeded();
     if (eventConn) {
       // Seed BEFORE subscribing: the in-flight assistant message must exist
@@ -1508,34 +1587,25 @@ async function reopenSession(sessionId: string): Promise<SyncSessionResult> {
 // View-model mappers
 // ---------------------------------------------------------------------------
 
-/** Whether the session should show the "working" spinner. Only a `running`
-    session qualifies — `awaiting*` is waiting on the user (not working) and
-    `aborted` is finished, so neither spins. Additionally, a session whose only
-    running task is its BTW side-channel agent should not look busy. When tasks
-    have not been loaded yet — e.g. right after a page refresh — we trust the
-    daemon-reported `running` status rather than hiding the spinner. */
-function isSessionEffectivelyRunning(session: AppSession | undefined): boolean {
-  if (!session) return false;
-  if (session.status !== 'running') return false;
-  const sessionId = session.id;
-  const hiddenBtwAgentId = sideChat.sideChatTargetBySession.value[sessionId]?.agentId;
-  const tasks = rawState.tasksBySession[sessionId] ?? [];
-  const runningTasks = tasks.filter((t) => t.status === 'running');
-  if (runningTasks.length === 0) {
-    // No task list yet (fresh refresh) — trust the daemon-reported session status,
-    // unless the only active work is a BTW side-chat agent. In that window the
-    // side chat is sending and its task hasn't been loaded, so suppress the main
-    // session spinner so the main composer stays usable.
-    if (hiddenBtwAgentId && rawState.sideChatSendingByAgent[hiddenBtwAgentId]) {
-      return false;
-    }
-    return true;
-  }
-  return runningTasks.some((t) => t.id !== hiddenBtwAgentId);
+/** Whether the session should show a "working" indicator (sidebar spinner,
+    row badge gating). ONE unified condition, shared with the working moon and
+    the Stop button: the main conversation has unfinished work — a prompt
+    submitted but not yet terminated (`inFlightBySession`) or a main turn in
+    flight (`turnActiveBySession`). Background tasks and subagent turns do NOT
+    light it; an approval/question pause does NOT dim it (the turn is still
+    open). */
+function isMainTurnActive(sessionId: string, listed?: boolean): boolean {
+  return (
+    (rawState.inFlightBySession[sessionId] ?? false) ||
+    (rawState.turnActiveBySession[sessionId] ?? false) ||
+    (listed ??
+      rawState.sessions.find((session) => session.id === sessionId)?.mainTurnActive ??
+      false)
+  );
 }
 
 /** Format createdAt/updatedAt into a short display string */
-function formatTime(iso: string, _status: string): string {
+function formatTime(iso: string): string {
   try {
     const d = new Date(iso);
     const now = Date.now();
@@ -1573,7 +1643,10 @@ function stopSessionTimeClock(): void {
 }
 
 if (import.meta.hot) {
-  import.meta.hot.dispose(stopSessionTimeClock);
+  import.meta.hot.dispose(() => {
+    stopSessionTimeClock();
+    enqueueEvent.dispose();
+  });
 }
 
 /** Build DiffLine[] from old_text/new_text strings */
@@ -1829,9 +1902,10 @@ const sessions = computed<Session[]>(() => {
     .map((s) => ({
       id: s.id,
       title: s.title,
-      time: formatTime(s.updatedAt, s.status),
-      status: s.status,
-      busy: isSessionEffectivelyRunning(s),
+      time: formatTime(s.updatedAt),
+      busy: isMainTurnActive(s.id, s.mainTurnActive),
+      pendingInteraction: s.pendingInteraction,
+      lastTurnReason: s.lastTurnReason,
     }));
 });
 
@@ -1846,10 +1920,10 @@ const skills = computed<AppSkill[]>(() => {
   return wid ? (modelProvider.skillsByWorkspace.value[wid] ?? []) : [];
 });
 
-const isSending = computed<boolean>(() => {
+const inFlight = computed<boolean>(() => {
   const sid = rawState.activeSessionId;
   if (!sid) return false;
-  return rawState.sendingBySession[sid] ?? false;
+  return rawState.inFlightBySession[sid] ?? false;
 });
 
 // True while the empty-composer first prompt for the active workspace is being
@@ -1883,11 +1957,29 @@ const turns = computed<ChatTurn[]>(() => {
     messages,
     approvals,
     (fileId) => getKimiWebApi().getFileUrl(fileId),
-    activity.value !== 'idle',
+    turnActive.value,
     rawState.planReviewByToolCallId,
   );
 });
 
+/** The MAIN agent of the active session has a turn in flight — the working
+ *  moon's authoritative half (the optimistic `inFlight` window covers the gap
+ *  before the turn.started round-trips). Background agents and BTW side chats
+ *  do NOT set this; the session-busy status lives on `activity`. */
+const turnActive = computed<boolean>(() => {
+  const sid = rawState.activeSessionId;
+  if (!sid) return false;
+  return (
+    (rawState.turnActiveBySession[sid] ?? false) ||
+    (rawState.sessions.find((session) => session.id === sid)?.mainTurnActive ?? false)
+  );
+});
+
+/** The working moon: the main conversation has an unfinished prompt — either
+ *  submitted-but-not-terminated (`inFlight`) or a main turn in flight
+ *  (`turnActive`). */
+const working = computed<boolean>(() => inFlight.value || turnActive.value);
+
 const tasks = computed<TaskItem[]>(() => {
   // Touch the clock so a running task's elapsed time recomputes each tick.
   void taskPoller.taskClock.value;
@@ -2007,6 +2099,7 @@ const queued = computed<QueuedPromptView[]>(() => {
       fileId: a.fileId,
       kind: a.kind,
       url: api.getFileUrl(a.fileId),
+      name: a.name,
     })),
   }));
 });
@@ -2041,6 +2134,13 @@ const pendingApprovals = computed<
 /**
  * Activity state for the active session.
  * Priority: awaiting-approval > awaiting-question > running > idle
+ *
+ * `running` is main-conversation liveness — the same condition as the working
+ * moon (the optimistic submit window or an in-flight main turn). The wire
+ * `busy` fact deliberately includes background tasks, but everything driven
+ * by `activity` (Stop button, composer/page-title spinners, send-vs-queue
+ * gating) follows the main conversation only: a session left with only
+ * background tasks is idle here, exactly like the retired turn-scoped status.
  */
 const activity = computed<ActivityState>(() => {
   const sid = rawState.activeSessionId;
@@ -2052,8 +2152,7 @@ const activity = computed<ActivityState>(() => {
   const questionList = rawState.questionsBySession[sid] ?? [];
   if (questionList.length > 0) return 'awaiting-question';
 
-  const activeSession = rawState.sessions.find((s) => s.id === sid);
-  if (isSessionEffectivelyRunning(activeSession)) {
+  if (inFlight.value || turnActive.value) {
     return 'running';
   }
 
@@ -2065,7 +2164,6 @@ const modelProvider = useModelProviderState(rawState, {
   refreshSessionStatus,
   persistSessionProfile,
   activity,
-  inFlightPromptSessions,
   saveThinkingToStorage,
   updateSession,
   updateSessionMessages,
@@ -2198,8 +2296,6 @@ const mergedWorkspaces = computed<AppWorkspace[]>(() =>
     workspaces: rawState.workspaces,
     sessions: rawState.sessions,
     hiddenWorkspaceRoots: rawState.hiddenWorkspaceRoots,
-    activeRoot: rawState.sessions.find((s) => s.id === rawState.activeSessionId)?.cwd,
-    activeBranch: gitInfo.value?.branch ?? null,
     sessionsHasMoreByWorkspace: rawState.sessionsHasMoreByWorkspace,
   }),
 );
@@ -2258,7 +2354,6 @@ const workspacesView = computed<WorkspaceView[]>(() => {
     name: w.name,
     root: w.root,
     shortPath: shortenHome(w.root, rawState.fsHome),
-    branch: w.branch,
     sessionCount: w.sessionCount,
   }));
   if (workspaceSortMode.value === 'recent') {
@@ -2329,9 +2424,10 @@ const sessionsForView = computed<Session[]>(() => {
       return {
         id: s.id,
         title: s.title,
-        time: formatTime(s.updatedAt, s.status),
-        status: s.status,
-        busy: isSessionEffectivelyRunning(s),
+        time: formatTime(s.updatedAt),
+        busy: isMainTurnActive(s.id, s.mainTurnActive),
+        pendingInteraction: s.pendingInteraction,
+        lastTurnReason: s.lastTurnReason,
         lastPrompt: s.lastPrompt,
         workspaceId,
         workspaceName: nameByWorkspaceId.get(workspaceId),
@@ -2351,9 +2447,10 @@ const workspaceGroups = computed<WorkspaceGroup[]>(() => {
     const view: Session = {
       id: s.id,
       title: s.title,
-      time: formatTime(s.updatedAt, s.status),
-      status: s.status,
-      busy: isSessionEffectivelyRunning(s),
+      time: formatTime(s.updatedAt),
+      busy: isMainTurnActive(s.id, s.mainTurnActive),
+      pendingInteraction: s.pendingInteraction,
+      lastTurnReason: s.lastTurnReason,
       updatedAt: s.updatedAt,
     };
     const list = byId.get(wid) ?? [];
@@ -2395,8 +2492,8 @@ function setWorkspaceSortMode(mode: WorkspaceSortMode): void {
 /**
  * Per-session pending-attention count = pending approvals + pending questions.
  * For the active session this is live (driven by WS events). Other sessions
- * light up once the daemon ships Session.pending_attention; until then their
- * counts are derived from whatever approvals/questions we've already seen.
+ * are derived from whatever approvals/questions we've already seen; the row's
+ * list-level pendingInteraction fact supplies the pre-status badge fallback.
  */
 const attentionBySession = computed<Record<string, number>>(() => {
   const out: Record<string, number> = {};
@@ -2459,11 +2556,13 @@ const availableOpenInApps = computed<string[]>(() => rawState.availableOpenInApp
 
 // ---------------------------------------------------------------------------
 // Per-session turn-end cleanup + queue auto-flush.
-// Driven by the daemon's sessionStatusChanged → idle event (wired in
+// Driven by the main agent's turn.ended boundary (wired in
 // connectEventsIfNeeded), NOT by the active-session `activity` computed: a
 // watcher on `activity` only ever saw the ACTIVE session, so a session that
 // finished in the background kept its in-flight flag forever — every later
-// prompt to it was silently enqueued and never flushed.
+// prompt to it was silently enqueued and never flushed. The session-busy
+// status stream is deliberately NOT the trigger: background agents keep it
+// non-idle past the main turn's end, which would hold the moon and the queue.
 // ---------------------------------------------------------------------------
 
 const workspaceState = useWorkspaceState(rawState, {
@@ -2472,7 +2571,6 @@ const workspaceState = useWorkspaceState(rawState, {
   modelProvider,
   pushOperationFailure,
   activity,
-  inFlightPromptSessions,
   sessionsKnownEmpty,
   setSessions,
   updateSession,
@@ -2524,11 +2622,33 @@ function isUserWatching(sid: string): boolean {
   );
 }
 
-function onSessionIdle(sid: string, status: 'idle' | 'aborted'): void {
+/**
+ * Authoritative-quiet escape hatch. The session's idle/aborted status means no
+ * main turn can still be in flight (an awaiting interaction would report
+ * awaiting_*, not idle), so both working-moon flags are cleared even when the
+ * turn.ended that owned them never arrived (e.g. abrupt agent disposal). This
+ * is the ONLY writer of `turnActiveBySession` outside the reducer /
+ * snapshot seed, and the ONLY clearer of `inFlightBySession` outside
+ * finishPromptLocal / the entry points' error paths. Drain and completion
+ * side effects are NOT run here — they stay single-owned by the turn.ended
+ * path (onMainTurnEnd).
+ */
+function clearWorkingFlags(sid: string): void {
+  if (rawState.turnActiveBySession[sid]) {
+    const next = { ...rawState.turnActiveBySession };
+    delete next[sid];
+    rawState.turnActiveBySession = next;
+  }
+  if (rawState.inFlightBySession[sid]) {
+    rawState.inFlightBySession = { ...rawState.inFlightBySession, [sid]: false };
+  }
+}
+
+function onMainTurnEnd(sid: string, status: 'idle' | 'aborted'): void {
   // Capture before finishPromptLocal drops it — it keys the completion
   // notification's dedup tag so each finished turn alerts once.
   const finishedPromptId = rawState.promptIdBySession[sid];
-  // Shared finish cleanup: clears in-flight/sending/prompt-id and drains one
+  // Shared finish cleanup: clears in-flight/prompt-id and drains one
   // queued message. The notification/sound/unread side effects below stay
   // WS-event-only — the snapshot path (handleSessionSnapshot) must not cry
   // wolf when opening a historical session.
@@ -2687,7 +2807,9 @@ export function useKimiWebClient() {
     warnings,
     questions,
     activity,
-    isSending,
+    turnActive,
+    inFlight,
+    working,
     isStartingFirstPrompt,
     fastMoon: appearance.fastMoon,
 
@@ -2805,7 +2927,6 @@ export function useKimiWebClient() {
     resolveImageUrl: workspaceState.resolveImageUrl,
 
     // Model + Provider actions
-    refreshOAuthProviderModels: modelProvider.refreshOAuthProviderModels,
     loadModels: modelProvider.loadModels,
     loadProviders: modelProvider.loadProviders,
     skills,
diff --git a/apps/kimi-web/src/debug/trace.ts b/apps/kimi-web/src/debug/trace.ts
index 7cb06c4f6..655f20b04 100644
--- a/apps/kimi-web/src/debug/trace.ts
+++ b/apps/kimi-web/src/debug/trace.ts
@@ -55,6 +55,7 @@ const EXPORT_TRACE_EVENTS = [
   'session:snapshot:start',
   'session:snapshot:accepted',
   'session:snapshot:failed',
+  'operation:failed',
   'window:error',
   'window:unhandled-rejection',
   'ws:connection',
@@ -68,6 +69,9 @@ type ExportTraceEvent = (typeof EXPORT_TRACE_EVENTS)[number];
 export interface ExportTraceMetadata {
   sessionId?: string;
   status?: string;
+  busy?: boolean;
+  /** Client operation name (e.g. 'archiveSession') for operation:failed. */
+  operation?: string;
   seq?: number;
   durationMs?: number;
   messageCount?: number;
@@ -226,6 +230,7 @@ function pushExportTrace(event: string, info?: ExportTraceMetadata): void {
       event: event as ExportTraceEvent,
       sessionId: exportString(info?.sessionId),
       status: exportString(info?.status),
+      operation: exportString(info?.operation),
       seq: exportNumber(info?.seq),
       durationMs: exportNumber(info?.durationMs),
       messageCount: exportNumber(info?.messageCount),
diff --git a/apps/kimi-web/src/i18n/locales/en/composer.ts b/apps/kimi-web/src/i18n/locales/en/composer.ts
index 567175c79..5f566c672 100644
--- a/apps/kimi-web/src/i18n/locales/en/composer.ts
+++ b/apps/kimi-web/src/i18n/locales/en/composer.ts
@@ -8,13 +8,18 @@ export default {
   queueNext: 'Up next',
   queueDragTitle: 'Drag to reorder',
   editQueued: 'Edit (load back into the input)',
-  queuedImageOnly: 'image ×{n}',
+  queuedAttachments: 'attachment ×{n}',
   queuedHasImage: 'Contains {n} image(s) — remove only, not editable',
+  attachmentImage: 'Image',
+  attachmentVideo: 'Video',
+  attachmentFile: 'File',
+  attachmentOpenUnsupported: 'Can’t open {name} — this file type isn’t supported',
+  dropToAttach: 'Drop files to attach',
   remove: 'Remove',
   removeNamed: 'Remove {name}',
   uploading: 'Uploading',
   uploadFailed: 'Upload failed',
-  attachImage: 'Attach image',
+  attachFile: 'Attach file',
   previewAttachment: 'Preview {name}',
   interrupt: 'Interrupt',
   interruptTitle: 'Interrupt current operation',
diff --git a/apps/kimi-web/src/i18n/locales/en/login.ts b/apps/kimi-web/src/i18n/locales/en/login.ts
index 3be4f32fd..790eee93e 100644
--- a/apps/kimi-web/src/i18n/locales/en/login.ts
+++ b/apps/kimi-web/src/i18n/locales/en/login.ts
@@ -19,4 +19,6 @@ export default {
   closeBtn: 'Close',
   errorTitle: 'The current daemon does not support login yet',
   errorHint: 'Please upgrade kimi-code and try again',
+  pollErrorTitle: 'Lost connection to the daemon',
+  pollErrorHint: 'Authorization polling failed repeatedly. Check the kimi-code process and try again.',
 } as const;
diff --git a/apps/kimi-web/src/i18n/locales/en/model.ts b/apps/kimi-web/src/i18n/locales/en/model.ts
index 962b2a831..aeba44be7 100644
--- a/apps/kimi-web/src/i18n/locales/en/model.ts
+++ b/apps/kimi-web/src/i18n/locales/en/model.ts
@@ -7,7 +7,7 @@ export default {
   searchPlaceholder: 'Search models or providers…',
   loading: 'Loading models…',
   unavailable: 'The daemon does not support model listing yet',
-  contextSuffix: '{size}k ctx',
+  contextSuffix: '{size} ctx',
   emptyNoModels: 'The daemon offers no selectable models',
   emptyNoMatch: 'No matching models',
   starTitle: 'Add to favorites',
diff --git a/apps/kimi-web/src/i18n/locales/en/warnings.ts b/apps/kimi-web/src/i18n/locales/en/warnings.ts
index 5afac2ef4..467e0ad70 100644
--- a/apps/kimi-web/src/i18n/locales/en/warnings.ts
+++ b/apps/kimi-web/src/i18n/locales/en/warnings.ts
@@ -2,6 +2,16 @@ export default {
   dismiss: 'Close',
   errorLabel: 'Error',
   noteLabel: 'Note',
+  agentError: {
+    title: 'Model request failed',
+    connection: 'Cannot connect to the model service',
+    auth: 'Model authentication failed',
+    rateLimit: 'Model rate limit reached',
+    overloaded: 'Model overloaded',
+    filtered: 'Response filtered by the provider',
+    api: 'Model API error',
+    contextOverflow: 'Context size exceeded',
+  },
   details: {
     cause: 'Cause',
     code: 'Error code',
diff --git a/apps/kimi-web/src/i18n/locales/en/workspace.ts b/apps/kimi-web/src/i18n/locales/en/workspace.ts
index bb6556eb5..d156809f7 100644
--- a/apps/kimi-web/src/i18n/locales/en/workspace.ts
+++ b/apps/kimi-web/src/i18n/locales/en/workspace.ts
@@ -34,7 +34,6 @@ export default {
   searching: 'Searching…',
   noFilterMatch: 'No subfolders match “{q}”',
   noSubfolders: 'No subfolders here',
-  gitTag: 'git',
   browseHint: 'Click a folder to enter it, then "Open this folder" to add it as a workspace.',
   // Path entry (absolute path typed into the same box)
   checkingPath: 'Checking path…',
diff --git a/apps/kimi-web/src/i18n/locales/zh/composer.ts b/apps/kimi-web/src/i18n/locales/zh/composer.ts
index fe9bda2a9..a0ef9f952 100644
--- a/apps/kimi-web/src/i18n/locales/zh/composer.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/composer.ts
@@ -8,13 +8,18 @@ export default {
   queueNext: '下一条',
   queueDragTitle: '拖拽排序',
   editQueued: '编辑（载入到输入框）',
-  queuedImageOnly: '图片 ×{n}',
+  queuedAttachments: '附件 ×{n}',
   queuedHasImage: '包含 {n} 张图片 — 只能移除，不能编辑',
+  attachmentImage: '图片',
+  attachmentVideo: '视频',
+  attachmentFile: '文件',
+  attachmentOpenUnsupported: '无法打开 {name}：暂不支持此文件类型',
+  dropToAttach: '松开鼠标添加附件',
   remove: '移除',
   removeNamed: '移除 {name}',
   uploading: '上传中',
   uploadFailed: '上传失败',
-  attachImage: '附加图片',
+  attachFile: '添加附件',
   previewAttachment: '预览 {name}',
   interrupt: '中断',
   interruptTitle: '中断当前操作',
diff --git a/apps/kimi-web/src/i18n/locales/zh/login.ts b/apps/kimi-web/src/i18n/locales/zh/login.ts
index 041550c62..42529dd57 100644
--- a/apps/kimi-web/src/i18n/locales/zh/login.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/login.ts
@@ -19,4 +19,6 @@ export default {
   closeBtn: '关闭',
   errorTitle: '当前 daemon 暂不支持登录',
   errorHint: '请升级 kimi-code 后重试',
+  pollErrorTitle: '与 daemon 的连接已断开',
+  pollErrorHint: '授权轮询连续失败，请检查 kimi-code 进程后重试',
 } as const;
diff --git a/apps/kimi-web/src/i18n/locales/zh/model.ts b/apps/kimi-web/src/i18n/locales/zh/model.ts
index d7702849e..f08ee5c01 100644
--- a/apps/kimi-web/src/i18n/locales/zh/model.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/model.ts
@@ -7,7 +7,7 @@ export default {
   searchPlaceholder: '搜索模型或提供商…',
   loading: '加载模型中…',
   unavailable: 'daemon 暂不支持模型列表',
-  contextSuffix: '{size}k ctx',
+  contextSuffix: '{size} ctx',
   emptyNoModels: 'daemon 未提供可选模型',
   emptyNoMatch: '无匹配模型',
   starTitle: '添加到收藏',
diff --git a/apps/kimi-web/src/i18n/locales/zh/warnings.ts b/apps/kimi-web/src/i18n/locales/zh/warnings.ts
index 0e3be56c1..916364887 100644
--- a/apps/kimi-web/src/i18n/locales/zh/warnings.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/warnings.ts
@@ -2,6 +2,16 @@ export default {
   dismiss: '关闭',
   errorLabel: '错误',
   noteLabel: '提示',
+  agentError: {
+    title: '模型请求失败',
+    connection: '无法连接模型服务',
+    auth: '模型认证失败',
+    rateLimit: '模型请求被限流',
+    overloaded: '模型服务过载',
+    filtered: '响应被提供方过滤',
+    api: '模型接口返回错误',
+    contextOverflow: '上下文超出模型限制',
+  },
   details: {
     cause: '底层原因',
     code: '错误码',
diff --git a/apps/kimi-web/src/i18n/locales/zh/workspace.ts b/apps/kimi-web/src/i18n/locales/zh/workspace.ts
index 23e6e38ad..1d60cfd6d 100644
--- a/apps/kimi-web/src/i18n/locales/zh/workspace.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/workspace.ts
@@ -34,7 +34,6 @@ export default {
   searching: '搜索中…',
   noFilterMatch: '没有匹配「{q}」的子文件夹',
   noSubfolders: '此处没有子文件夹',
-  gitTag: 'git',
   browseHint: '点击文件夹进入，再点"打开此文件夹"将其添加为工作区。',
   // Path entry (absolute path typed into the same box)
   checkingPath: '检查路径…',
diff --git a/apps/kimi-web/src/lib/formatTokens.test.ts b/apps/kimi-web/src/lib/formatTokens.test.ts
new file mode 100644
index 000000000..a8b2114df
--- /dev/null
+++ b/apps/kimi-web/src/lib/formatTokens.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatTokens } from './formatTokens';
+
+describe('formatTokens', () => {
+  it('renders sub-k counts as-is', () => {
+    expect(formatTokens(0)).toBe('0');
+    expect(formatTokens(512)).toBe('512');
+    expect(formatTokens(1023)).toBe('1023');
+  });
+
+  it('uses 1024-based k units', () => {
+    expect(formatTokens(1024)).toBe('1k');
+    expect(formatTokens(2048)).toBe('2k');
+    expect(formatTokens(262144)).toBe('256k');
+  });
+
+  it('keeps one decimal under 100k', () => {
+    expect(formatTokens(50552)).toBe('49.4k');
+    expect(formatTokens(1536)).toBe('1.5k');
+  });
+
+  it('rounds at and above 100k', () => {
+    expect(formatTokens(102400)).toBe('100k');
+    expect(formatTokens(999999)).toBe('977k');
+  });
+
+  it('uses 1024-based M units, dropping a trailing ".0"', () => {
+    expect(formatTokens(1048576)).toBe('1M');
+    expect(formatTokens(1572864)).toBe('1.5M');
+    expect(formatTokens(10485760)).toBe('10M');
+  });
+});
diff --git a/apps/kimi-web/src/lib/formatTokens.ts b/apps/kimi-web/src/lib/formatTokens.ts
new file mode 100644
index 000000000..5f588a15c
--- /dev/null
+++ b/apps/kimi-web/src/lib/formatTokens.ts
@@ -0,0 +1,20 @@
+// Format a token count for compact display. Context sizes are powers of two
+// (262144 = 256×1024, 1048576 = 1024×1024), so the k/M units are 1024-based —
+// a 256k context must render as "256k", never "262k".
+// - < 1024:    as-is ("512")
+// - k range:   one decimal under 100k, rounded above ("49.4k", "256k")
+// - M range:   one decimal, trailing ".0" dropped ("1M", "1.5M")
+export function formatTokens(n: number): string {
+  if (n >= 1024 * 1024) return `${trimDecimal(n / (1024 * 1024))}M`;
+  if (n >= 1024) {
+    const k = n / 1024;
+    return `${k >= 100 ? Math.round(k) : trimDecimal(k)}k`;
+  }
+  return String(n);
+}
+
+/** One decimal place, dropping a redundant ".0" ("1.0" → "1", "1.5" stays). */
+function trimDecimal(v: number): string {
+  const s = v.toFixed(1);
+  return s.endsWith('.0') ? s.slice(0, -2) : s;
+}
diff --git a/apps/kimi-web/src/lib/icons.ts b/apps/kimi-web/src/lib/icons.ts
index fcd6025e0..f7d64a8ad 100644
--- a/apps/kimi-web/src/lib/icons.ts
+++ b/apps/kimi-web/src/lib/icons.ts
@@ -36,6 +36,7 @@ import KimiSetting from '~icons/kimi/setting';
 // Components (Tabler) ---------------------------------------------------------
 import TablerSidebarLeftCollapse from '~icons/tabler/layout-sidebar-left-collapse';
 import TablerSidebarLeftExpand from '~icons/tabler/layout-sidebar-left-expand';
+import TablerPaperclip from '~icons/tabler/paperclip';
 
 // Components (Remix) ---------------------------------------------------------
 import RiAddLine from '~icons/ri/add-line';
@@ -47,6 +48,7 @@ import RiArrowGoBackLine from '~icons/ri/arrow-go-back-line';
 import RiArrowRightLine from '~icons/ri/arrow-right-line';
 import RiArrowRightSLine from '~icons/ri/arrow-right-s-line';
 import RiArrowUpLine from '~icons/ri/arrow-up-line';
+import RiArrowUpSLine from '~icons/ri/arrow-up-s-line';
 import RiBracesLine from '~icons/ri/braces-line';
 import RiCalendarCloseLine from '~icons/ri/calendar-close-line';
 import RiCalendarScheduleLine from '~icons/ri/calendar-schedule-line';
@@ -106,6 +108,7 @@ import RawKimiSetting from '~icons/kimi/setting?raw';
 // Raw SVG strings (Tabler) ----------------------------------------------------
 import RawTablerSidebarLeftCollapse from '~icons/tabler/layout-sidebar-left-collapse?raw';
 import RawTablerSidebarLeftExpand from '~icons/tabler/layout-sidebar-left-expand?raw';
+import RawTablerPaperclip from '~icons/tabler/paperclip?raw';
 
 // Raw SVG strings (Remix) ----------------------------------------------------
 import RawAddLine from '~icons/ri/add-line?raw';
@@ -117,6 +120,7 @@ import RawArrowGoBackLine from '~icons/ri/arrow-go-back-line?raw';
 import RawArrowRightLine from '~icons/ri/arrow-right-line?raw';
 import RawArrowRightSLine from '~icons/ri/arrow-right-s-line?raw';
 import RawArrowUpLine from '~icons/ri/arrow-up-line?raw';
+import RawArrowUpSLine from '~icons/ri/arrow-up-s-line?raw';
 import RawBracesLine from '~icons/ri/braces-line?raw';
 import RawCalendarCloseLine from '~icons/ri/calendar-close-line?raw';
 import RawCalendarScheduleLine from '~icons/ri/calendar-schedule-line?raw';
@@ -188,6 +192,7 @@ export type IconName =
   | 'log-in'
   | 'chevron-down'
   | 'chevron-right'
+  | 'chevron-up'
   | 'arrow-up'
   | 'arrow-down'
   | 'arrow-right'
@@ -208,6 +213,7 @@ export type IconName =
   | 'file-edit'
   | 'file-plus'
   | 'file-off'
+  | 'attachment'
   | 'image-off'
   | 'code'
   | 'terminal'
@@ -272,6 +278,7 @@ export const ICONS: Record<IconName, IconEntry> = {
   'log-in': entry(RiLoginBoxLine, RawLoginBoxLine),
   'chevron-down': entry(RiArrowDownSLine, RawArrowDownSLine),
   'chevron-right': entry(RiArrowRightSLine, RawArrowRightSLine),
+  'chevron-up': entry(RiArrowUpSLine, RawArrowUpSLine),
   'arrow-up': entry(RiArrowUpLine, RawArrowUpLine),
   'arrow-down': entry(RiArrowDownLine, RawArrowDownLine),
   'arrow-right': entry(RiArrowRightLine, RawArrowRightLine),
@@ -292,6 +299,7 @@ export const ICONS: Record<IconName, IconEntry> = {
   'file-edit': entry(RiFileEditLine, RawFileEditLine),
   'file-plus': entry(RiFileAddLine, RawFileAddLine),
   'file-off': entry(RiFileLine, RawFileLine),
+  attachment: entry(TablerPaperclip, RawTablerPaperclip),
   'image-off': entry(RiImageLine, RawImageLine),
   code: entry(RiCodeLine, RawCodeLine),
   terminal: entry(RiTerminalBoxLine, RawTerminalBoxLine),
@@ -347,6 +355,7 @@ export const ICON_GROUPS: ReadonlyArray<readonly [string, readonly IconName[]]>
     'Actions',
     [
       'plus',
+      'attachment',
       'chat-new',
       'close',
       'check',
@@ -368,6 +377,7 @@ export const ICON_GROUPS: ReadonlyArray<readonly [string, readonly IconName[]]>
     [
       'chevron-down',
       'chevron-right',
+      'chevron-up',
       'arrow-up',
       'arrow-down',
       'arrow-right',
diff --git a/apps/kimi-web/src/lib/mergeWorkspaces.ts b/apps/kimi-web/src/lib/mergeWorkspaces.ts
index 68a0925e9..c9a0e2504 100644
--- a/apps/kimi-web/src/lib/mergeWorkspaces.ts
+++ b/apps/kimi-web/src/lib/mergeWorkspaces.ts
@@ -24,10 +24,6 @@ export interface MergeWorkspacesInput {
   sessions: Pick<AppSession, 'id' | 'cwd' | 'workspaceId'>[];
   /** Root paths the user removed from the sidebar. */
   hiddenWorkspaceRoots: string[];
-  /** cwd of the active session, used to hint the branch on the active workspace. */
-  activeRoot: string | undefined;
-  /** Live git branch of the active session, or null when unknown. */
-  activeBranch: string | null;
   /** Per-workspace "server has more sessions" flag; false means the local
    *  session count is exact. */
   sessionsHasMoreByWorkspace: Record<string, boolean>;
@@ -43,8 +39,6 @@ export function mergeWorkspaces(input: MergeWorkspacesInput): AppWorkspace[] {
     workspaces,
     sessions,
     hiddenWorkspaceRoots,
-    activeRoot,
-    activeBranch,
     sessionsHasMoreByWorkspace,
   } = input;
 
@@ -73,7 +67,6 @@ export function mergeWorkspaces(input: MergeWorkspacesInput): AppWorkspace[] {
         id: s.workspaceId ?? root,
         root,
         name: basename(root),
-        isGitRepo: false,
         sessionCount: 0,
       });
     }
@@ -111,9 +104,7 @@ export function mergeWorkspaces(input: MergeWorkspacesInput): AppWorkspace[] {
       sessionsHasMoreByWorkspace[w.id] === false
         ? localCount
         : Math.max(w.sessionCount, localCount);
-    let branch = w.branch;
-    if (!branch && activeBranch && activeRoot === w.root) branch = activeBranch;
-    result.push({ ...w, sessionCount: count, branch });
+    result.push({ ...w, sessionCount: count });
   }
   return result;
 }
diff --git a/apps/kimi-web/src/lib/modelThinking.test.ts b/apps/kimi-web/src/lib/modelThinking.test.ts
index eca0fef15..e3d068a7f 100644
--- a/apps/kimi-web/src/lib/modelThinking.test.ts
+++ b/apps/kimi-web/src/lib/modelThinking.test.ts
@@ -237,7 +237,6 @@ describe('useModelProviderState thinking on model selection', () => {
       refreshSessionStatus: vi.fn().mockResolvedValue(undefined),
       persistSessionProfile: vi.fn().mockResolvedValue(undefined),
       activity: computed(() => 'idle'),
-      inFlightPromptSessions: new Set(),
       saveThinkingToStorage: vi.fn(),
       updateSession: (id, update) => {
         state.sessions = state.sessions.map((session) =>
diff --git a/apps/kimi-web/src/lib/openFileAttachment.ts b/apps/kimi-web/src/lib/openFileAttachment.ts
new file mode 100644
index 000000000..8cbde37a1
--- /dev/null
+++ b/apps/kimi-web/src/lib/openFileAttachment.ts
@@ -0,0 +1,82 @@
+// apps/kimi-web/src/lib/openFileAttachment.ts
+// Open a generic file attachment in a new tab — but ONLY types the browser
+// renders inertly (the whitelist below). A blob: URL inherits this origin, so
+// navigating a tab to an active document (HTML/SVG/JS/XML) would execute its
+// scripts with the app's credentials (the daemon token lives in localStorage)
+// and a live window.opener. Bytes come through the API client with auth — a
+// bare getFileUrl src 401s under daemon auth.
+
+import { getKimiWebApi } from '../api';
+
+// Navigating to these types cannot execute content: the PDF viewer is
+// sandboxed, media elements don't run scripts, and these image formats can't
+// carry any (SVG can — it is excluded on purpose).
+const SAFE_PREVIEW_MIME_RE =
+  /^(application\/pdf|image\/(png|jpe?g|gif|webp|avif|bmp|x-icon|vnd\.microsoft\.icon)|video\/[\w.+-]+|audio\/[\w.+-]+)$/i;
+
+// Everything under text/ renders as source when forced to text/plain — EXCEPT
+// text/html, which is an active document. When the recorded MIME is empty or
+// untrusted-looking, these extensions still preview, always as text/plain.
+const TEXT_PREVIEW_EXT_RE =
+  /^(txt|md|markdown|log|json|ya?ml|csv|tsv|ts|mts|tsx|jsx|css|py|go|rs|java|c|h|cc|cpp|hpp|sh|zsh|sql|toml|ini|cfg|conf|vue)$/i;
+const IMAGE_PREVIEW_EXT_RE = /^(png|jpe?g|gif|webp|avif|bmp|ico)$/i;
+
+const TEXT_PLAIN = 'text/plain;charset=utf-8';
+
+export type OpenFileAttachmentResult = 'previewed' | 'unsupported' | 'failed';
+
+/**
+ * The MIME to stamp on the preview blob when this attachment may open in a
+ * tab, or null when it must never be previewed. The returned MIME always
+ * comes from the whitelist — for text it is pinned to text/plain — so the
+ * navigation stays inert no matter what content-type was recorded at upload.
+ */
+function safePreviewMime(name: string | undefined, mediaType: string | undefined): string | null {
+  const mime = (mediaType ?? '').toLowerCase();
+  if (SAFE_PREVIEW_MIME_RE.test(mime)) return mime;
+  if (mime.startsWith('text/')) return mime === 'text/html' ? null : TEXT_PLAIN;
+  const ext = name?.match(/\.([A-Za-z0-9]{1,8})$/)?.[1]?.toLowerCase();
+  if (ext === undefined) return null;
+  if (TEXT_PREVIEW_EXT_RE.test(ext)) return TEXT_PLAIN;
+  if (IMAGE_PREVIEW_EXT_RE.test(ext)) return `image/${ext === 'jpg' ? 'jpeg' : ext === 'ico' ? 'x-icon' : ext}`;
+  if (ext === 'pdf') return 'application/pdf';
+  return null;
+}
+
+/**
+ * Preview a whitelisted file attachment in a new tab; anything else reports
+ * 'unsupported' so the caller can tell the user the type can't be opened.
+ * The tab is opened synchronously with the click (popup blockers reject
+ * window.open after an await), and a blocked popup falls back to a download.
+ */
+export async function openFileAttachment(
+  fileId: string,
+  name?: string,
+  mediaType?: string,
+): Promise<OpenFileAttachmentResult> {
+  const previewMime = safePreviewMime(name, mediaType);
+  if (previewMime === null) return 'unsupported';
+  // noopener can't go into window.open — it forfeits the handle we need to
+  // navigate after the async fetch. Sever the opener right away instead; the
+  // whitelist is what actually keeps the new tab inert.
+  const win = window.open('', '_blank');
+  if (win !== null) win.opener = null;
+  const blob = await getKimiWebApi().getFileBlob(fileId).catch(() => null);
+  if (blob === null) {
+    win?.close();
+    return 'failed';
+  }
+  const url = URL.createObjectURL(new Blob([blob], { type: previewMime }));
+  if (win !== null) {
+    win.location.href = url;
+  } else {
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = name ?? fileId;
+    a.click();
+  }
+  setTimeout(() => {
+    URL.revokeObjectURL(url);
+  }, 60_000);
+  return 'previewed';
+}
diff --git a/apps/kimi-web/src/lib/taskMerge.ts b/apps/kimi-web/src/lib/taskMerge.ts
index 17a766076..d3c41b986 100644
--- a/apps/kimi-web/src/lib/taskMerge.ts
+++ b/apps/kimi-web/src/lib/taskMerge.ts
@@ -14,11 +14,51 @@ import type { AppTask } from '../api/types';
  *
  * Keep WS-owned subagent tasks that REST omits, so the REST refresh only governs
  * background tasks. REST stays authoritative for anything it does return.
+ *
+ * One exception: REST DOES return background subagents — keyed by their
+ * background-task id, while the WS stream keys the same agent by agent id
+ * (`backgroundTaskId` links the two, set from the `task.started`
+ * registration). Fold the REST copy into the WS-owned row so one agent does
+ * not surface as two rows; REST still corrects a terminal status the WS row
+ * may have missed while disconnected.
  */
 export function keepLiveSubagents(restBased: AppTask[], existing: AppTask[]): AppTask[] {
   const restIds = new Set(restBased.map((t) => t.id));
   const liveSubagents = existing.filter((t) => t.kind === 'subagent' && !restIds.has(t.id));
-  return liveSubagents.length === 0 ? restBased : [...restBased, ...liveSubagents];
+  if (liveSubagents.length === 0) return restBased;
+  const restById = new Map(restBased.map((t) => [t.id, t] as const));
+  const foldedRestIds = new Set<string>();
+  const merged = liveSubagents.map((live) => {
+    const rest =
+      live.backgroundTaskId !== undefined ? restById.get(live.backgroundTaskId) : undefined;
+    if (rest === undefined) return live;
+    foldedRestIds.add(rest.id);
+    // True when the fold — not the event stream — is what makes the row terminal.
+    const restCompletesLiveRow = live.status === 'running' && rest.status !== 'running';
+    return {
+      ...live,
+      // Terminal-stickiness: never let a lagging poll flip a finished row back
+      // to running, but let REST complete a row whose finish event was missed.
+      status: live.status === 'running' ? rest.status : live.status,
+      // toAgentMember prefers subagentPhase over status, so sync it too —
+      // otherwise the detail panel badge keeps showing a stale Working/Queued.
+      // The phase enum has no 'cancelled'; the dock already styles cancelled
+      // rows as failed.
+      subagentPhase: restCompletesLiveRow
+        ? rest.status === 'completed'
+          ? 'completed'
+          : 'failed'
+        : live.subagentPhase,
+      completedAt: live.completedAt ?? rest.completedAt,
+      // REST output is authoritative once present: agent tasks persist their
+      // result at completion, and a previously folded preview would otherwise
+      // freeze the detail panel's Result.
+      outputPreview: rest.outputPreview ?? live.outputPreview,
+      outputBytes: rest.outputBytes ?? live.outputBytes,
+    };
+  });
+  const rest = restBased.filter((t) => !foldedRestIds.has(t.id));
+  return [...rest, ...merged];
 }
 
 /**
diff --git a/apps/kimi-web/src/style.css b/apps/kimi-web/src/style.css
index 2f39b0473..da20f8073 100644
--- a/apps/kimi-web/src/style.css
+++ b/apps/kimi-web/src/style.css
@@ -211,6 +211,25 @@ summary {
   color-scheme: light dark;
 }
 
+/* Safe-area insets + chat-dock metrics ---------------------------------------
+   Centralised so mobile layout reads one consistent source instead of each
+   component calling env(safe-area-inset-*) with its own fallback. Falls back to
+   0px where the UA doesn't expose insets (most desktops, older Android);
+   pair with max(min, var(--safe-bottom)) so gestures / home indicators keep a
+   minimum gutter even when the inset reports 0. The mobile footer (composer),
+   bottom sheets and the toast layer all consume these. */
+:root {
+  --safe-top: env(safe-area-inset-top, 0px);
+  --safe-right: env(safe-area-inset-right, 0px);
+  --safe-bottom: env(safe-area-inset-bottom, 0px);
+  --safe-left: env(safe-area-inset-left, 0px);
+  /* Border-box height of the chat dock, written by ChatDock via ResizeObserver.
+     Used to anchor fixed overlays (toasts, floating hints) just above the
+     composer — dynamic so multi-line input growth keeps them clear. Left
+     undeclared on purpose: consumers use a fallback (e.g. the assumed
+     single-line dock height) on pages where ChatDock is not mounted. */
+}
+
 /* -- icon primitive (design-system §02) -------------------------------------
    Applied to every design-system icon: the <Icon> component output
    (components/ui/Icon.vue) and the iconSvg() v-html strings (lib/icons.ts).
diff --git a/apps/kimi-web/src/types.ts b/apps/kimi-web/src/types.ts
index c94a705aa..766f11842 100644
--- a/apps/kimi-web/src/types.ts
+++ b/apps/kimi-web/src/types.ts
@@ -1,9 +1,4 @@
 // apps/kimi-web/src/types.ts
-import type { AppSessionStatus } from './api/types';
-
-/** Real session lifecycle status (5 states), surfaced verbatim to the UI so the
-    list can distinguish awaiting / aborted instead of collapsing to running|idle. */
-export type SessionStatus = AppSessionStatus;
 
 /** File content loaded for preview (text or base64-encoded binary). */
 export interface FileData {
@@ -28,12 +23,16 @@ export interface Session {
   id: string;
   title: string;
   time: string;
-  status: SessionStatus;
-  /** True only when the session should show a "working" spinner: it is
-      `running` AND has a real task in flight. Awaiting-input and aborted are
-      NOT busy, so the spinner no longer spins while the session waits on the
-      user. (Distinct from `status`, which is the lifecycle label.) */
+  /** True while the session shows a "working" indicator — the unified
+      condition shared by the sidebar spinner, the chat moon, and the Stop
+      button: a prompt submitted but not yet terminated, or a main turn in
+      flight. Background tasks and subagent turns do NOT set it. */
   busy: boolean;
+  /** List-level fallback for action-required badges on unopened sessions. */
+  pendingInteraction?: 'none' | 'approval' | 'question';
+  /** Main agent's latest turn outcome — drives the "aborted" tag when the
+      session is quiet and the last turn was cancelled/failed. */
+  lastTurnReason?: 'completed' | 'cancelled' | 'failed';
   /** ISO timestamp for recency-based filtering (e.g. default visible sessions). */
   updatedAt?: string;
   /** Text of the most recent user prompt, used by sidebar search. */
@@ -61,8 +60,6 @@ export interface WorkspaceView {
   root: string;
   /** Home-shortened path for dim display, e.g. `~/code/kimi-code-web`. */
   shortPath: string;
-  /** Current branch, when known. */
-  branch?: string;
   /** Number of sessions in this workspace. */
   sessionCount: number;
 }
@@ -231,6 +228,18 @@ export type TurnBlock =
   | { kind: 'thinking'; thinking: string }
   | { kind: 'tool'; tool: ToolCall };
 
+/** One attachment on a user turn: an uploaded file, image or video. Images
+    and pasted media carry no name; the chip falls back to a generic label.
+    `url` is browser-loadable (a data URL, or the authed file URL). */
+export interface TurnAttachment {
+  kind: 'image' | 'video' | 'file';
+  url: string;
+  fileId?: string;
+  name?: string;
+  mediaType?: string;
+  size?: number;
+}
+
 export interface ChatTurn {
   id: string;
   role: TurnRole;
@@ -244,8 +253,9 @@ export interface ChatTurn {
   blocks?: TurnBlock[];
   approval?: ApprovalBlock;
   approvalId?: string; // daemon approval id — present when approval needs a decision
-  /** Image attachments sent by the user (rendered above the text bubble). */
-  images?: { url: string; alt?: string; kind: 'image' | 'video'; fileId?: string }[];
+  /** Attachments sent by the user — files, images and videos, rendered as a
+      chip row above the text bubble. */
+  attachments?: TurnAttachment[];
   /** Compaction divider data (role 'compaction'): the transcript keeps all
       prior turns and renders this as a separator line; `text` holds the
       LLM-generated summary, opened in the right-side panel on click. */
@@ -338,10 +348,11 @@ export interface ActivationBadges {
 /** A queued prompt as shown inline at the tail of the transcript. */
 export interface QueuedPromptView {
   text: string;
-  /** Number of image attachments waiting with this prompt. */
+  /** Number of attachments waiting with this prompt. */
   attachmentCount: number;
-  /** Image/video attachments waiting with this prompt, with resolved URLs for thumbnails. */
-  attachments?: { fileId: string; kind: 'image' | 'video'; url: string }[];
+  /** Attachments waiting with this prompt, with resolved URLs for thumbnails
+      (file attachments render an icon chip, no thumbnail). */
+  attachments?: { fileId: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[];
 }
 
 /** Horizontal alignment of the conversation reading column within the pane. */
diff --git a/apps/kimi-web/src/views/DesignSystemView.vue b/apps/kimi-web/src/views/DesignSystemView.vue
index 16fde8bdc..0ae989786 100644
--- a/apps/kimi-web/src/views/DesignSystemView.vue
+++ b/apps/kimi-web/src/views/DesignSystemView.vue
@@ -1449,7 +1449,7 @@ onUnmounted(() => {
               <tbody>
                 <tr><td>Width / cursor</td><td>4px / <code>col-resize</code></td></tr>
                 <tr><td>Normal / active</td><td>transparent / <code>accent</code> fill</td></tr>
-                <tr><td>Layer</td><td><code>--z-sticky</code>, over the column border</td></tr>
+                <tr><td>Layer</td><td><code>--z-dropdown</code>, above pane-level sticky chrome (chat dock at <code>--z-sticky</code>) so the overhang stays visible and grabbable</td></tr>
                 <tr><td>Behavior</td><td>panel width follows the pointer 1:1 while dragging (the parent disables transitions to avoid lag); on release it is persisted to localStorage</td></tr>
               </tbody>
             </table>
diff --git a/apps/kimi-web/test/agent-event-projector.test.ts b/apps/kimi-web/test/agent-event-projector.test.ts
index 36bf5ec58..763e2fe2b 100644
--- a/apps/kimi-web/test/agent-event-projector.test.ts
+++ b/apps/kimi-web/test/agent-event-projector.test.ts
@@ -85,7 +85,14 @@ describe('agent error projection', () => {
     expect(
       projector.project(
         'error',
-        { agentId: 'main', code: 'provider.rate_limit', message: 'Rate limited' },
+        {
+          agentId: 'main',
+          code: 'provider.rate_limit',
+          message: 'Rate limited',
+          name: 'RateLimitError',
+          details: { statusCode: 429, requestId: 'req_1' },
+          retryable: true,
+        },
         's1',
       ),
     ).toEqual([
@@ -95,6 +102,9 @@ describe('agent error projection', () => {
           _agentError: true,
           code: 'provider.rate_limit',
           message: 'Rate limited',
+          name: 'RateLimitError',
+          details: { statusCode: 429, requestId: 'req_1' },
+          retryable: true,
         },
       },
     ]);
@@ -175,18 +185,18 @@ describe('classifyFrame cron.fired', () => {
   });
 });
 
-// Session status has a single source: the daemon's event.session.status_changed
+// Session busy has a single source: the daemon's event.session.work_changed
 // (mapped by toAppEvent). The raw turn stream must NOT project a second
-// sessionStatusChanged per transition — when it did, every turn end fired
+// sessionWorkChanged per transition — when it did, every turn end fired
 // turn-end consumers (completion notification, sound) twice.
 describe('session status single-sourcing', () => {
-  it('turn.started projects no sessionStatusChanged', () => {
+  it('turn.started projects no sessionWorkChanged', () => {
     const projector = createAgentProjector();
     const events = projector.project('turn.started', { turnId: 1 }, 's1');
-    expect(events.some((e) => e.type === 'sessionStatusChanged')).toBe(false);
+    expect(events.some((e) => e.type === 'sessionWorkChanged')).toBe(false);
   });
 
-  it('turn.ended finalizes the message and usage but projects no sessionStatusChanged', () => {
+  it('turn.ended finalizes the message and usage but projects no sessionWorkChanged', () => {
     const projector = createAgentProjector();
     projector.project('turn.started', { turnId: 1 }, 's1');
     projector.project('turn.step.started', { turnId: 1, step: 1 }, 's1');
@@ -195,7 +205,7 @@ describe('session status single-sourcing', () => {
       { turnId: 1, reason: 'completed', durationMs: 123 },
       's1',
     );
-    expect(events.some((e) => e.type === 'sessionStatusChanged')).toBe(false);
+    expect(events.some((e) => e.type === 'sessionWorkChanged')).toBe(false);
     expect(events).toContainEqual(
       expect.objectContaining({ type: 'messageUpdated', status: 'completed', durationMs: 123 }),
     );
@@ -210,7 +220,7 @@ describe('session status single-sourcing', () => {
       thinkingText: '',
       runningTools: [],
     });
-    expect(events.some((e) => e.type === 'sessionStatusChanged')).toBe(false);
+    expect(events.some((e) => e.type === 'sessionWorkChanged')).toBe(false);
     expect(events).toContainEqual(
       expect.objectContaining({
         type: 'messageCreated',
@@ -220,6 +230,73 @@ describe('session status single-sourcing', () => {
   });
 });
 
+describe('main-turn liveness projection', () => {
+  it('turn.started marks the main conversation active', () => {
+    const projector = createAgentProjector();
+    const events = projector.project('turn.started', { agentId: 'main', turnId: 1 }, 's1');
+    expect(events).toContainEqual({ type: 'turnActiveChanged', sessionId: 's1', active: true });
+  });
+
+  it('turn.ended clears it and carries the reason', () => {
+    const projector = createAgentProjector();
+    projector.project('turn.started', { agentId: 'main', turnId: 1 }, 's1');
+    const events = projector.project('turn.ended', { agentId: 'main', turnId: 1, reason: 'cancelled' }, 's1');
+    expect(events).toContainEqual({
+      type: 'turnActiveChanged',
+      sessionId: 's1',
+      active: false,
+      reason: 'cancelled',
+    });
+  });
+
+  it('subagent turn boundaries never touch main-conversation liveness', () => {
+    const projector = createAgentProjector();
+    const started = projector.project('turn.started', { agentId: 'agent-2', turnId: 1 }, 's1');
+    const ended = projector.project('turn.ended', { agentId: 'agent-2', turnId: 1, reason: 'completed' }, 's1');
+    expect([...started, ...ended].some((e) => e.type === 'turnActiveChanged')).toBe(false);
+  });
+});
+
+describe('prompt-level lifecycle projection', () => {
+  it('prompt.completed carries promptId and reason for the sending-flag cleanup', () => {
+    const projector = createAgentProjector();
+    const events = projector.project(
+      'prompt.completed',
+      { agentId: 'main', promptId: 'msg_1', reason: 'blocked', finishedAt: '2026-01-01T00:00:00Z' },
+      's1',
+    );
+    expect(events).toContainEqual({
+      type: 'promptCompleted',
+      sessionId: 's1',
+      promptId: 'msg_1',
+      reason: 'blocked',
+    });
+  });
+
+  it('prompt.aborted projects a promptAborted keyed by promptId', () => {
+    const projector = createAgentProjector();
+    const events = projector.project(
+      'prompt.aborted',
+      { agentId: 'main', promptId: 'msg_2', abortedAt: '2026-01-01T00:00:00Z' },
+      's1',
+    );
+    expect(events).toContainEqual({ type: 'promptAborted', sessionId: 's1', promptId: 'msg_2' });
+  });
+
+  it('subagent-scoped prompt.aborted stays out of the main prompt channel', () => {
+    const projector = createAgentProjector();
+    const events = projector.project('prompt.aborted', { agentId: 'agent-2', promptId: 'msg_3' }, 's1');
+    expect(events.some((e) => e.type === 'promptAborted')).toBe(false);
+  });
+
+  it('classifyFrame routes prompt.aborted to the agent projector', () => {
+    expect(classifyFrame('prompt.aborted', { promptId: 'msg_1' })).toEqual({
+      route: 'agent',
+      agentType: 'prompt.aborted',
+    });
+  });
+});
+
 describe('step-boundary delta alignment', () => {
   it('resets stream offsets at step boundaries — a post-step delta ahead of local state signals a gap', () => {
     const projector = createAgentProjector();
@@ -296,3 +373,210 @@ describe('step-boundary delta alignment', () => {
     );
   });
 });
+
+describe('turn.step.retrying bubble reuse', () => {
+  it('refills the abandoned bubble instead of stacking a duplicate one', () => {
+    const projector = createAgentProjector();
+    const sid = 's1';
+    projector.project('turn.started', { type: 'turn.started', turnId: 1, origin: { kind: 'user' }, agentId: 'main', sessionId: sid }, sid);
+    projector.project('turn.step.started', { type: 'turn.step.started', turnId: 1, step: 1, agentId: 'main', sessionId: sid }, sid);
+    projector.project('assistant.delta', { type: 'assistant.delta', turnId: 1, delta: 'AB', agentId: 'main', sessionId: sid }, sid, { offset: 0 });
+    projector.project('tool.call.started', { type: 'tool.call.started', turnId: 1, toolCallId: 'tc1', name: 'Bash', agentId: 'main', sessionId: sid }, sid);
+
+    const retryEvents = projector.project('turn.step.retrying', { type: 'turn.step.retrying', turnId: 1, step: 1, failedAttempt: 1, nextAttempt: 2, maxAttempts: 10, delayMs: 100, agentId: 'main', sessionId: sid }, sid);
+    expect(retryEvents).toContainEqual(expect.objectContaining({ type: 'messageUpdated' }));
+
+    const restarted = projector.project('turn.step.started', { type: 'turn.step.started', turnId: 1, step: 1, agentId: 'main', sessionId: sid }, sid);
+    // No new messageCreated for the retried step — the cleared bubble is reused.
+    expect(restarted.filter((e) => e.type === 'messageCreated')).toEqual([]);
+
+    const deltas = projector.project('assistant.delta', { type: 'assistant.delta', turnId: 1, delta: 'ABC', agentId: 'main', sessionId: sid }, sid, { offset: 0 });
+    const toolEvents = projector.project('tool.call.started', { type: 'tool.call.started', turnId: 1, toolCallId: 'tc1', name: 'Bash', agentId: 'main', sessionId: sid }, sid);
+
+    // The same bubble receives the retried stream: exactly one assistant
+    // message id across the whole attempt→retry sequence.
+    const messageIds = new Set(
+      [...deltas, ...toolEvents]
+        .map((e) => (e as { messageId?: string }).messageId)
+        .filter((id): id is string => typeof id === 'string'),
+    );
+    expect(messageIds.size).toBe(1);
+  });
+
+  it('drops the reuse target when the turn ends before the retried step starts', () => {
+    const projector = createAgentProjector();
+    const sid = 's1';
+    projector.project('turn.started', { type: 'turn.started', turnId: 1, origin: { kind: 'user' }, agentId: 'main', sessionId: sid }, sid);
+    projector.project('turn.step.started', { type: 'turn.step.started', turnId: 1, step: 1, agentId: 'main', sessionId: sid }, sid);
+    projector.project('assistant.delta', { type: 'assistant.delta', turnId: 1, delta: 'AB', agentId: 'main', sessionId: sid }, sid, { offset: 0 });
+    projector.project('turn.step.retrying', { type: 'turn.step.retrying', turnId: 1, step: 1, failedAttempt: 1, nextAttempt: 2, maxAttempts: 10, delayMs: 100, agentId: 'main', sessionId: sid }, sid);
+
+    // The user aborts before the retried step.started ever arrives.
+    projector.project('turn.ended', { type: 'turn.ended', turnId: 1, reason: 'interrupted', agentId: 'main', sessionId: sid }, sid);
+
+    // The next prompt must open a fresh bubble — not refill the emptied one,
+    // which would render the new response under the previous prompt.
+    projector.project('turn.started', { type: 'turn.started', turnId: 2, origin: { kind: 'user' }, agentId: 'main', sessionId: sid }, sid);
+    const started = projector.project('turn.step.started', { type: 'turn.step.started', turnId: 2, step: 1, agentId: 'main', sessionId: sid }, sid);
+    expect(started.filter((e) => e.type === 'messageCreated')).toHaveLength(1);
+  });
+
+  it('drops the reuse target when the step is interrupted before the retry restarts', () => {
+    const projector = createAgentProjector();
+    const sid = 's1';
+    projector.project('turn.started', { type: 'turn.started', turnId: 1, origin: { kind: 'user' }, agentId: 'main', sessionId: sid }, sid);
+    projector.project('turn.step.started', { type: 'turn.step.started', turnId: 1, step: 1, agentId: 'main', sessionId: sid }, sid);
+    projector.project('assistant.delta', { type: 'assistant.delta', turnId: 1, delta: 'AB', agentId: 'main', sessionId: sid }, sid, { offset: 0 });
+    projector.project('turn.step.retrying', { type: 'turn.step.retrying', turnId: 1, step: 1, failedAttempt: 1, nextAttempt: 2, maxAttempts: 10, delayMs: 100, agentId: 'main', sessionId: sid }, sid);
+
+    projector.project('turn.step.interrupted', { type: 'turn.step.interrupted', turnId: 1, step: 1, agentId: 'main', sessionId: sid }, sid);
+
+    // The next step.started creates a new bubble instead of reusing the
+    // emptied one left by the interrupted retry attempt.
+    const started = projector.project('turn.step.started', { type: 'turn.step.started', turnId: 1, step: 2, agentId: 'main', sessionId: sid }, sid);
+    expect(started.filter((e) => e.type === 'messageCreated')).toHaveLength(1);
+  });
+});
+
+describe('background subagent task registration', () => {
+  it('folds task.started (kind agent) into the spawned row instead of adding a second row', () => {
+    const projector = createAgentProjector();
+    projector.project(
+      'subagent.spawned',
+      { subagentId: 'agent-1', description: 'Explore repo', runInBackground: true },
+      's1',
+    );
+
+    const events = projector.project(
+      'task.started',
+      {
+        info: {
+          taskId: 'task-9',
+          kind: 'agent',
+          detached: true,
+          agentId: 'agent-1',
+          description: 'Explore repo',
+          startedAt: 1767225600000,
+        },
+      },
+      's1',
+    );
+
+    // A single patch of the WS-owned row — never a second (bash) task row.
+    expect(events).toEqual([
+      {
+        type: 'taskCreated',
+        sessionId: 's1',
+        task: expect.objectContaining({
+          id: 'agent-1',
+          kind: 'subagent',
+          description: 'Explore repo',
+          runInBackground: true,
+          backgroundTaskId: 'task-9',
+        }),
+      },
+    ]);
+  });
+
+  it('keys a late registration by agent id so later progress frames stay on one row', () => {
+    const projector = createAgentProjector();
+    const events = projector.project(
+      'task.started',
+      {
+        info: {
+          taskId: 'task-9',
+          kind: 'agent',
+          detached: true,
+          agentId: 'agent-1',
+          description: 'Explore repo',
+          startedAt: 1767225600000,
+        },
+      },
+      's1',
+    );
+
+    expect(events).toEqual([
+      {
+        type: 'taskCreated',
+        sessionId: 's1',
+        task: expect.objectContaining({
+          id: 'agent-1',
+          kind: 'subagent',
+          description: 'Explore repo',
+          runInBackground: true,
+          backgroundTaskId: 'task-9',
+        }),
+      },
+    ]);
+
+    // A later agent-scoped progress frame must not synthesize a second row.
+    const progress = projector.project(
+      'assistant.delta',
+      { agentId: 'agent-1', delta: 'Hi' },
+      's1',
+    );
+    expect(progress).toContainEqual(
+      expect.objectContaining({ type: 'taskProgress', taskId: 'agent-1' }),
+    );
+    const created = progress.filter((e) => e.type === 'taskCreated');
+    expect(created).toHaveLength(1);
+    expect(created[0]).toMatchObject({
+      task: { id: 'agent-1', backgroundTaskId: 'task-9' },
+    });
+  });
+
+  it('falls back to the task id when the registration carries no agent id', () => {
+    const projector = createAgentProjector();
+    const events = projector.project(
+      'task.started',
+      {
+        info: {
+          taskId: 'task-9',
+          kind: 'agent',
+          detached: true,
+          description: 'Explore repo',
+          startedAt: 1767225600000,
+        },
+      },
+      's1',
+    );
+
+    expect(events).toEqual([
+      {
+        type: 'taskCreated',
+        sessionId: 's1',
+        task: expect.objectContaining({
+          id: 'task-9',
+          kind: 'subagent',
+          description: 'Explore repo',
+          runInBackground: true,
+        }),
+      },
+    ]);
+  });
+
+  it('keeps projecting process tasks as bash rows', () => {
+    const projector = createAgentProjector();
+    const events = projector.project(
+      'task.started',
+      {
+        info: {
+          taskId: 'task-1',
+          kind: 'process',
+          description: 'npm test',
+          command: 'npm test',
+          startedAt: 1767225600000,
+        },
+      },
+      's1',
+    );
+
+    expect(events).toEqual([
+      {
+        type: 'taskCreated',
+        sessionId: 's1',
+        task: expect.objectContaining({ id: 'task-1', kind: 'bash', command: 'npm test' }),
+      },
+    ]);
+  });
+});
diff --git a/apps/kimi-web/test/attachment-upload.test.ts b/apps/kimi-web/test/attachment-upload.test.ts
index 799eaf561..6c5ed9b75 100644
--- a/apps/kimi-web/test/attachment-upload.test.ts
+++ b/apps/kimi-web/test/attachment-upload.test.ts
@@ -53,11 +53,31 @@ describe('useAttachmentUpload', () => {
     expect(createObjectURL).toHaveBeenCalledOnce();
   });
 
-  it('ignores non-media files', () => {
+  it('accepts a non-media file as a file attachment without a thumbnail object URL', () => {
+    const uploadImage = vi.fn<UploadImage>().mockResolvedValue({ fileId: 'f1', name: 'a.pdf', mediaType: 'application/pdf' });
+    const att = setup(uploadImage);
+    att.handleFileInputChange(inputEvent([{ name: 'a.pdf', type: 'application/pdf' } as unknown as File]));
+
+    expect(att.attachments.value).toHaveLength(1);
+    expect(att.attachments.value[0]).toMatchObject({
+      name: 'a.pdf',
+      kind: 'file',
+      mediaType: 'application/pdf',
+      uploading: true,
+    });
+    // No thumbnail for generic files — the chip renders an icon instead.
+    expect(att.attachments.value[0].previewUrl).toBeUndefined();
+    expect(createObjectURL).not.toHaveBeenCalled();
+  });
+
+  it('accepts a file with an empty MIME type as a file attachment', () => {
     const uploadImage = vi.fn<UploadImage>().mockResolvedValue(null);
     const att = setup(uploadImage);
-    att.handleFileInputChange(inputEvent([{ name: 'a.txt', type: 'text/plain' } as unknown as File]));
-    expect(att.attachments.value).toHaveLength(0);
+    att.handleFileInputChange(inputEvent([{ name: 'Makefile', type: '' } as unknown as File]));
+    expect(att.attachments.value).toHaveLength(1);
+    expect(att.attachments.value[0].kind).toBe('file');
+    // The wire schema requires a non-empty media_type — '' must be normalized.
+    expect(att.attachments.value[0].mediaType).toBe('application/octet-stream');
   });
 
   it('is a no-op when uploadImage is not provided', () => {
@@ -66,6 +86,32 @@ describe('useAttachmentUpload', () => {
     expect(att.attachments.value).toHaveLength(0);
   });
 
+  it('removeAttachment on a file chip has no object URL to revoke', () => {
+    const uploadImage = vi.fn<UploadImage>().mockResolvedValue(null);
+    const att = setup(uploadImage);
+    att.handleFileInputChange(inputEvent([{ name: 'a.pdf', type: 'application/pdf' } as unknown as File]));
+    const localId = att.attachments.value[0].localId;
+
+    att.removeAttachment(localId);
+    expect(att.attachments.value).toHaveLength(0);
+    expect(revokeObjectURL).not.toHaveBeenCalled();
+  });
+
+  it('loadAttachments refills a file attachment without fetching a thumbnail', () => {
+    const att = setup(undefined);
+    att.loadAttachments([
+      { fileId: 'f_pdf', kind: 'file', url: 'https://example.test/api/v1/files/f_pdf', name: 'a.pdf' },
+    ]);
+    expect(att.attachments.value).toHaveLength(1);
+    expect(att.attachments.value[0]).toMatchObject({
+      fileId: 'f_pdf',
+      kind: 'file',
+      name: 'a.pdf',
+      uploading: false,
+    });
+    expect(att.attachments.value[0].previewUrl).toBeUndefined();
+  });
+
   it('removeAttachment drops the entry and revokes its object URL', () => {
     const uploadImage = vi.fn<UploadImage>().mockResolvedValue(null);
     const att = setup(uploadImage);
@@ -215,4 +261,56 @@ describe('useAttachmentUpload', () => {
     // B's attachment is gone from A's view.
     expect(att.attachments.value.map((a) => a.name)).not.toContain('b.png');
   });
+
+  it('adds dropped files once and stops the drop from bubbling to document handlers', () => {
+    const uploadImage = vi.fn<UploadImage>().mockResolvedValue(null);
+    const att = setup(uploadImage);
+    const file = { name: 'd.txt', type: 'text/plain' } as unknown as File;
+    const preventDefault = vi.fn();
+    const stopPropagation = vi.fn();
+
+    att.handleDrop({
+      dataTransfer: { files: [file] },
+      preventDefault,
+      stopPropagation,
+    } as unknown as DragEvent);
+
+    // The document-level drop listener must not see the same drop again —
+    // otherwise the file would be attached twice.
+    expect(preventDefault).toHaveBeenCalled();
+    expect(stopPropagation).toHaveBeenCalled();
+    expect(att.attachments.value).toHaveLength(1);
+    expect(att.attachments.value[0]).toMatchObject({ name: 'd.txt', kind: 'file' });
+  });
+
+  it('ignores a dragover that carries no files (e.g. text drag)', () => {
+    const uploadImage = vi.fn<UploadImage>().mockResolvedValue(null);
+    const att = setup(uploadImage);
+    const preventDefault = vi.fn();
+
+    att.handleDragOver({
+      dataTransfer: { items: [{ kind: 'string' }] },
+      preventDefault,
+      stopPropagation: vi.fn(),
+    } as unknown as DragEvent);
+
+    expect(preventDefault).not.toHaveBeenCalled();
+    expect(att.isDragOver.value).toBe(false);
+  });
+
+  it('skips a file attachment with no fileId and an empty URL instead of fetching it', async () => {
+    // The non-clickable chip rebuilt from an inline-base64 notice has neither —
+    // fetch('') would resolve to the current page and upload the web app HTML.
+    const uploadImage = vi.fn<UploadImage>().mockResolvedValue(null);
+    const fetchSpy = vi.spyOn(globalThis, 'fetch');
+    const att = setup(uploadImage);
+
+    att.loadAttachments([{ kind: 'file', url: '', name: 'image.avif' }]);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(att.attachments.value).toHaveLength(0);
+    // No fetch with the empty URL (a same-document fetch would upload the page).
+    expect(fetchSpy.mock.calls.every((call) => call[0] !== '')).toBe(true);
+    fetchSpy.mockRestore();
+  });
 });
diff --git a/apps/kimi-web/test/chat-turn-rendering.test.ts b/apps/kimi-web/test/chat-turn-rendering.test.ts
index 77916465a..6538aa842 100644
--- a/apps/kimi-web/test/chat-turn-rendering.test.ts
+++ b/apps/kimi-web/test/chat-turn-rendering.test.ts
@@ -25,13 +25,13 @@ function assistantTurn(blocks: TurnBlock[], over: Partial<ChatTurn> = {}): ChatT
 }
 
 describe('formatTokens', () => {
-  it('keeps small counts verbatim and abbreviates at the k / M thresholds', () => {
+  it('keeps counts under 1024 verbatim and uses 1024-based k / M units', () => {
     expect(formatTokens(0)).toBe('0');
     expect(formatTokens(999)).toBe('999');
-    expect(formatTokens(1000)).toBe('1.0k');
+    expect(formatTokens(1000)).toBe('1000');
     expect(formatTokens(1500)).toBe('1.5k');
-    expect(formatTokens(1_000_000)).toBe('1.0M');
-    expect(formatTokens(2_500_000)).toBe('2.5M');
+    expect(formatTokens(1_000_000)).toBe('977k');
+    expect(formatTokens(2_500_000)).toBe('2.4M');
   });
 });
 
diff --git a/apps/kimi-web/test/confirm-dialog.test.ts b/apps/kimi-web/test/confirm-dialog.test.ts
new file mode 100644
index 000000000..b059b2244
--- /dev/null
+++ b/apps/kimi-web/test/confirm-dialog.test.ts
@@ -0,0 +1,141 @@
+// apps/kimi-web/test/confirm-dialog.test.ts
+// Logic tests for the useConfirmDialog singleton: boolean confirm/cancel,
+// supersede, and the async `action` flow (busy state, close-on-settle,
+// rejection propagation).
+import { beforeEach, describe, expect, it } from 'vitest';
+import { useConfirmDialog } from '../src/composables/useConfirmDialog';
+
+function deferred<T = void>(): {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (err?: unknown) => void;
+} {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (err?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+describe('useConfirmDialog', () => {
+  const { current, busy, confirm, settle, runAction } = useConfirmDialog();
+
+  beforeEach(() => {
+    // Drop any pending request so tests don't leak into each other.
+    settle(false);
+  });
+
+  it('resolves true on confirm without an action', async () => {
+    const p = confirm({ title: 'Archive?' });
+    expect(current.value?.title).toBe('Archive?');
+    await runAction();
+    expect(current.value).toBeNull();
+    await expect(p).resolves.toBe(true);
+  });
+
+  it('resolves false on cancel', async () => {
+    const p = confirm({ title: 'Archive?' });
+    settle(false);
+    expect(current.value).toBeNull();
+    await expect(p).resolves.toBe(false);
+  });
+
+  it('cancels a pending request when a new confirm supersedes it', async () => {
+    const first = confirm({ title: 'First' });
+    const second = confirm({ title: 'Second' });
+    await expect(first).resolves.toBe(false);
+    expect(current.value?.title).toBe('Second');
+    settle(true);
+    await expect(second).resolves.toBe(true);
+  });
+
+  it('keeps the dialog open (busy) while the action runs, then closes', async () => {
+    const action = deferred();
+    let ran = false;
+    const p = confirm({
+      title: 'Archive?',
+      action: async () => {
+        ran = true;
+        await action.promise;
+      },
+    });
+
+    void runAction();
+    expect(ran).toBe(true);
+    expect(busy.value).toBe(true);
+    // Still open while the action is in flight.
+    expect(current.value).not.toBeNull();
+    // Cancel is inert while busy.
+    settle(false);
+    expect(current.value).not.toBeNull();
+
+    action.resolve();
+    await p;
+    expect(busy.value).toBe(false);
+    expect(current.value).toBeNull();
+    await expect(p).resolves.toBe(true);
+  });
+
+  it('closes and rejects the confirm() promise when the action fails', async () => {
+    const failure = new Error('boom');
+    const p = confirm({
+      title: 'Archive?',
+      action: () => Promise.reject(failure),
+    });
+    // Attach the rejection expectation before running so no unhandled
+    // rejection can escape between ticks.
+    const assertion = expect(p).rejects.toBe(failure);
+    await runAction();
+    expect(busy.value).toBe(false);
+    expect(current.value).toBeNull();
+    await assertion;
+  });
+
+  it('ignores a duplicate confirm while an action is running', async () => {
+    const action = deferred();
+    let runs = 0;
+    const p = confirm({
+      title: 'Archive?',
+      action: async () => {
+        runs += 1;
+        await action.promise;
+      },
+    });
+    void runAction();
+    await runAction(); // no-op: busy
+    expect(runs).toBe(1);
+    action.resolve();
+    await p;
+  });
+
+  it('runAction without a pending request is a no-op', async () => {
+    expect(current.value).toBeNull();
+    await runAction();
+    expect(busy.value).toBe(false);
+  });
+
+  it('resolves a new confirm false instead of superseding while an action runs', async () => {
+    const action = deferred();
+    const first = confirm({
+      title: 'First',
+      action: () => action.promise,
+    });
+    void runAction();
+    expect(busy.value).toBe(true);
+
+    // The second confirm can't replace the busy dialog (it would open inert
+    // under the global busy state) — it resolves unconfirmed immediately and
+    // leaves the in-flight request untouched.
+    const second = confirm({ title: 'Second' });
+    await expect(second).resolves.toBe(false);
+    expect(current.value?.title).toBe('First');
+    expect(busy.value).toBe(true);
+
+    action.resolve();
+    await expect(first).resolves.toBe(true);
+    expect(busy.value).toBe(false);
+    expect(current.value).toBeNull();
+  });
+});
diff --git a/apps/kimi-web/test/daemon-client.test.ts b/apps/kimi-web/test/daemon-client.test.ts
index 1d452ff54..dbe9c7918 100644
--- a/apps/kimi-web/test/daemon-client.test.ts
+++ b/apps/kimi-web/test/daemon-client.test.ts
@@ -1,12 +1,42 @@
 // apps/kimi-web/test/daemon-client.test.ts
-// DaemonKimiWebApi public REST adapter: session export binary/error contracts
-// and getSessionGoal wire → app mapping.
+// DaemonKimiWebApi public REST adapter: session export binary/error contracts,
+// getSessionGoal wire → app mapping, and raw stream-coordinate delivery.
+// Wiring: real client/projector; fetch or WebSocket is stubbed at the network boundary.
+// Run: pnpm --filter @moonshot-ai/kimi-web exec vitest run test/daemon-client.test.ts
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { DaemonKimiWebApi } from '../src/api/daemon/client';
 import { DaemonApiError, DaemonNetworkError } from '../src/api/errors';
 import { clearTrace, traceToJsonl } from '../src/debug/trace';
+import type { AppEvent, KimiEventConnection, KimiEventMeta } from '../src/api/types';
+
+class FakeWebSocket {
+  static readonly OPEN = 1;
+  static instances: FakeWebSocket[] = [];
+
+  readonly OPEN = FakeWebSocket.OPEN;
+  readyState = FakeWebSocket.OPEN;
+  onopen: (() => void) | null = null;
+  onmessage: ((event: MessageEvent) => void) | null = null;
+  onerror: (() => void) | null = null;
+  onclose: ((event?: CloseEvent) => void) | null = null;
+
+  constructor(_url: string, _protocols?: string | string[]) {
+    FakeWebSocket.instances.push(this);
+  }
+
+  send(_data: string): void {}
+
+  close(): void {
+    this.readyState = 3;
+    this.onclose?.();
+  }
+
+  emit(frame: unknown): void {
+    this.onmessage?.({ data: JSON.stringify(frame) } as MessageEvent);
+  }
+}
 
 function envelope(data: unknown): Response {
   return new Response(JSON.stringify({ code: 0, msg: '', data }), {
@@ -177,3 +207,130 @@ describe('DaemonKimiWebApi.getSessionGoal', () => {
     );
   });
 });
+
+describe('DaemonKimiWebApi.connectEvents', () => {
+  let connection: KimiEventConnection | undefined;
+
+  afterEach(() => {
+    connection?.close();
+    connection = undefined;
+    vi.unstubAllGlobals();
+  });
+
+  it('delivers raw assistant stream coordinates with the projected delta', () => {
+    FakeWebSocket.instances = [];
+    vi.stubGlobal('WebSocket', FakeWebSocket as unknown as typeof WebSocket);
+    const received: Array<{ event: AppEvent; meta: KimiEventMeta }> = [];
+    connection = createApi().connectEvents({
+      onEvent(event, meta) {
+        received.push({ event, meta });
+      },
+      onResync() {},
+      onError() {},
+      onConnectionChange() {},
+    });
+    const socket = FakeWebSocket.instances[0]!;
+
+    socket.emit({ type: 'server_hello', payload: { protocol_version: 2 } });
+    socket.emit({
+      type: 'turn.started',
+      seq: 1,
+      session_id: 'session-1',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      payload: { agentId: 'main', turnId: 7 },
+    });
+    socket.emit({
+      type: 'turn.step.started',
+      seq: 2,
+      session_id: 'session-1',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      payload: { agentId: 'main', turnId: 7, step: 1 },
+    });
+    socket.emit({
+      type: 'assistant.delta',
+      seq: 2,
+      session_id: 'session-1',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      volatile: true,
+      offset: 0,
+      payload: { agentId: 'main', turnId: 7, delta: 'hello' },
+    });
+    socket.emit({
+      type: 'thinking.delta',
+      seq: 2,
+      session_id: 'session-1',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      volatile: true,
+      offset: 0,
+      payload: { agentId: 'main', turnId: 7, delta: 'thought' },
+    });
+
+    const delta = received.find(({ event }) => event.type === 'assistantDelta');
+    expect(delta).toMatchObject({
+      event: {
+        type: 'assistantDelta',
+        sessionId: 'session-1',
+        delta: { text: 'hello' },
+      },
+      meta: {
+        sessionId: 'session-1',
+        seq: 2,
+        stream: { turnId: 7, offset: 0, kind: 'text' },
+      },
+    });
+
+    const thinking = received.find(
+      ({ event }) => event.type === 'assistantDelta' && event.delta.thinking !== undefined,
+    );
+    expect(thinking).toMatchObject({
+      event: {
+        type: 'assistantDelta',
+        sessionId: 'session-1',
+        delta: { thinking: 'thought' },
+      },
+      meta: {
+        sessionId: 'session-1',
+        seq: 2,
+        stream: { turnId: 7, offset: 0, kind: 'thinking' },
+      },
+    });
+  });
+
+  it('projects list-level work facts from the global session event', () => {
+    FakeWebSocket.instances = [];
+    vi.stubGlobal('WebSocket', FakeWebSocket as unknown as typeof WebSocket);
+    const received: AppEvent[] = [];
+    connection = createApi().connectEvents({
+      onEvent(event) {
+        received.push(event);
+      },
+      onResync() {},
+      onError() {},
+      onConnectionChange() {},
+    });
+    const [socket] = FakeWebSocket.instances;
+    if (socket === undefined) throw new Error('WebSocket was not created');
+
+    socket.emit({ type: 'server_hello', payload: { protocol_version: 2 } });
+    socket.emit({
+      type: 'event.session.work_changed',
+      seq: 1,
+      session_id: 'session-1',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      payload: {
+        busy: true,
+        main_turn_active: false,
+        pending_interaction: 'question',
+      },
+    });
+
+    expect(received).toContainEqual({
+      type: 'sessionWorkChanged',
+      sessionId: 'session-1',
+      busy: true,
+      mainTurnActive: false,
+      pendingInteraction: 'question',
+      lastTurnReason: undefined,
+    });
+  });
+});
diff --git a/apps/kimi-web/test/event-batcher.test.ts b/apps/kimi-web/test/event-batcher.test.ts
index 09360e6db..0108d9241 100644
--- a/apps/kimi-web/test/event-batcher.test.ts
+++ b/apps/kimi-web/test/event-batcher.test.ts
@@ -1,148 +1,792 @@
-// apps/kimi-web/test/event-batcher.test.ts
-// Unit tests for the streaming-event coalescing logic.
-//
-// These verify the batcher's behaviour (coalesce + preserve order + immediate
-// passthrough for non-batchable items). They deliberately do NOT try to assert
-// "Vue renders once" — that is a property of Vue's scheduler and is covered by
-// manual perf verification, not by a unit test.
+/**
+ * Scenario: high-frequency WebSocket render events reach the browser queue.
+ * Responsibilities: preserve ordering, merge only proven-contiguous assistant
+ * streams, bound each drain, keep a hidden-tab task fallback, and cancel stale
+ * callbacks after flush. Wiring: real batcher/coalescer/reducer with only the
+ * browser scheduler replaced by a manual public scheduler.
+ * Run: pnpm --filter @moonshot-ai/kimi-web exec vitest run test/event-batcher.test.ts
+ */
 
-import { describe, expect, it } from 'vitest';
-import { createEventBatcher, isRenderEvent } from '../src/composables/client/eventBatcher';
-import type { AppEvent } from '../src/api/types';
+import { describe, expect, it, vi } from 'vitest';
 
-interface FakeSchedule {
-  schedule: (cb: () => void) => number;
-  calls: () => number;
-  flush: () => void;
+import { createInitialState, reduceAppEvent, type KimiClientState } from '../src/api/daemon/eventReducer';
+import type {
+  AppEvent,
+  AppMessage,
+  AppSession,
+  AppSessionSnapshot,
+  KimiEventConnection,
+  KimiEventHandlers,
+  KimiWebApi,
+} from '../src/api/types';
+import {
+  coalesceAppRenderEvents,
+  createEventBatcher,
+  isRenderEvent,
+  splitOversizedAppRenderEvent,
+  type EventBatcher,
+  type EventBatcherScheduler,
+  type PendingAppEvent,
+} from '../src/composables/client/eventBatcher';
+
+const clientApiMock = vi.hoisted(() => ({}));
+const REASONABLE_MAX_STREAM_GROUP_CHARS = 64 * 1024;
+
+vi.mock('../src/api', () => ({
+  getKimiWebApi: () => clientApiMock,
+}));
+
+interface ManualScheduler extends EventBatcherScheduler {
+  flushFrame(): void;
+  flushTask(): void;
+  pendingFrames(): number;
+  pendingTasks(): number;
 }
 
-// A synchronous, manually-triggered scheduler. Stores the most recent callback;
-// `flush()` runs it. Lets tests drive the batcher without real rAF / timers.
-function fakeSchedule(): FakeSchedule {
-  let cb: (() => void) | null = null;
-  let count = 0;
+interface OwnedQueueItem {
+  owner: string;
+  kind: 'render' | 'control';
+  id: string;
+}
+
+function manualScheduler(): ManualScheduler {
+  let nextHandle = 1;
+  const frames = new Map<number, () => void>();
+  const tasks = new Map<number, () => void>();
+
+  function takeOne(callbacks: Map<number, () => void>): void {
+    const entry = callbacks.entries().next().value as [number, () => void] | undefined;
+    if (entry === undefined) return;
+    callbacks.delete(entry[0]);
+    entry[1]();
+  }
+
   return {
-    schedule(fn) {
-      count += 1;
-      cb = fn;
-      return count;
+    requestFrame(callback) {
+      const handle = nextHandle++;
+      frames.set(handle, callback);
+      return handle;
     },
-    calls: () => count,
-    flush() {
-      const fn = cb;
-      cb = null;
-      fn?.();
+    cancelFrame(handle) {
+      frames.delete(handle);
+    },
+    requestTask(callback) {
+      const handle = nextHandle++;
+      tasks.set(handle, callback);
+      return handle;
+    },
+    cancelTask(handle) {
+      tasks.delete(handle);
+    },
+    flushFrame() {
+      takeOne(frames);
+    },
+    flushTask() {
+      takeOne(tasks);
+    },
+    pendingFrames: () => frames.size,
+    pendingTasks: () => tasks.size,
+  };
+}
+
+interface DeltaOptions {
+  sessionId?: string;
+  messageId?: string;
+  contentIndex?: number;
+  turnId?: number;
+  kind?: 'text' | 'thinking';
+  stream?: boolean;
+  seq?: number;
+}
+
+function pendingDelta(value: string, offset: number, options: DeltaOptions = {}): PendingAppEvent {
+  const sessionId = options.sessionId ?? 'session-1';
+  const kind = options.kind ?? 'text';
+  return {
+    appEvent: {
+      type: 'assistantDelta',
+      sessionId,
+      messageId: options.messageId ?? 'message-1',
+      contentIndex: options.contentIndex ?? 0,
+      delta: kind === 'text' ? { text: value } : { thinking: value },
+    },
+    meta: {
+      sessionId,
+      seq: options.seq ?? offset + value.length,
+      stream:
+        options.stream === false
+          ? undefined
+          : {
+              turnId: options.turnId ?? 1,
+              offset,
+              kind,
+            },
     },
   };
 }
 
-describe('createEventBatcher', () => {
-  it('coalesces consecutive batchable items into one scheduled flush, in order', () => {
+function enqueueAppEvent(
+  enqueue: EventBatcher<PendingAppEvent>,
+  item: PendingAppEvent,
+): void {
+  for (const part of splitOversizedAppRenderEvent(item)) enqueue(part);
+}
+
+function assistantState(content: AppMessage['content'] = [{ type: 'text', text: '' }]): KimiClientState {
+  const state = createInitialState();
+  state.messagesBySession['session-1'] = [
+    {
+      id: 'message-1',
+      sessionId: 'session-1',
+      role: 'assistant',
+      content,
+      createdAt: '2026-01-01T00:00:00.000Z',
+    },
+  ];
+  return state;
+}
+
+describe('createEventBatcher (ordered bounded scheduling)', () => {
+  it('processes queued render items in arrival order when the frame runs', () => {
     const processed: string[] = [];
-    const f = fakeSchedule();
-    const enqueue = createEventBatcher<string>((s) => processed.push(s), (s) => s.startsWith('d'), f.schedule);
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      (item) => item.startsWith('d'),
+      { scheduler },
+    );
 
     enqueue('d1');
     enqueue('d2');
     enqueue('d3');
 
-    expect(processed).toEqual([]); // nothing processed yet
-    expect(f.calls()).toBe(1); // scheduled exactly once
+    expect(processed).toEqual([]);
+    expect(scheduler.pendingFrames()).toBe(1);
+    expect(scheduler.pendingTasks()).toBe(1);
+
+    scheduler.flushFrame();
 
-    f.flush();
     expect(processed).toEqual(['d1', 'd2', 'd3']);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
   });
 
-  it('applies a non-batchable item immediately when the queue is empty', () => {
+  it('processes a control item synchronously when no render item is pending', () => {
     const processed: string[] = [];
-    const f = fakeSchedule();
-    const enqueue = createEventBatcher<string>((s) => processed.push(s), (s) => s.startsWith('d'), f.schedule);
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      (item) => item.startsWith('d'),
+      { scheduler },
+    );
 
-    enqueue('X');
+    enqueue('control');
 
-    expect(processed).toEqual(['X']);
-    expect(f.calls()).toBe(0); // never scheduled
+    expect(processed).toEqual(['control']);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
   });
 
-  it('drains pending batchables before applying an immediate item', () => {
+  it('keeps a control item behind prior render items when one slice is enough', () => {
     const processed: string[] = [];
-    const f = fakeSchedule();
-    const enqueue = createEventBatcher<string>((s) => processed.push(s), (s) => s.startsWith('d'), f.schedule);
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      (item) => item.startsWith('d'),
+      { scheduler, maxItemsPerSlice: 10 },
+    );
 
     enqueue('d1');
     enqueue('d2');
-    enqueue('X'); // immediate → must flush d1, d2 first
+    enqueue('control');
 
-    expect(processed).toEqual(['d1', 'd2', 'X']);
-
-    // The rAF scheduled for d1 is now stale; firing it must be a harmless no-op.
-    f.flush();
-    expect(processed).toEqual(['d1', 'd2', 'X']);
+    expect(processed).toEqual(['d1', 'd2', 'control']);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
   });
 
-  it('preserves arrival order across mixed batchable and immediate items', () => {
+  it('continues on a later callback when a control item follows more than one slice', () => {
     const processed: string[] = [];
-    const f = fakeSchedule();
-    const enqueue = createEventBatcher<string>((s) => processed.push(s), (s) => s.startsWith('d'), f.schedule);
-
-    enqueue('d1'); // queued
-    enqueue('d2'); // queued
-    enqueue('A'); // immediate → drains d1, d2, then A
-    enqueue('d3'); // queued again
-    f.flush(); // drains d3
-
-    expect(processed).toEqual(['d1', 'd2', 'A', 'd3']);
-  });
-
-  it('reschedules after a flush when new batchable items arrive', () => {
-    const processed: string[] = [];
-    const f = fakeSchedule();
-    const enqueue = createEventBatcher<string>((s) => processed.push(s), (s) => s.startsWith('d'), f.schedule);
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      (item) => item.startsWith('d'),
+      { scheduler, maxItemsPerSlice: 2 },
+    );
 
     enqueue('d1');
-    f.flush();
-    expect(processed).toEqual(['d1']);
-
     enqueue('d2');
-    expect(f.calls()).toBe(2); // scheduled a second time
+    enqueue('d3');
+    enqueue('control');
+    enqueue('d4');
 
-    f.flush();
     expect(processed).toEqual(['d1', 'd2']);
+    expect(scheduler.pendingFrames()).toBe(1);
+    expect(scheduler.pendingTasks()).toBe(1);
+
+    scheduler.flushFrame();
+
+    expect(processed).toEqual(['d1', 'd2', 'd3', 'control']);
+    expect(scheduler.pendingFrames()).toBe(1);
+    expect(scheduler.pendingTasks()).toBe(1);
+
+    scheduler.flushTask();
+
+    expect(processed).toEqual(['d1', 'd2', 'd3', 'control', 'd4']);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
   });
 
-  it('flush() drains pending batchables synchronously without the scheduler', () => {
+  it('uses the task fallback when animation frames do not run', () => {
     const processed: string[] = [];
-    const f = fakeSchedule();
-    const enqueue = createEventBatcher<string>((s) => processed.push(s), (s) => s.startsWith('d'), f.schedule);
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      () => true,
+      { scheduler },
+    );
 
     enqueue('d1');
     enqueue('d2');
-    expect(processed).toEqual([]);
+    scheduler.flushTask();
 
-    enqueue.flush(); // synchronous drain, no scheduler callback needed
     expect(processed).toEqual(['d1', 'd2']);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
   });
 
-  it('flush() on an empty queue is a no-op', () => {
+  it('cancels scheduled callbacks when flush drains the queue authoritatively', () => {
     const processed: string[] = [];
-    const f = fakeSchedule();
-    const enqueue = createEventBatcher<string>((s) => processed.push(s), (s) => s.startsWith('d'), f.schedule);
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      () => true,
+      { scheduler },
+    );
 
+    enqueue('d1');
+    enqueue('d2');
     enqueue.flush();
+
+    expect(processed).toEqual(['d1', 'd2']);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
+  });
+
+  it('discards a removed owner control item that remains beyond the slice budget', () => {
+    const processed: string[] = [];
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<OwnedQueueItem>(
+      (item) => processed.push(item.id),
+      (item) => item.kind === 'render',
+      { scheduler, maxItemsPerSlice: 2 },
+    );
+
+    enqueue({ owner: 'session-2', kind: 'render', id: 'session-2:d1' });
+    enqueue({ owner: 'session-2', kind: 'render', id: 'session-2:d2' });
+    enqueue({ owner: 'session-1', kind: 'render', id: 'session-1:d1' });
+    enqueue({ owner: 'session-1', kind: 'control', id: 'session-1:idle' });
+    expect(processed).toEqual(['session-2:d1', 'session-2:d2']);
+
+    enqueue.discard((item) => item.owner === 'session-1');
+    scheduler.flushFrame();
+    scheduler.flushTask();
+
+    expect(processed).toEqual(['session-2:d1', 'session-2:d2']);
+  });
+
+  it('preserves the order of items not discarded', () => {
+    const processed: string[] = [];
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      () => true,
+      { scheduler },
+    );
+
+    enqueue('session-1:d1');
+    enqueue('session-2:d1');
+    enqueue('session-1:d2');
+    enqueue('session-2:d2');
+    enqueue.discard((item) => item.startsWith('session-1:'));
+    scheduler.flushFrame();
+
+    expect(processed).toEqual(['session-2:d1', 'session-2:d2']);
+  });
+
+  it('cancels scheduled callbacks when discard empties the queue', () => {
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      () => {},
+      () => true,
+      { scheduler },
+    );
+
+    enqueue('session-1:d1');
+    enqueue('session-1:d2');
+    expect(scheduler.pendingFrames()).toBe(1);
+    expect(scheduler.pendingTasks()).toBe(1);
+
+    enqueue.discard((item) => item.startsWith('session-1:'));
+
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
+  });
+
+  it('cancels scheduled work once when dispose is repeated', () => {
+    const processed: string[] = [];
+    const scheduler = manualScheduler();
+    const cancelFrame = vi.spyOn(scheduler, 'cancelFrame');
+    const cancelTask = vi.spyOn(scheduler, 'cancelTask');
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      () => true,
+      { scheduler },
+    );
+
+    enqueue('d1');
+    enqueue('d2');
+    expect(scheduler.pendingFrames()).toBe(1);
+    expect(scheduler.pendingTasks()).toBe(1);
+
+    enqueue.dispose();
+    enqueue.dispose();
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
+    expect(cancelFrame).toHaveBeenCalledTimes(1);
+    expect(cancelTask).toHaveBeenCalledTimes(1);
+
+    scheduler.flushFrame();
+    scheduler.flushTask();
     expect(processed).toEqual([]);
   });
+
+  it('ignores items enqueued after dispose without scheduling callbacks', () => {
+    const processed: string[] = [];
+    const scheduler = manualScheduler();
+    const enqueue = createEventBatcher<string>(
+      (item) => processed.push(item),
+      () => true,
+      { scheduler },
+    );
+
+    enqueue.dispose();
+    enqueue('d3');
+    enqueue.flush();
+
+    expect(processed).toEqual([]);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
+  });
 });
 
-describe('isRenderEvent', () => {
+describe('coalesceAppRenderEvents (lossless stream grouping)', () => {
+  it('reduces 10,000 contiguous deltas in capped groups while preserving every character', () => {
+    const scheduler = manualScheduler();
+    let state = assistantState();
+    let reducerCalls = 0;
+    const groupLengths: number[] = [];
+    const groupOffsets: number[] = [];
+    const enqueue = createEventBatcher<PendingAppEvent>(
+      ({ appEvent, meta }) => {
+        reducerCalls += 1;
+        groupLengths.push(
+          appEvent.type === 'assistantDelta' ? (appEvent.delta.text?.length ?? 0) : 0,
+        );
+        groupOffsets.push(meta.stream?.offset ?? -1);
+        state = reduceAppEvent(state, appEvent, meta);
+      },
+      ({ appEvent }) => isRenderEvent(appEvent),
+      { scheduler, coalesce: coalesceAppRenderEvents },
+    );
+
+    for (let index = 0; index < 10_000; index += 1) {
+      enqueueAppEvent(enqueue, pendingDelta('abcdefghijklmnop', index * 16));
+    }
+
+    expect(scheduler.pendingFrames()).toBe(1);
+    expect(scheduler.pendingTasks()).toBe(1);
+    scheduler.flushFrame();
+
+    expect(reducerCalls).toBeGreaterThan(1);
+    expect(reducerCalls).toBeLessThan(100);
+    expect(
+      groupLengths.every((length) => length <= REASONABLE_MAX_STREAM_GROUP_CHARS),
+    ).toBe(true);
+    let expectedOffset = 0;
+    for (let index = 0; index < groupOffsets.length; index += 1) {
+      expect(groupOffsets[index]).toBe(expectedOffset);
+      expectedOffset += groupLengths[index]!;
+    }
+    expect(state.lastSeqBySession['session-1']).toBe(160_000);
+    expect(state.messagesBySession['session-1']?.[0]?.content).toEqual([
+      { type: 'text', text: 'abcdefghijklmnop'.repeat(10_000) },
+    ]);
+  });
+
+  it('keeps a 10,000-delta hidden-tab backlog in a few capped groups', () => {
+    const scheduler = manualScheduler();
+    const processed: PendingAppEvent[] = [];
+    const enqueue = createEventBatcher<PendingAppEvent>(
+      (item) => processed.push(item),
+      ({ appEvent }) => isRenderEvent(appEvent),
+      { scheduler, coalesce: coalesceAppRenderEvents },
+    );
+
+    for (let index = 0; index < 10_000; index += 1) {
+      enqueueAppEvent(enqueue, pendingDelta('abcdefghijklmnop', index * 16));
+    }
+
+    expect(processed).toEqual([]);
+    expect(scheduler.pendingFrames()).toBe(1);
+    expect(scheduler.pendingTasks()).toBe(1);
+
+    scheduler.flushTask();
+
+    expect(processed.length).toBeGreaterThan(1);
+    expect(processed.length).toBeLessThan(100);
+    expect(
+      processed.every(
+        ({ appEvent }) =>
+          appEvent.type === 'assistantDelta' &&
+          (appEvent.delta.text?.length ?? 0) <= REASONABLE_MAX_STREAM_GROUP_CHARS,
+      ),
+    ).toBe(true);
+    let expectedOffset = 0;
+    for (const item of processed) {
+      expect(item.meta.stream?.offset).toBe(expectedOffset);
+      if (item.appEvent.type === 'assistantDelta') {
+        expectedOffset += item.appEvent.delta.text?.length ?? 0;
+      }
+    }
+    expect(
+      processed
+        .map(({ appEvent }) =>
+          appEvent.type === 'assistantDelta' ? (appEvent.delta.text ?? '') : '',
+        )
+        .join(''),
+    ).toBe('abcdefghijklmnop'.repeat(10_000));
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
+  });
+
+  it('splits one oversized incoming delta without breaking a surrogate pair', () => {
+    const value = '\ud83d\ude00'.repeat(50_000) + 'tail';
+
+    const parts = splitOversizedAppRenderEvent(pendingDelta(value, 7));
+
+    expect(parts.length).toBeGreaterThan(1);
+    expect(parts.length).toBeLessThan(100);
+    let expectedOffset = 7;
+    for (const part of parts) {
+      expect(part.meta.stream?.offset).toBe(expectedOffset);
+      expect(part.meta.seq).toBe(7 + value.length);
+      if (part.appEvent.type === 'assistantDelta') {
+        const text = part.appEvent.delta.text ?? '';
+        expect(text.length).toBeLessThanOrEqual(REASONABLE_MAX_STREAM_GROUP_CHARS);
+        expect(/[\uD800-\uDBFF]$/u.test(text)).toBe(false);
+        expect(/^[\uDC00-\uDFFF]/u.test(text)).toBe(false);
+        expectedOffset += text.length;
+      }
+    }
+    expect(
+      parts.every(
+        ({ appEvent }) =>
+          appEvent.type === 'assistantDelta' &&
+          (appEvent.delta.text?.length ?? 0) <= REASONABLE_MAX_STREAM_GROUP_CHARS,
+      ),
+    ).toBe(true);
+    expect(
+      parts
+        .map(({ appEvent }) =>
+          appEvent.type === 'assistantDelta' ? (appEvent.delta.text ?? '') : '',
+        )
+        .join(''),
+    ).toBe(value);
+  });
+
+  it.each([
+    ['session differs', pendingDelta('b', 1, { sessionId: 'session-2' })],
+    ['turn differs', pendingDelta('b', 1, { turnId: 2 })],
+    ['message differs', pendingDelta('b', 1, { messageId: 'message-2' })],
+    ['content index differs', pendingDelta('b', 1, { contentIndex: 1 })],
+    ['delta kind differs', pendingDelta('b', 1, { kind: 'thinking' })],
+    ['offset is not contiguous', pendingDelta('b', 2)],
+    ['stream coordinates are missing', pendingDelta('b', 1, { stream: false })],
+  ])('keeps adjacent deltas separate when %s', (_condition, next) => {
+    const scheduler = manualScheduler();
+    let processed = 0;
+    const enqueue = createEventBatcher<PendingAppEvent>(
+      () => {
+        processed += 1;
+      },
+      ({ appEvent }) => isRenderEvent(appEvent),
+      { scheduler, coalesce: coalesceAppRenderEvents },
+    );
+
+    enqueue(pendingDelta('a', 0));
+    enqueue(next);
+    scheduler.flushFrame();
+
+    expect(processed).toBe(2);
+  });
+
+  it('coalesces contiguous thinking deltas into the existing thinking block', () => {
+    const scheduler = manualScheduler();
+    let state = assistantState([{ type: 'thinking', thinking: 'seed' }]);
+    const enqueue = createEventBatcher<PendingAppEvent>(
+      ({ appEvent, meta }) => {
+        state = reduceAppEvent(state, appEvent, meta);
+      },
+      ({ appEvent }) => isRenderEvent(appEvent),
+      { scheduler, coalesce: coalesceAppRenderEvents },
+    );
+
+    enqueue(pendingDelta(' one', 0, { kind: 'thinking' }));
+    enqueue(pendingDelta(' two', 4, { kind: 'thinking' }));
+    scheduler.flushFrame();
+
+    expect(state.messagesBySession['session-1']?.[0]?.content).toEqual([
+      { type: 'thinking', thinking: 'seed one two', signature: undefined },
+    ]);
+  });
+
+  it('does not reapply a pre-snapshot delta after the snapshot seeds live text', () => {
+    const scheduler = manualScheduler();
+    let state = assistantState();
+    const enqueue = createEventBatcher<PendingAppEvent>(
+      ({ appEvent, meta }) => {
+        state = reduceAppEvent(state, appEvent, meta);
+      },
+      ({ appEvent }) => isRenderEvent(appEvent),
+      { scheduler, coalesce: coalesceAppRenderEvents },
+    );
+
+    enqueue(pendingDelta('stale', 0));
+    enqueue.flush();
+    state = assistantState([{ type: 'text', text: 'snapshot' }]);
+    enqueue(pendingDelta(' live', 8));
+    scheduler.flushFrame();
+
+    expect(state.messagesBySession['session-1']?.[0]?.content).toEqual([
+      { type: 'text', text: 'snapshot live' },
+    ]);
+    expect(scheduler.pendingFrames()).toBe(0);
+    expect(scheduler.pendingTasks()).toBe(0);
+  });
+});
+
+describe('useKimiWebClient (resync integration)', () => {
+  it('flushes queued deltas around an authoritative snapshot before live streaming resumes', async () => {
+    vi.stubGlobal('WebSocket', class {});
+
+    const sessionId = 'session-1';
+    const session: AppSession = {
+      id: sessionId,
+      title: 'Session',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-01T00:00:00.000Z',
+      status: 'running',
+      archived: false,
+      currentPromptId: 'prompt-1',
+      cwd: '/workspace',
+      model: 'model-1',
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        totalCostUsd: 0,
+        contextTokens: 0,
+        contextLimit: 0,
+        turnCount: 1,
+      },
+      messageCount: 1,
+      lastSeq: 10,
+      workspaceId: 'workspace-1',
+    };
+    const snapshot = (text: string, asOfSeq: number, epoch: string): AppSessionSnapshot => ({
+      asOfSeq,
+      epoch,
+      session: { ...session, lastSeq: asOfSeq },
+      messages: [
+        {
+          id: 'message-1',
+          sessionId,
+          role: 'assistant',
+          content: [{ type: 'text', text }],
+          createdAt: '2026-01-01T00:00:00.000Z',
+        },
+      ],
+      hasMoreMessages: false,
+      inFlightTurn: {
+        turnId: 1,
+        assistantText: text,
+        thinkingText: '',
+        runningTools: [],
+        promptId: 'prompt-1',
+      },
+      subagents: [],
+      pendingApprovals: [],
+      pendingQuestions: [],
+    });
+    const initialSnapshot = snapshot('seed', 10, 'epoch-1');
+    const authoritativeSnapshot = snapshot('snapshot', 20, 'epoch-2');
+
+    let handlers: KimiEventHandlers | undefined;
+    let resolveSnapshotRequest!: () => void;
+    const snapshotRequested = new Promise<void>((resolve) => {
+      resolveSnapshotRequest = resolve;
+    });
+    let resolveAuthoritativeSnapshot!: (value: AppSessionSnapshot) => void;
+    const authoritativeSnapshotResponse = new Promise<AppSessionSnapshot>((resolve) => {
+      resolveAuthoritativeSnapshot = resolve;
+    });
+    let resolveSnapshotApplied!: () => void;
+    const snapshotApplied = new Promise<void>((resolve) => {
+      resolveSnapshotApplied = resolve;
+    });
+    let snapshotCalls = 0;
+    const getSessionSnapshot = vi.fn((_id: string) => {
+      snapshotCalls += 1;
+      if (snapshotCalls === 1) return Promise.resolve(initialSnapshot);
+      resolveSnapshotRequest();
+      return authoritativeSnapshotResponse;
+    });
+    let seedCalls = 0;
+    const connection: KimiEventConnection = {
+      subscribe: vi.fn(),
+      unsubscribe: vi.fn(),
+      bindNextPromptId: vi.fn(),
+      seedSnapshot: vi.fn(() => {
+        seedCalls += 1;
+        if (seedCalls === 2) resolveSnapshotApplied();
+      }),
+      abort: vi.fn(),
+      terminalAttach: vi.fn(),
+      terminalInput: vi.fn(),
+      terminalResize: vi.fn(),
+      terminalDetach: vi.fn(),
+      terminalClose: vi.fn(),
+      markSideChannelAgent: vi.fn(),
+      health: () => ({ connected: true, open: true, stale: false }),
+      reconnect: vi.fn(),
+      close: vi.fn(),
+    };
+    const api: Partial<KimiWebApi> = {
+      getAuth: vi.fn(async () => ({
+        ready: true,
+        defaultModel: 'model-1',
+        managedProvider: null,
+      })),
+      getHealth: vi.fn(async () => ({ status: 'ok', uptimeSec: 1 })),
+      getMeta: vi.fn(async () => ({
+        serverVersion: '0.0.0',
+        serverId: 'server-1',
+        startedAt: '2026-01-01T00:00:00.000Z',
+        capabilities: {},
+        openInApps: [],
+        dangerousBypassAuth: false,
+        backend: 'v2',
+      })),
+      getConfig: vi.fn(async () => ({ providers: {}, defaultModel: 'model-1' })),
+      listModels: vi.fn(async () => []),
+      listProviders: vi.fn(async () => []),
+      listWorkspaces: vi.fn(async () => [
+        {
+          id: 'workspace-1',
+          root: '/workspace',
+          name: 'Workspace',
+          sessionCount: 1,
+        },
+      ]),
+      getFsHome: vi.fn(async () => ({ home: '/home/test', recentRoots: [] })),
+      listSessions: vi.fn(async () => ({ items: [session], hasMore: false })),
+      getSessionSnapshot,
+      getSessionStatus: vi.fn(async () => ({
+        model: 'model-1',
+        thinkingEffort: 'high',
+        permission: 'manual',
+        planMode: false,
+        swarmMode: false,
+        contextTokens: 0,
+        maxContextTokens: 0,
+        contextUsage: 0,
+      })),
+      getSessionGoal: vi.fn(async () => null),
+      getSessionWarnings: vi.fn(async () => []),
+      getGitStatus: vi.fn(async () => ({
+        branch: '',
+        ahead: 0,
+        behind: 0,
+        entries: {},
+        additions: 0,
+        deletions: 0,
+        pullRequest: null,
+      })),
+      listTasks: vi.fn(async () => []),
+      listSkills: vi.fn(async () => []),
+      listSkillsForWorkspace: vi.fn(async () => []),
+      getFileUrl: (fileId) => `file:${fileId}`,
+      connectEvents: vi.fn((nextHandlers) => {
+        handlers = nextHandlers;
+        return connection;
+      }),
+    };
+    for (const key of Object.keys(clientApiMock)) delete clientApiMock[key];
+    Object.assign(clientApiMock, api);
+
+    try {
+      const { useKimiWebClient } = await import('../src/composables/useKimiWebClient');
+      const client = useKimiWebClient();
+      await client.load();
+      const assistantText = (): string | undefined =>
+        client.turns.value.find((turn) => turn.role === 'assistant')?.text;
+
+      expect(assistantText()).toBe('seed');
+      expect(handlers).toBeDefined();
+
+      const beforeResync = pendingDelta('before', 4, { seq: 11 });
+      handlers!.onEvent(beforeResync.appEvent, beforeResync.meta);
+      handlers!.onResync(sessionId, 11, 'epoch-2');
+
+      // onResync synchronously drains pre-resync text onto the old state.
+      expect(assistantText()).toBe('seedbefore');
+      await snapshotRequested;
+
+      // A frame can race the REST request. The second flush must consume it on
+      // the old state before the authoritative snapshot replaces that state.
+      const duringSnapshot = pendingDelta('old', 10, { seq: 12 });
+      handlers!.onEvent(duringSnapshot.appEvent, duringSnapshot.meta);
+      resolveAuthoritativeSnapshot(authoritativeSnapshot);
+      await snapshotApplied;
+      expect(assistantText()).toBe('snapshot');
+
+      const live = pendingDelta(' live', 8, { seq: 21 });
+      handlers!.onEvent(live.appEvent, live.meta);
+      handlers!.onEvent(
+        { type: 'sessionMetaUpdated', sessionId, title: 'Session' },
+        { sessionId, seq: 22 },
+      );
+
+      expect(assistantText()).toBe('snapshot live');
+    } finally {
+      connection.close();
+      vi.unstubAllGlobals();
+    }
+  });
+});
+
+describe('isRenderEvent (queue classification)', () => {
   it.each(['assistantDelta', 'agentDelta', 'toolOutput', 'taskProgress'])(
-    'treats %s as batchable',
+    'classifies %s as a render event',
     (type) => {
       expect(isRenderEvent({ type } as AppEvent)).toBe(true);
     },
   );
 
-  it.each(['messageCreated', 'messageUpdated', 'sessionStatusChanged', 'approvalRequested', 'configChanged'])(
-    'treats %s as immediate',
+  it.each(['messageCreated', 'messageUpdated', 'sessionWorkChanged', 'approvalRequested', 'configChanged'])(
+    'classifies %s as a control event',
     (type) => {
       expect(isRenderEvent({ type } as AppEvent)).toBe(false);
     },
diff --git a/apps/kimi-web/test/event-reducer.test.ts b/apps/kimi-web/test/event-reducer.test.ts
index 3aa471c2a..f22c51119 100644
--- a/apps/kimi-web/test/event-reducer.test.ts
+++ b/apps/kimi-web/test/event-reducer.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { createInitialState, reduceAppEvent } from '../src/api/daemon/eventReducer';
 import type { AppMessage, AppSession, AppTask } from '../src/api/types';
+import { i18n } from '../src/i18n';
 
 function makeSession(id: string, updatedAt: string): AppSession {
   return {
@@ -8,7 +9,7 @@ function makeSession(id: string, updatedAt: string): AppSession {
     title: id,
     createdAt: updatedAt,
     updatedAt,
-    status: 'idle',
+    busy: false,
     archived: false,
     cwd: '/workspace',
     model: 'kimi-code',
@@ -43,11 +44,175 @@ function makeSubagentTask(id: string, sessionId: string): AppTask {
     sessionId,
     kind: 'subagent',
     description: 'subagent task',
-    status: 'running',
+    busy: true,
     createdAt: '2026-01-01T00:00:00.000Z',
   };
 }
 
+describe('reduceAppEvent turnActiveChanged', () => {
+  it('sets and clears the per-session main-turn liveness flag', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [makeSession('s1', '2026-01-01T00:00:00.000Z')],
+    };
+    const started = reduceAppEvent(
+      state,
+      { type: 'turnActiveChanged', sessionId: 's1', active: true },
+      { sessionId: 's1', seq: 1 },
+    );
+    expect(started.turnActiveBySession['s1']).toBe(true);
+    expect(started.sessions[0]?.mainTurnActive).toBe(true);
+    const ended = reduceAppEvent(
+      started,
+      { type: 'turnActiveChanged', sessionId: 's1', active: false, reason: 'completed' },
+      { sessionId: 's1', seq: 2 },
+    );
+    expect(ended.turnActiveBySession['s1']).toBeUndefined();
+    expect(ended.sessions[0]?.mainTurnActive).toBe(false);
+  });
+
+  it('drops the flag with the rest of a deleted session', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [makeSession('s1', '2026-01-01T00:00:00.000Z')],
+      turnActiveBySession: { s1: true },
+    };
+    const next = reduceAppEvent(state, { type: 'sessionDeleted', sessionId: 's1' }, { sessionId: 's1', seq: 1 });
+    expect(next.turnActiveBySession['s1']).toBeUndefined();
+  });
+});
+
+describe('reduceAppEvent sessionWorkChanged', () => {
+  it('updates list-level main-turn liveness for an unopened session', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [makeSession('s1', '2026-01-01T00:00:00.000Z')],
+    };
+
+    const next = reduceAppEvent(
+      state,
+      {
+        type: 'sessionWorkChanged',
+        sessionId: 's1',
+        busy: true,
+        mainTurnActive: true,
+      },
+      { sessionId: 's1', seq: 1 },
+    );
+
+    expect(next.sessions[0]).toMatchObject({
+      busy: true,
+      mainTurnActive: true,
+    });
+    expect(next.turnActiveBySession['s1']).toBe(true);
+  });
+
+  it('updates the listed action-required fallback for an unopened session', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [makeSession('s1', '2026-01-01T00:00:00.000Z')],
+    };
+
+    const next = reduceAppEvent(
+      state,
+      {
+        type: 'sessionWorkChanged',
+        sessionId: 's1',
+        busy: true,
+        pendingInteraction: 'question',
+      },
+      { sessionId: 's1', seq: 1 },
+    );
+
+    expect(next.sessions[0]?.pendingInteraction).toBe('question');
+  });
+
+  it('clears streamed main-turn liveness while aggregate work remains busy', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [
+        {
+          ...makeSession('s1', '2026-01-01T00:00:00.000Z'),
+          busy: true,
+          mainTurnActive: true,
+        },
+      ],
+      turnActiveBySession: { s1: true },
+    };
+
+    const next = reduceAppEvent(
+      state,
+      {
+        type: 'sessionWorkChanged',
+        sessionId: 's1',
+        busy: true,
+        mainTurnActive: false,
+        pendingInteraction: 'none',
+      },
+      { sessionId: 's1', seq: 1 },
+    );
+
+    expect(next.sessions[0]).toMatchObject({ busy: true, mainTurnActive: false });
+    expect(next.turnActiveBySession['s1']).toBeUndefined();
+  });
+
+  it('clears stale main-turn liveness when an idle update omits the optional field', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [
+        {
+          ...makeSession('s1', '2026-01-01T00:00:00.000Z'),
+          busy: true,
+          mainTurnActive: true,
+        },
+      ],
+      turnActiveBySession: { s1: true },
+    };
+
+    const next = reduceAppEvent(
+      state,
+      {
+        type: 'sessionWorkChanged',
+        sessionId: 's1',
+        busy: false,
+      },
+      { sessionId: 's1', seq: 1 },
+    );
+
+    expect(next.sessions[0]).toMatchObject({ busy: false, mainTurnActive: false });
+    expect(next.turnActiveBySession['s1']).toBeUndefined();
+  });
+
+  it('clears a stale turn outcome when the update omits lastTurnReason', () => {
+    // An omitted last_turn_reason is authoritative ("no current outcome" —
+    // e.g. a fresh turn cleared the previous one), not "keep the old value".
+    const state = {
+      ...createInitialState(),
+      sessions: [
+        {
+          ...makeSession('s1', '2026-01-01T00:00:00.000Z'),
+          busy: false,
+          lastTurnReason: 'cancelled' as const,
+        },
+      ],
+    };
+
+    const cleared = reduceAppEvent(
+      state,
+      { type: 'sessionWorkChanged', sessionId: 's1', busy: true },
+      { sessionId: 's1', seq: 1 },
+    );
+    expect(cleared.sessions[0]?.lastTurnReason).toBeUndefined();
+
+    const set = reduceAppEvent(
+      state,
+      { type: 'sessionWorkChanged', sessionId: 's1', busy: false, lastTurnReason: 'failed' },
+      { sessionId: 's1', seq: 2 },
+    );
+    expect(set.sessions[0]?.lastTurnReason).toBe('failed');
+  });
+});
+
 describe('reduceAppEvent messageCreated', () => {
   it('bumps the session updatedAt so it floats to the top of the sidebar', () => {
     const state = {
@@ -394,3 +559,77 @@ describe('reduceAppEvent messageCreated cron origin', () => {
     expect(msgs.map((m) => m.id)).toEqual(['opt_1', 'cron_1']);
   });
 });
+
+describe('reduceAppEvent unknown agent error', () => {
+  function reduceRaw(raw: unknown): ReturnType<typeof reduceAppEvent> {
+    return reduceAppEvent(
+      createInitialState(),
+      { type: 'unknown', raw },
+      { sessionId: 's1', seq: 1 },
+    );
+  }
+
+  it('surfaces a rate-limit failure as a structured notice with full diagnostics', () => {
+    const next = reduceRaw({
+      _agentError: true,
+      code: 'provider.rate_limit',
+      message: 'Rate limit reached for requests. Please try again later.',
+      name: 'RateLimitError',
+      details: { statusCode: 429, requestId: 'req_1' },
+      retryable: true,
+    });
+    const notice = next.warnings[0];
+    expect(typeof notice).toBe('object');
+    if (typeof notice !== 'object' || notice === null) return;
+    expect(notice.severity).toBe('error');
+    expect(notice.title).toBe(i18n.global.t('warnings.agentError.rateLimit'));
+    expect(notice.message).toBe('Rate limit reached for requests. Please try again later.');
+    const byLabel = new Map(notice.details?.map((d) => [d.label, d.value]));
+    expect(byLabel.get(i18n.global.t('warnings.details.code'))).toBe('provider.rate_limit');
+    expect(byLabel.get(i18n.global.t('warnings.details.status'))).toBe('429');
+    expect(byLabel.get(i18n.global.t('warnings.details.requestId'))).toBe('req_1');
+    expect(byLabel.get(i18n.global.t('warnings.details.errorName'))).toBe('RateLimitError');
+  });
+
+  it('keeps extra detail fields such as finishReason visible', () => {
+    const next = reduceRaw({
+      _agentError: true,
+      code: 'provider.filtered',
+      message: 'Provider filtered the response',
+      details: { finishReason: 'filtered', rawFinishReason: 'content_filter' },
+    });
+    const notice = next.warnings[0];
+    if (typeof notice !== 'object' || notice === null) throw new Error('expected notice');
+    const values = notice.details?.map((d) => d.value) ?? [];
+    expect(values).toContain('filtered');
+    expect(values).toContain('content_filter');
+  });
+
+  it('shows a connection failure without status/requestId rows', () => {
+    const next = reduceRaw({
+      _agentError: true,
+      code: 'provider.connection_error',
+      message: 'Connection error.',
+    });
+    const notice = next.warnings[0];
+    if (typeof notice !== 'object' || notice === null) throw new Error('expected notice');
+    expect(notice.title).toBe(i18n.global.t('warnings.agentError.connection'));
+    expect(notice.message).toBe('Connection error.');
+    expect(notice.details?.map((d) => d.value)).toEqual(['provider.connection_error']);
+  });
+
+  it('falls back to the generic title for unmapped or missing codes', () => {
+    for (const code of ['internal', undefined]) {
+      const next = reduceRaw({ _agentError: true, code, message: 'boom' });
+      const notice = next.warnings[0];
+      if (typeof notice !== 'object' || notice === null) throw new Error('expected notice');
+      expect(notice.title).toBe(i18n.global.t('warnings.agentError.title'));
+      expect(notice.message).toBe('boom');
+    }
+  });
+
+  it('still renders agent warnings as plain strings', () => {
+    const next = reduceRaw({ _agentWarning: true, message: 'heads up' });
+    expect(next.warnings[0]).toBe(`${i18n.global.t('warnings.noteLabel')}: heads up`);
+  });
+});
diff --git a/apps/kimi-web/test/index-html.test.ts b/apps/kimi-web/test/index-html.test.ts
new file mode 100644
index 000000000..860d8683d
--- /dev/null
+++ b/apps/kimi-web/test/index-html.test.ts
@@ -0,0 +1,33 @@
+// apps/kimi-web/test/index-html.test.ts
+// CSP regression guard: kap-server serves the built bundle with
+// `Content-Security-Policy: default-src 'self'; …` (see securityHeaders.ts),
+// which forbids inline scripts and inline event handlers. index.html must
+// therefore stay free of both, and the anti-FOUC color-scheme bootstrap must
+// load from the external /boot.js.
+
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+const indexHtml = readFileSync(fileURLToPath(new URL('../index.html', import.meta.url)), 'utf-8');
+const bootJsPath = fileURLToPath(new URL('../public/boot.js', import.meta.url));
+
+describe('index.html CSP hygiene', () => {
+  it('has no <script> tag without a src attribute', () => {
+    const scriptTags = indexHtml.match(/<script\b[^>]*>/gi) ?? [];
+    expect(scriptTags.length).toBeGreaterThan(0);
+    for (const tag of scriptTags) {
+      expect(tag).toMatch(/\bsrc\s*=/);
+    }
+  });
+
+  it('has no inline event-handler attributes', () => {
+    expect(indexHtml).not.toMatch(/\son[a-z]+\s*=/i);
+  });
+
+  it('loads the anti-FOUC bootstrap from the external /boot.js', () => {
+    expect(indexHtml).toContain('<script src="/boot.js"></script>');
+    expect(existsSync(bootJsPath)).toBe(true);
+  });
+});
diff --git a/apps/kimi-web/test/lib-logic.test.ts b/apps/kimi-web/test/lib-logic.test.ts
index 25b7ec744..36f3f8eda 100644
--- a/apps/kimi-web/test/lib-logic.test.ts
+++ b/apps/kimi-web/test/lib-logic.test.ts
@@ -9,7 +9,7 @@ import { buildDiffLines } from '../src/lib/diffLines';
 import { buildEditDiffLines } from '../src/lib/toolDiff';
 import { createCoalescedAsyncRunner } from '../src/lib/snapshotSync';
 import { mergeSnapshotMessages } from '../src/lib/snapshotMessages';
-import { mergeSnapshotSubagents } from '../src/lib/taskMerge';
+import { keepLiveSubagents, mergeSnapshotSubagents } from '../src/lib/taskMerge';
 import { normalizeToolName, toolSummary } from '../src/lib/toolMeta';
 import { collapsePrompt, humanizeCron } from '../src/lib/cronHumanize';
 import {
@@ -704,7 +704,7 @@ describe('mergeSnapshotSubagents', () => {
       sessionId: 's1',
       kind: 'subagent',
       description: `task ${id}`,
-      status: 'running',
+      busy: true,
       createdAt: '2026-01-01T00:00:00.000Z',
       ...overrides,
     };
@@ -739,7 +739,7 @@ describe('mergeSnapshotSubagents', () => {
       sessionId: 's1',
       kind: 'bash',
       description: 'npm test',
-      status: 'running',
+      busy: true,
       createdAt: '2026-01-01T00:00:00.000Z',
     };
     const roster = [subagent('a1')];
@@ -752,3 +752,114 @@ describe('mergeSnapshotSubagents', () => {
     expect(mergeSnapshotSubagents([], existing)).toBe(existing);
   });
 });
+
+
+describe('keepLiveSubagents', () => {
+  function subagent(id: string, overrides: Partial<AppTask> = {}): AppTask {
+    return {
+      id,
+      sessionId: 's1',
+      kind: 'subagent',
+      description: `task ${id}`,
+      status: 'running',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      ...overrides,
+    };
+  }
+
+  it('returns the REST list untouched when no live-only subagent exists', () => {
+    const rest = [subagent('a1')];
+    expect(keepLiveSubagents(rest, [subagent('a1')])).toBe(rest);
+  });
+
+  it('keeps WS-only swarm subagents that REST omits', () => {
+    const rest: AppTask[] = [];
+    const merged = keepLiveSubagents(rest, [subagent('a1')]);
+    expect(merged.map((t) => t.id)).toEqual(['a1']);
+  });
+
+  it('folds a REST background-subagent row into the WS row keyed by agent id', () => {
+    // The same background subagent: WS keys it by agent id, REST by task id.
+    const live = subagent('agent-1', {
+      runInBackground: true,
+      backgroundTaskId: 'task-9',
+      outputLines: ['step 1'],
+      text: 'partial',
+    });
+    const rest = [subagent('task-9', { runInBackground: true })];
+    const merged = keepLiveSubagents(rest, [live]);
+    expect(merged).toHaveLength(1);
+    expect(merged[0]?.id).toBe('agent-1');
+    expect(merged[0]?.outputLines).toEqual(['step 1']);
+    expect(merged[0]?.text).toBe('partial');
+    expect(merged[0]?.backgroundTaskId).toBe('task-9');
+  });
+
+  it('lets REST complete a live row whose finish event was missed', () => {
+    const live = subagent('agent-1', {
+      runInBackground: true,
+      backgroundTaskId: 'task-9',
+      subagentPhase: 'working',
+    });
+    const rest = [
+      subagent('task-9', {
+        runInBackground: true,
+        status: 'completed',
+        completedAt: '2026-01-01T00:01:00.000Z',
+        outputPreview: 'done',
+      }),
+    ];
+    const [merged] = keepLiveSubagents(rest, [live]);
+    expect(merged?.status).toBe('completed');
+    // The detail panel prefers subagentPhase over status — it must follow too.
+    expect(merged?.subagentPhase).toBe('completed');
+    expect(merged?.completedAt).toBe('2026-01-01T00:01:00.000Z');
+    expect(merged?.outputPreview).toBe('done');
+  });
+
+  it('maps a REST-cancelled row to the failed phase (the enum has no cancelled)', () => {
+    const live = subagent('agent-1', {
+      runInBackground: true,
+      backgroundTaskId: 'task-9',
+      subagentPhase: 'working',
+    });
+    const rest = [subagent('task-9', { runInBackground: true, status: 'cancelled' })];
+    const [merged] = keepLiveSubagents(rest, [live]);
+    expect(merged?.status).toBe('cancelled');
+    expect(merged?.subagentPhase).toBe('failed');
+  });
+
+  it('never lets a lagging poll flip a finished row back to running', () => {
+    const live = subagent('agent-1', {
+      runInBackground: true,
+      backgroundTaskId: 'task-9',
+      status: 'completed',
+      completedAt: '2026-01-01T00:01:00.000Z',
+    });
+    const rest = [subagent('task-9', { runInBackground: true, status: 'running' })];
+    const [merged] = keepLiveSubagents(rest, [live]);
+    expect(merged?.status).toBe('completed');
+  });
+
+  it('keeps newer REST output flowing into an already-folded row', () => {
+    // The live row carries a preview folded in by an earlier poll; the fresh
+    // REST row has the final persisted output and must win.
+    const live = subagent('agent-1', {
+      runInBackground: true,
+      backgroundTaskId: 'task-9',
+      outputPreview: 'stale tail',
+      outputBytes: 100,
+    });
+    const rest = [
+      subagent('task-9', {
+        runInBackground: true,
+        status: 'completed',
+        outputPreview: 'final result',
+        outputBytes: 200,
+      }),
+    ];
+    const [merged] = keepLiveSubagents(rest, [live]);
+    expect(merged?.outputPreview).toBe('final result');
+    expect(merged?.outputBytes).toBe(200);
+  });
+});
diff --git a/apps/kimi-web/test/open-file-attachment.test.ts b/apps/kimi-web/test/open-file-attachment.test.ts
new file mode 100644
index 000000000..515b8a64b
--- /dev/null
+++ b/apps/kimi-web/test/open-file-attachment.test.ts
@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { openFileAttachment } from '../src/lib/openFileAttachment';
+
+// The module under test reads the daemon API client; stub the file-byte fetch.
+const mocks = vi.hoisted(() => ({ getFileBlob: vi.fn() }));
+vi.mock('../src/api', () => ({
+  getKimiWebApi: () => ({ getFileBlob: mocks.getFileBlob }),
+}));
+
+interface WinHandle {
+  location: { href: string };
+  close: ReturnType<typeof vi.fn>;
+  opener: unknown;
+}
+
+describe('openFileAttachment', () => {
+  let win: WinHandle;
+  let windowOpen: ReturnType<typeof vi.fn>;
+  let createObjectURL: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    win = { location: { href: '' }, close: vi.fn(), opener: {} };
+    windowOpen = vi.fn().mockReturnValue(win);
+    createObjectURL = vi.fn().mockReturnValue('blob:mock-url');
+    (globalThis as { window?: unknown }).window = { open: windowOpen };
+    (globalThis.URL as unknown as { createObjectURL: unknown }).createObjectURL = createObjectURL;
+    (globalThis.URL as unknown as { revokeObjectURL: unknown }).revokeObjectURL = vi.fn();
+    mocks.getFileBlob.mockResolvedValue(new Blob(['<h1>x</h1>'], { type: 'text/html' }));
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    delete (globalThis as { window?: unknown }).window;
+  });
+
+  /** The MIME of the blob handed to createObjectURL most recently. */
+  function previewedBlobType(): string {
+    const blob = createObjectURL.mock.calls.at(-1)?.[0] as Blob;
+    return blob.type;
+  }
+
+  it('refuses to preview text/html — an active document would run same-origin', async () => {
+    const result = await openFileAttachment('f_1', 'page.html', 'text/html');
+    expect(result).toBe('unsupported');
+    expect(windowOpen).not.toHaveBeenCalled();
+  });
+
+  it('refuses to preview image/svg+xml — SVG carries script when navigated', async () => {
+    const result = await openFileAttachment('f_1', 'vector.svg', 'image/svg+xml');
+    expect(result).toBe('unsupported');
+    expect(windowOpen).not.toHaveBeenCalled();
+  });
+
+  it('refuses a .html extension even with an empty recorded MIME', async () => {
+    const result = await openFileAttachment('f_1', 'page.html', '');
+    expect(result).toBe('unsupported');
+  });
+
+  it('renders script source inert: text/* is pinned to text/plain, never executed', async () => {
+    const result = await openFileAttachment('f_1', 'a.js', 'text/javascript');
+    expect(result).toBe('previewed');
+    expect(previewedBlobType()).toBe('text/plain;charset=utf-8');
+  });
+
+  it('refuses non-text xml types outright', async () => {
+    expect(await openFileAttachment('f_1', 'a.xml', 'application/xml')).toBe('unsupported');
+    expect(await openFileAttachment('f_1', 'a.xhtml', 'application/xhtml+xml')).toBe('unsupported');
+  });
+
+  it('refuses an extensionless file with no usable MIME', async () => {
+    expect(await openFileAttachment('f_1', 'Makefile', '')).toBe('unsupported');
+  });
+
+  it('previews pdf / safe images / media with their whitelisted MIME', async () => {
+    expect(await openFileAttachment('f_1', 'a.pdf', 'application/pdf')).toBe('previewed');
+    expect(previewedBlobType()).toBe('application/pdf');
+    expect(await openFileAttachment('f_1', 'a.png', 'image/png')).toBe('previewed');
+    expect(previewedBlobType()).toBe('image/png');
+    expect(await openFileAttachment('f_1', 'a.mp4', 'video/mp4')).toBe('previewed');
+    expect(previewedBlobType()).toBe('video/mp4');
+  });
+
+  it('previews text but pins the blob to text/plain so it renders inert', async () => {
+    // A .html file uploaded with a plain-text label must NOT regain its active
+    // type — the blob is re-wrapped, never trusting the recorded content-type.
+    const result = await openFileAttachment('f_1', 'evil.html', 'text/plain');
+    expect(result).toBe('previewed');
+    expect(previewedBlobType()).toBe('text/plain;charset=utf-8');
+  });
+
+  it('previews text-ish extensions with an empty MIME as text/plain', async () => {
+    const result = await openFileAttachment('f_1', 'notes.md', '');
+    expect(result).toBe('previewed');
+    expect(previewedBlobType()).toBe('text/plain;charset=utf-8');
+  });
+
+  it('severs window.opener on the preview tab', async () => {
+    await openFileAttachment('f_1', 'a.pdf', 'application/pdf');
+    expect(win.opener).toBeNull();
+    expect(win.location.href).toBe('blob:mock-url');
+  });
+
+  it('closes the tab and reports failure when the byte fetch fails', async () => {
+    mocks.getFileBlob.mockRejectedValue(new Error('401'));
+    const result = await openFileAttachment('f_1', 'a.pdf', 'application/pdf');
+    expect(result).toBe('failed');
+    expect(win.close).toHaveBeenCalled();
+  });
+});
diff --git a/apps/kimi-web/test/side-chat.test.ts b/apps/kimi-web/test/side-chat.test.ts
index aee0073b4..4099737aa 100644
--- a/apps/kimi-web/test/side-chat.test.ts
+++ b/apps/kimi-web/test/side-chat.test.ts
@@ -22,7 +22,7 @@ function createState(): ExtendedState {
         title: 'Session',
         createdAt: '2026-01-01T00:00:00.000Z',
         updatedAt: '2026-01-01T00:00:00.000Z',
-        status: 'idle' as const,
+        busy: false as const,
         archived: false,
         currentPromptId: null,
         cwd: '/workspace',
diff --git a/apps/kimi-web/test/swarm-groups.test.ts b/apps/kimi-web/test/swarm-groups.test.ts
index a806de323..69703f9de 100644
--- a/apps/kimi-web/test/swarm-groups.test.ts
+++ b/apps/kimi-web/test/swarm-groups.test.ts
@@ -38,7 +38,7 @@ function bashTask(id: string): AppTask {
     sessionId: 'session-1',
     kind: 'bash',
     description: `bash ${id}`,
-    status: 'running',
+    busy: true,
     createdAt: '2026-01-01T00:00:00.000Z',
   };
 }
diff --git a/apps/kimi-web/test/task-poller.test.ts b/apps/kimi-web/test/task-poller.test.ts
new file mode 100644
index 000000000..0010d1759
--- /dev/null
+++ b/apps/kimi-web/test/task-poller.test.ts
@@ -0,0 +1,121 @@
+// Scenario: terminal-output backfill for background tasks (useTaskPoller).
+// Responsibilities: folded background-subagent rows must receive the output
+// fetched under their REST task id, and a transient getTask failure must not
+// permanently suppress later backfills.
+// Wiring: the composable is real; daemon requests are stubbed.
+// Run: pnpm --filter @moonshot-ai/kimi-web exec vitest run test/task-poller.test.ts
+
+import { computed } from 'vue';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { AppTask } from '../src/api/types';
+import { createInitialState } from '../src/api/daemon/eventReducer';
+import { useTaskPoller } from '../src/composables/client/useTaskPoller';
+import type { ExtendedState } from '../src/composables/useKimiWebClient';
+
+const apiMock = vi.hoisted(() => ({
+  listTasks: vi.fn(),
+  getTask: vi.fn(),
+}));
+
+vi.mock('../src/api', () => ({
+  getKimiWebApi: () => apiMock,
+}));
+
+function createState(tasks: AppTask[]): ExtendedState {
+  return {
+    ...createInitialState(),
+    activeSessionId: 'sess_1',
+    tasksBySession: { sess_1: tasks },
+  } as unknown as ExtendedState;
+}
+
+function subagent(id: string, overrides: Partial<AppTask> = {}): AppTask {
+  return {
+    id,
+    sessionId: 'sess_1',
+    kind: 'subagent',
+    description: `task ${id}`,
+    status: 'running',
+    createdAt: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+/** The same background subagent as seen on the two channels: WS keys it by
+    agent id, REST by background-task id (`backgroundTaskId` links them).
+    The live row is already completed so the poller's 1s output polling does
+    not start racing the one-off backfill under test. */
+function liveRow(): AppTask {
+  return subagent('agent-1', {
+    runInBackground: true,
+    backgroundTaskId: 'task-9',
+    status: 'completed',
+    completedAt: '2026-01-01T00:01:00.000Z',
+  });
+}
+function restRow(overrides: Partial<AppTask> = {}): AppTask {
+  return subagent('task-9', {
+    runInBackground: true,
+    status: 'completed',
+    completedAt: '2026-01-01T00:01:00.000Z',
+    ...overrides,
+  });
+}
+
+describe('useTaskPoller terminal-output backfill', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('attaches output fetched under the REST id to the folded agent-id row', async () => {
+    const state = createState([liveRow()]);
+    apiMock.listTasks.mockResolvedValue([restRow()]);
+    apiMock.getTask.mockResolvedValue(
+      restRow({ outputPreview: 'final result', outputBytes: 2048 }),
+    );
+
+    const poller = useTaskPoller(state, computed(() => []));
+    await poller.loadTasksForSession('sess_1');
+
+    expect(apiMock.getTask).toHaveBeenCalledWith(
+      'sess_1',
+      'task-9',
+      expect.objectContaining({ withOutput: true }),
+    );
+    const rows = state.tasksBySession['sess_1'] ?? [];
+    expect(rows.map((t) => t.id)).toEqual(['agent-1']);
+    expect(rows[0]?.status).toBe('completed');
+    expect(rows[0]?.outputPreview).toBe('final result');
+    expect(rows[0]?.outputBytes).toBe(2048);
+  });
+
+  it('fetches terminal output only once for a task', async () => {
+    const state = createState([liveRow()]);
+    apiMock.listTasks.mockResolvedValue([restRow()]);
+    apiMock.getTask.mockResolvedValue(
+      restRow({ outputPreview: 'final result', outputBytes: 2048 }),
+    );
+
+    const poller = useTaskPoller(state, computed(() => []));
+    await poller.loadTasksForSession('sess_1');
+    await poller.loadTasksForSession('sess_1');
+
+    expect(apiMock.getTask).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries the backfill on a later load after a transient getTask failure', async () => {
+    const state = createState([liveRow()]);
+    apiMock.listTasks.mockResolvedValue([restRow()]);
+    apiMock.getTask
+      .mockRejectedValueOnce(new Error('network blip'))
+      .mockResolvedValue(restRow({ outputPreview: 'final result', outputBytes: 2048 }));
+
+    const poller = useTaskPoller(state, computed(() => []));
+    await poller.loadTasksForSession('sess_1');
+    expect(state.tasksBySession['sess_1']?.[0]?.outputPreview).toBeUndefined();
+
+    await poller.loadTasksForSession('sess_1');
+    expect(apiMock.getTask).toHaveBeenCalledTimes(2);
+    expect(state.tasksBySession['sess_1']?.[0]?.outputPreview).toBe('final result');
+  });
+});
diff --git a/apps/kimi-web/test/turn-logic.test.ts b/apps/kimi-web/test/turn-logic.test.ts
index b7c6191d6..83d244538 100644
--- a/apps/kimi-web/test/turn-logic.test.ts
+++ b/apps/kimi-web/test/turn-logic.test.ts
@@ -212,11 +212,177 @@ describe('messagesToTurns', () => {
 
     expect(turns).toHaveLength(1);
     expect(turns[0]).toMatchObject({ role: 'user', text: 'look at this' });
-    expect(turns[0]?.images).toEqual([
-      { url: `/api/v1/files/${fileId}`, kind: 'video', alt: fileId, fileId },
+    expect(turns[0]?.attachments).toEqual([
+      { url: `/api/v1/files/${fileId}`, kind: 'video', fileId },
     ]);
   });
 
+  it('renders a non-media file part as a file attachment with name and size', () => {
+    const turns = messagesToTurns(
+      [
+        message('u1', 'user', [
+          { type: 'text', text: 'check these' },
+          { type: 'file', fileId: 'f_yaml', name: 'api-spec.yaml', mediaType: 'application/yaml', size: 18432 },
+          { type: 'file', fileId: 'f_pdf', name: '设计文档.pdf', mediaType: 'application/pdf', size: 2516582 },
+        ]),
+      ],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns).toHaveLength(1);
+    expect(turns[0]?.attachments).toEqual([
+      {
+        kind: 'file',
+        url: '/api/v1/files/f_yaml',
+        fileId: 'f_yaml',
+        name: 'api-spec.yaml',
+        mediaType: 'application/yaml',
+        size: 18432,
+      },
+      {
+        kind: 'file',
+        url: '/api/v1/files/f_pdf',
+        fileId: 'f_pdf',
+        name: '设计文档.pdf',
+        mediaType: 'application/pdf',
+        size: 2516582,
+      },
+    ]);
+  });
+
+  it('renders an extensionless file part with no mediaType as a file attachment', () => {
+    const turns = messagesToTurns(
+      [
+        message('u1', 'user', [
+          { type: 'file', fileId: 'f_make', name: 'Makefile', mediaType: '', size: 512 },
+        ]),
+      ],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns[0]?.attachments).toEqual([
+      { kind: 'file', url: '/api/v1/files/f_make', fileId: 'f_make', name: 'Makefile', mediaType: undefined, size: 512 },
+    ]);
+  });
+
+  it('recovers a file attachment from the server’s "Attached file" notice, not raw text', () => {
+    // After a resync the file part is gone from history — the kap-server prompt
+    // route replaced it with this notice. The chip must be rebuilt from the
+    // notice (fileId lives in the materialized basename) instead of dumping the
+    // absolute server path into the bubble.
+    const fileId = 'f_01KWK39A0ZC8R2ATZEQMD8716C';
+    const notice =
+      `Attached file "report.pdf" (application/pdf, 24 bytes): ` +
+      `/home/u/.kimi-code/sessions/s_1/attachments/${fileId}-report.pdf — open it with the Read tool`;
+    const turns = messagesToTurns(
+      [
+        message('u1', 'user', [
+          { type: 'text', text: 'summarize this' },
+          { type: 'text', text: notice },
+        ]),
+      ],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns).toHaveLength(1);
+    expect(turns[0]).toMatchObject({ role: 'user', text: 'summarize this' });
+    expect(turns[0]?.attachments).toEqual([
+      {
+        kind: 'file',
+        url: `/api/v1/files/${fileId}`,
+        fileId,
+        name: 'report.pdf',
+        mediaType: 'application/pdf',
+        size: 24,
+      },
+    ]);
+  });
+
+  it('recovers a non-clickable chip from an inline-base64 attachment notice (no fileId)', () => {
+    // Inline base64 uploads are materialized under a content hash, not a file
+    // id — the chip keeps name/size but has no bytes to open.
+    const notice =
+      'Attached file "image.avif" (image/avif, 100 bytes): ' +
+      '/home/u/.kimi-code/sessions/s_1/attachments/9f86d081884c7d659a2feaa0c55ad015-image.avif — open it with the Read tool';
+    const turns = messagesToTurns(
+      [message('u1', 'user', [{ type: 'text', text: notice }])],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns[0]?.text).toBe('');
+    expect(turns[0]?.attachments).toEqual([
+      { kind: 'file', url: '', fileId: undefined, name: 'image.avif', mediaType: 'image/avif', size: 100 },
+    ]);
+  });
+
+  it('recovers the full UUID file id from a v2 "Attached file" notice', () => {
+    // v2 file ids are `f_`<randomUUID> and contain hyphens themselves — a naive
+    // first-hyphen split would truncate the id and lose the clickable URL.
+    const fileId = 'f_550e8400-e29b-41d4-a716-446655440000';
+    const notice =
+      `Attached file "api-spec-v2.yaml" (application/yaml, 18 bytes): ` +
+      `/home/u/.kimi-code/sessions/s_1/attachments/${fileId}-api-spec-v2.yaml — open it with the Read tool`;
+    const turns = messagesToTurns(
+      [message('u1', 'user', [{ type: 'text', text: notice }])],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns[0]?.attachments).toEqual([
+      {
+        kind: 'file',
+        url: `/api/v1/files/${fileId}`,
+        fileId,
+        name: 'api-spec-v2.yaml',
+        mediaType: 'application/yaml',
+        size: 18,
+      },
+    ]);
+  });
+
+  it('renders a `<video path>` tag with a v2 UUID file id as a video attachment', () => {
+    const fileId = 'f_550e8400-e29b-41d4-a716-446655440000';
+    const turns = messagesToTurns(
+      [
+        message('u1', 'user', [
+          {
+            type: 'text',
+            text: `<video path="/Users/me/.kimi-code/cache/${fileId}.mp4"></video>`,
+          },
+        ]),
+      ],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns[0]?.attachments).toEqual([
+      { url: `/api/v1/files/${fileId}`, kind: 'video', fileId },
+    ]);
+  });
+
+  it('keeps lookalike text that is not an attachment notice as text', () => {
+    const text = 'Attached file "a.pdf" (application/pdf, 3 bytes): /tmp/x - open it with the Read tool';
+    const turns = messagesToTurns(
+      [message('u1', 'user', [{ type: 'text', text }])],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns[0]).toMatchObject({ role: 'user', text });
+    expect(turns[0]?.attachments).toBeUndefined();
+  });
+
   it('keeps the video tag as text when no file resolver is provided', () => {
     const tag =
       '<video path="/Users/me/.kimi-code/cache/f_01KWK39A0ZC8R2ATZEQMD8716C.mp4"></video>';
@@ -228,7 +394,7 @@ describe('messagesToTurns', () => {
     );
 
     expect(turns[0]).toMatchObject({ role: 'user', text: tag });
-    expect(turns[0]?.images).toBeUndefined();
+    expect(turns[0]?.attachments).toBeUndefined();
   });
 
   it('leaves non-file-store media paths as text instead of fabricating a url', () => {
@@ -244,7 +410,7 @@ describe('messagesToTurns', () => {
     );
 
     expect(turns[0]).toMatchObject({ role: 'user', text: tag });
-    expect(turns[0]?.images).toBeUndefined();
+    expect(turns[0]?.attachments).toBeUndefined();
   });
 
   it('strips the hidden image-compression caption from a user bubble', () => {
diff --git a/apps/kimi-web/test/workspace-state.test.ts b/apps/kimi-web/test/workspace-state.test.ts
index ef96f5967..4322a8895 100644
--- a/apps/kimi-web/test/workspace-state.test.ts
+++ b/apps/kimi-web/test/workspace-state.test.ts
@@ -1,3 +1,8 @@
+// Scenario: workspace/session actions exposed by useWorkspaceState.
+// Responsibilities: observable state and error reporting across load, paging, and user actions.
+// Wiring: the composable is real; daemon requests and unrelated facade collaborators are stubbed.
+// Run: pnpm --filter @moonshot-ai/kimi-web exec vitest run test/workspace-state.test.ts
+
 import { computed, ref, type Ref } from 'vue';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { AppApprovalRequest, AppQuestionRequest, AppSession, AppTask } from '../src/api/types';
@@ -41,7 +46,7 @@ function createSession(): AppSession {
     title: 'Session',
     createdAt: '2026-01-01T00:00:00.000Z',
     updatedAt: '2026-01-01T00:00:00.000Z',
-    status: 'running',
+    busy: true,
     archived: false,
     currentPromptId: 'prompt_live',
     cwd: '/workspace',
@@ -82,13 +87,18 @@ function createState(): ExtendedState {
     queuedBySession: {},
     gitStatusBySession: {},
     promptIdBySession: { sess_1: 'prompt_stale' },
-    sendingBySession: {},
+    inFlightBySession: {},
     unreadBySession: {},
     authReady: true,
     defaultModel: null,
     managedProviderStatus: null,
     workspaces: [],
     activeWorkspaceId: null,
+    sessionsHasMoreByWorkspace: {},
+    sessionsLoadingMoreByWorkspace: {},
+    sessionsCursorByWorkspace: {},
+    sessionsInitialCountByWorkspace: {},
+    sessionsFullyLoaded: false,
     fsHome: null,
     recentRoots: [],
     hiddenWorkspaceRoots: [],
@@ -110,7 +120,6 @@ function createDeps(): UseWorkspaceStateDeps {
     modelProvider: {},
     pushOperationFailure: vi.fn(),
     activity: computed(() => 'running'),
-    inFlightPromptSessions: new Set(),
     sessionsKnownEmpty: new Set(),
     setSessions: vi.fn(),
     updateSession: vi.fn(),
@@ -181,7 +190,7 @@ function installStorage(storage: Storage): void {
 }
 
 function workspace(id: string, root: string, name: string) {
-  return { id, root, name, isGitRepo: false, sessionCount: 0 };
+  return { id, root, name, sessionCount: 0 };
 }
 
 function questionRequest(questionId: string): AppQuestionRequest {
@@ -407,14 +416,12 @@ describe('mergeWorkspaces', () => {
       workspaces: [
         // Server orders by last_opened_at desc, so the most recently opened
         // (typically the canonical re-add) comes first.
-        { id: 'wd_current', root: '/agent/GEO', name: 'GEO', isGitRepo: false, sessionCount: 0 },
-        { id: 'wd_legacy', root: '/agent/GEO', name: 'GEO', isGitRepo: false, sessionCount: 0 },
+        { id: 'wd_current', root: '/agent/GEO', name: 'GEO', sessionCount: 0 },
+        { id: 'wd_legacy', root: '/agent/GEO', name: 'GEO', sessionCount: 0 },
       ],
       // A session whose daemon workspace_id points at the dropped (legacy) entry.
       sessions: [{ id: 's1', cwd: '/agent/GEO', workspaceId: 'wd_legacy' }],
       hiddenWorkspaceRoots: [],
-      activeRoot: undefined,
-      activeBranch: null,
       sessionsHasMoreByWorkspace: { wd_current: false },
     });
 
@@ -429,15 +436,13 @@ describe('mergeWorkspaces', () => {
   it('keeps distinct roots separate and appends derived cwds after real ones', () => {
     const result = mergeWorkspaces({
       workspaces: [
-        { id: 'wd_a', root: '/agent/A', name: 'A', isGitRepo: false, sessionCount: 1 },
+        { id: 'wd_a', root: '/agent/A', name: 'A', sessionCount: 1 },
       ],
       sessions: [
         { id: 's1', cwd: '/agent/A', workspaceId: 'wd_a' },
         { id: 's2', cwd: '/agent/B', workspaceId: 'wd_b' },
       ],
       hiddenWorkspaceRoots: [],
-      activeRoot: undefined,
-      activeBranch: null,
       sessionsHasMoreByWorkspace: {},
     });
 
@@ -448,12 +453,10 @@ describe('mergeWorkspaces', () => {
   it('hides workspaces whose root the user removed', () => {
     const result = mergeWorkspaces({
       workspaces: [
-        { id: 'wd_a', root: '/agent/A', name: 'A', isGitRepo: false, sessionCount: 1 },
+        { id: 'wd_a', root: '/agent/A', name: 'A', sessionCount: 1 },
       ],
       sessions: [{ id: 's1', cwd: '/agent/A', workspaceId: 'wd_a' }],
       hiddenWorkspaceRoots: ['/agent/A'],
-      activeRoot: undefined,
-      activeBranch: null,
       sessionsHasMoreByWorkspace: {},
     });
 
@@ -542,7 +545,6 @@ describe('useWorkspaceState — addWorkspaceByPath', () => {
       id: 'wd_abc',
       root: '/abs/path',
       name: 'path',
-      isGitRepo: false,
       sessionCount: 0,
     };
     apiMock.addWorkspace.mockResolvedValue(registered);
@@ -722,7 +724,7 @@ describe('useWorkspaceState — cancelTask', () => {
 });
 
 describe('useWorkspaceState — startSessionAndActivateSkill', () => {
-  const registered = { id: 'wd_1', root: '/abs/path', name: 'A', isGitRepo: false, sessionCount: 0 };
+  const registered = { id: 'wd_1', root: '/abs/path', name: 'A', sessionCount: 0 };
   const newSession = { ...createSession(), id: 'sess_new', workspaceId: 'wd_1', cwd: '/abs/path' };
 
   beforeEach(() => {
@@ -864,7 +866,7 @@ describe('useWorkspaceState — startSessionAndActivateSkill', () => {
 });
 
 describe('useWorkspaceState — createGoal from an empty composer', () => {
-  const registered = { id: 'wd_1', root: '/abs/path', name: 'A', isGitRepo: false, sessionCount: 0 };
+  const registered = { id: 'wd_1', root: '/abs/path', name: 'A', sessionCount: 0 };
   const newSession = { ...createSession(), id: 'sess_new', workspaceId: 'wd_1', cwd: '/abs/path' };
 
   beforeEach(() => {
@@ -1038,7 +1040,7 @@ describe('useWorkspaceState — createGoal from an empty composer', () => {
 });
 
 describe('useWorkspaceState — startSessionAndOpenSideChat', () => {
-  const registered = { id: 'wd_1', root: '/abs/path', name: 'A', isGitRepo: false, sessionCount: 0 };
+  const registered = { id: 'wd_1', root: '/abs/path', name: 'A', sessionCount: 0 };
   const newSession = { ...createSession(), id: 'sess_new', workspaceId: 'wd_1', cwd: '/abs/path' };
 
   beforeEach(() => {
@@ -1211,6 +1213,281 @@ describe('useWorkspaceState — first-load auth gate', () => {
   );
 });
 
+describe('useWorkspaceState — session list loading', () => {
+  beforeEach(() => {
+    apiMock.getAuth.mockReset().mockResolvedValue({
+      ready: true,
+      defaultModel: 'kimi-code',
+      managedProvider: null,
+    });
+    apiMock.getHealth.mockReset().mockResolvedValue({ ok: true });
+    apiMock.getMeta.mockReset().mockResolvedValue({
+      serverVersion: '0.0.0',
+      openInApps: [],
+      dangerousBypassAuth: false,
+      backend: 'v1',
+    });
+    apiMock.getConfig.mockReset().mockResolvedValue({});
+    apiMock.listWorkspaces.mockReset().mockResolvedValue([]);
+    apiMock.getFsHome.mockReset().mockResolvedValue({ home: '', recentRoots: [] });
+    apiMock.listSessions.mockReset();
+  });
+
+  function createSessionLoadRig(sessions: AppSession[]) {
+    const state = createState();
+    state.sessions = sessions;
+    state.activeSessionId = sessions[0]?.id ?? null;
+    const deps = {
+      ...createDeps(),
+      modelProvider: { loadModels: vi.fn().mockResolvedValue(undefined) },
+      initialized: ref(false),
+      connectIssue: ref<string | null>(null),
+      setSessions: vi.fn((next: AppSession[]) => {
+        state.sessions = next;
+      }),
+      workspaceIdForSession: vi.fn(
+        (session: { workspaceId?: string; cwd: string }) =>
+          state.workspaces.find((item) => item.root === session.cwd)?.id ??
+          session.workspaceId ??
+          session.cwd,
+      ),
+    } as unknown as UseWorkspaceStateDeps;
+    return { state, deps, workspaceState: useWorkspaceState(state, deps) };
+  }
+
+  it('reports one load failure when the no-workspace session fallback rejects', async () => {
+    const error = new Error('session index unavailable');
+    apiMock.listSessions.mockRejectedValue(error);
+    const { deps, workspaceState } = createSessionLoadRig([]);
+
+    await workspaceState.load();
+
+    expect(deps.pushOperationFailure).toHaveBeenCalledOnce();
+    expect(deps.pushOperationFailure).toHaveBeenCalledWith('load', error);
+  });
+
+  it('keeps failed workspace sessions while replacing a successful shared-root workspace', async () => {
+    const error = new Error('legacy workspace unavailable');
+    const cached = {
+      ...createSession(),
+      id: 'sess_cached',
+      title: 'Cached legacy',
+      workspaceId: 'wd_legacy',
+      updatedAt: '2026-01-02T00:00:00.000Z',
+    };
+    const fresh = {
+      ...createSession(),
+      id: 'sess_fresh',
+      title: 'Fresh current',
+      workspaceId: 'wd_current',
+      updatedAt: '2026-01-03T00:00:00.000Z',
+    };
+    const staleCurrent = {
+      ...createSession(),
+      id: 'sess_stale',
+      title: 'Stale current',
+      workspaceId: 'wd_current',
+      updatedAt: '2026-01-01T00:00:00.000Z',
+    };
+    apiMock.listWorkspaces.mockResolvedValue([
+      workspace('wd_current', '/workspace', 'Workspace'),
+      workspace('wd_legacy', '/workspace', 'Workspace'),
+    ]);
+    apiMock.listSessions.mockImplementation(
+      async ({ workspaceId }: { workspaceId?: string }) => {
+        if (workspaceId === 'wd_current') return { items: [fresh], hasMore: false };
+        throw error;
+      },
+    );
+    const { state, deps, workspaceState } = createSessionLoadRig([cached, staleCurrent]);
+
+    await workspaceState.load();
+
+    expect(state.sessions.map((session) => session.id)).toEqual(['sess_fresh', 'sess_cached']);
+    expect(deps.pushOperationFailure).toHaveBeenCalledOnce();
+    expect(deps.pushOperationFailure).toHaveBeenCalledWith('load', error);
+  });
+
+  it('keeps root-matched sessions when their stored workspace id is no longer registered', async () => {
+    const error = new Error('current workspace unavailable');
+    const cached = {
+      ...createSession(),
+      id: 'sess_cached',
+      title: 'Cached old workspace id',
+      workspaceId: 'wd_removed',
+      updatedAt: '2026-01-02T00:00:00.000Z',
+    };
+    const fresh = {
+      ...createSession(),
+      id: 'sess_fresh',
+      title: 'Fresh other workspace',
+      cwd: '/other-workspace',
+      workspaceId: 'wd_other',
+      updatedAt: '2026-01-03T00:00:00.000Z',
+    };
+    apiMock.listWorkspaces.mockResolvedValue([
+      workspace('wd_current', '/workspace', 'Workspace'),
+      workspace('wd_other', '/other-workspace', 'Other'),
+    ]);
+    apiMock.listSessions.mockImplementation(
+      async ({ workspaceId }: { workspaceId?: string }) => {
+        if (workspaceId === 'wd_current') throw error;
+        return { items: [fresh], hasMore: false };
+      },
+    );
+    const { state, deps, workspaceState } = createSessionLoadRig([cached]);
+
+    await workspaceState.load();
+
+    expect(state.sessions.map((session) => session.id)).toEqual(['sess_fresh', 'sess_cached']);
+    expect(deps.pushOperationFailure).toHaveBeenCalledOnce();
+    expect(deps.pushOperationFailure).toHaveBeenCalledWith('load', error);
+  });
+
+  it('loads the next page when a retry follows an automatic continuation failure', async () => {
+    const error = new Error('automatic continuation unavailable');
+    const cached = {
+      ...createSession(),
+      title: 'Cached first page',
+      workspaceId: 'wd_1',
+      updatedAt: '2099-01-01T00:00:00.000Z',
+    };
+    const fresh = { ...cached, title: 'Fresh first page' };
+    const older = {
+      ...createSession(),
+      id: 'sess_older',
+      workspaceId: 'wd_1',
+      updatedAt: '2025-12-31T00:00:00.000Z',
+    };
+    apiMock.listWorkspaces.mockResolvedValue([workspace('wd_1', '/workspace', 'Workspace')]);
+    apiMock.listSessions
+      .mockResolvedValueOnce({ items: [fresh], hasMore: true })
+      .mockRejectedValueOnce(error)
+      .mockResolvedValue({ items: [older], hasMore: false });
+    const { state, deps, workspaceState } = createSessionLoadRig([cached]);
+
+    await workspaceState.load();
+
+    expect(state.sessions.map((session) => session.title)).toEqual(['Fresh first page']);
+    expect(deps.pushOperationFailure).toHaveBeenCalledWith('load', error);
+
+    await workspaceState.loadMoreSessions('wd_1');
+
+    expect(state.sessions.map((session) => session.id)).toEqual(['sess_1', 'sess_older']);
+    expect(deps.pushOperationFailure).toHaveBeenCalledOnce();
+  });
+
+  it('recovers the global session list when a retry follows a second-page failure', async () => {
+    const error = new Error('global continuation unavailable');
+    const cached = { ...createSession(), title: 'Cached first page' };
+    const fresh = {
+      ...cached,
+      title: 'Fresh first page',
+      updatedAt: '2026-01-02T00:00:00.000Z',
+    };
+    const older = {
+      ...createSession(),
+      id: 'sess_older',
+      updatedAt: '2025-12-31T00:00:00.000Z',
+    };
+    const cachedOlder = { ...older, title: 'Cached older page' };
+    apiMock.listSessions
+      .mockResolvedValueOnce({ items: [fresh], hasMore: true })
+      .mockRejectedValueOnce(error)
+      .mockResolvedValue({ items: [fresh, older], hasMore: false });
+    const { state, deps, workspaceState } = createSessionLoadRig([cached, cachedOlder]);
+
+    await workspaceState.load();
+
+    expect(state.sessions.map((session) => session.title)).toEqual([
+      'Fresh first page',
+      'Cached older page',
+    ]);
+    expect(deps.pushOperationFailure).toHaveBeenCalledOnce();
+    expect(deps.pushOperationFailure).toHaveBeenCalledWith('load', error);
+
+    await workspaceState.load();
+
+    expect(state.sessions.map((session) => session.id)).toEqual(['sess_1', 'sess_older']);
+  });
+
+  it('preserves cached sessions when every workspace initial page rejects', async () => {
+    const firstError = new Error('workspace A unavailable');
+    const cachedA = {
+      ...createSession(),
+      id: 'sess_a',
+      cwd: '/workspace-a',
+      workspaceId: 'wd_a',
+    };
+    const cachedB = {
+      ...createSession(),
+      id: 'sess_b',
+      cwd: '/workspace-b',
+      workspaceId: 'wd_b',
+    };
+    apiMock.listWorkspaces.mockResolvedValue([
+      workspace('wd_a', '/workspace-a', 'A'),
+      workspace('wd_b', '/workspace-b', 'B'),
+    ]);
+    apiMock.listSessions.mockImplementation(
+      async ({ workspaceId }: { workspaceId?: string }) => {
+        if (workspaceId === 'wd_a') throw firstError;
+        throw new Error('workspace B unavailable');
+      },
+    );
+    const { state, deps, workspaceState } = createSessionLoadRig([cachedA, cachedB]);
+
+    await workspaceState.load();
+
+    expect(state.sessions.map((session) => session.id)).toEqual(['sess_a', 'sess_b']);
+    expect(deps.pushOperationFailure).toHaveBeenCalledOnce();
+    expect(deps.pushOperationFailure).toHaveBeenCalledWith('load', firstError);
+  });
+
+  it('loads workspace sessions when a retry follows an initial failure', async () => {
+    const cached = {
+      ...createSession(),
+      title: 'Cached',
+      workspaceId: 'wd_1',
+    };
+    const recovered = { ...cached, title: 'Recovered' };
+    apiMock.listWorkspaces.mockResolvedValue([workspace('wd_1', '/workspace', 'Workspace')]);
+    apiMock.listSessions
+      .mockRejectedValueOnce(new Error('session index unavailable'))
+      .mockResolvedValue({ items: [recovered], hasMore: false });
+    const { state, workspaceState } = createSessionLoadRig([cached]);
+
+    await workspaceState.load();
+    await workspaceState.load();
+
+    expect(state.sessions.map((session) => session.title)).toEqual(['Recovered']);
+  });
+
+  it('loads the next workspace page when a retry follows a rejection', async () => {
+    const loaded = { ...createSession(), workspaceId: 'wd_1' };
+    const older = {
+      ...createSession(),
+      id: 'sess_older',
+      workspaceId: 'wd_1',
+      updatedAt: '2025-12-31T00:00:00.000Z',
+    };
+    const { state, deps, workspaceState } = createSessionLoadRig([loaded]);
+    state.workspaces = [workspace('wd_1', '/workspace', 'Workspace')];
+    state.sessionsHasMoreByWorkspace = { wd_1: true };
+    state.sessionsCursorByWorkspace = { wd_1: 'sess_1' };
+    state.sessionsLoadingMoreByWorkspace = { wd_1: false };
+    apiMock.listSessions
+      .mockRejectedValueOnce(new Error('next page unavailable'))
+      .mockResolvedValue({ items: [older], hasMore: false });
+
+    await workspaceState.loadMoreSessions('wd_1');
+    await workspaceState.loadMoreSessions('wd_1');
+
+    expect(state.sessions.map((session) => session.id)).toEqual(['sess_1', 'sess_older']);
+    expect(deps.pushOperationFailure).toHaveBeenCalledOnce();
+  });
+});
+
 // /meta re-read on every WS (re)connect — keeps version / backend truthful
 // across backend restarts and dev-proxy backend switches.
 describe('useWorkspaceState — refreshServerMeta', () => {
@@ -1266,17 +1543,15 @@ describe('useWorkspaceState — snapshot prompt recovery', () => {
 
   it('clears a finished prompt from a terminal snapshot so the next send is immediate', async () => {
     const state = createState();
-    const inFlight = new Set(['sess_1']);
-    state.sendingBySession = { sess_1: true };
+    state.inFlightBySession = { sess_1: true };
     const ws = useWorkspaceState(
       state,
-      promptDeps({ inFlightPromptSessions: inFlight, activity: computed(() => 'idle') }),
+      promptDeps({ activity: computed(() => 'idle') }),
     );
 
-    ws.handleSessionSnapshot('sess_1', { inFlightTurn: null, status: 'idle' });
+    ws.handleSessionSnapshot('sess_1', { inFlightTurn: null, busy: false });
 
-    expect(inFlight.has('sess_1')).toBe(false);
-    expect(state.sendingBySession.sess_1).toBe(false);
+    expect(state.inFlightBySession.sess_1).toBe(false);
     expect(state.promptIdBySession.sess_1).toBeUndefined();
 
     await ws.sendPrompt('next');
@@ -1286,33 +1561,64 @@ describe('useWorkspaceState — snapshot prompt recovery', () => {
 
   it('keeps a genuinely running prompt in flight and queues the next send', async () => {
     const state = createState();
-    const inFlight = new Set(['sess_1']);
-    state.sendingBySession = { sess_1: true };
-    const ws = useWorkspaceState(state, promptDeps({ inFlightPromptSessions: inFlight }));
+    state.inFlightBySession = { sess_1: true };
+    const ws = useWorkspaceState(state, promptDeps());
 
     ws.handleSessionSnapshot('sess_1', {
       inFlightTurn: { turnId: 1, assistantText: '', thinkingText: '', runningTools: [] },
-      status: 'running',
+      busy: true,
     });
     await ws.sendPrompt('next');
 
-    expect(inFlight.has('sess_1')).toBe(true);
-    expect(state.sendingBySession.sess_1).toBe(true);
+    expect(state.inFlightBySession.sess_1).toBe(true);
     expect(apiMock.submitPrompt).not.toHaveBeenCalled();
     expect(state.queuedBySession.sess_1).toEqual([{ text: 'next', attachments: undefined }]);
   });
 
+  it('drains one queued prompt when only background work remains', async () => {
+    const state = createState();
+    state.inFlightBySession = { sess_1: true };
+    state.promptIdBySession = { sess_1: 'prompt_old' };
+    state.queuedBySession = {
+      sess_1: [
+        { text: 'first queued', attachments: undefined },
+        { text: 'second queued', attachments: undefined },
+      ],
+    };
+    const ws = useWorkspaceState(state, promptDeps());
+
+    ws.handleSessionSnapshot('sess_1', { inFlightTurn: null, busy: true });
+
+    expect(apiMock.submitPrompt).toHaveBeenCalledOnce();
+    expect(state.queuedBySession.sess_1).toEqual([
+      { text: 'second queued', attachments: undefined },
+    ]);
+  });
+
+  it('clears local prompt state when busy disproves a stale snapshot turn', () => {
+    const state = createState();
+    state.inFlightBySession = { sess_1: true };
+    state.promptIdBySession = { sess_1: 'prompt_old' };
+    const ws = useWorkspaceState(state, promptDeps());
+
+    ws.handleSessionSnapshot('sess_1', {
+      inFlightTurn: { turnId: 1, assistantText: '', thinkingText: '', runningTools: [] },
+      busy: false,
+    });
+
+    expect(state.inFlightBySession.sess_1).toBe(false);
+    expect(state.promptIdBySession.sess_1).toBeUndefined();
+  });
+
   it('rejects a snapshot when a new local prompt started during the request', async () => {
     const state = createState();
-    const inFlight = new Set<string>();
-    const ws = useWorkspaceState(state, promptDeps({ inFlightPromptSessions: inFlight }));
+    const ws = useWorkspaceState(state, promptDeps());
     const atRequest = ws.localTurnStartState('sess_1');
 
     await ws.submitPromptInternal('sess_1', 'fresh prompt');
 
     expect(ws.isLocalTurnSnapshotCurrent('sess_1', atRequest)).toBe(false);
-    expect(inFlight.has('sess_1')).toBe(true);
-    expect(state.sendingBySession.sess_1).toBe(true);
+    expect(state.inFlightBySession.sess_1).toBe(true);
   });
 
   it('rejects a snapshot requested while the local submit is still pending', async () => {
@@ -1338,6 +1644,46 @@ describe('useWorkspaceState — snapshot prompt recovery', () => {
     expect(ws.localTurnStartState('sess_1').pending).toBe(false);
     expect(retrySnapshot).toHaveBeenCalledOnce();
   });
+
+  it('maps attachments to the matching content parts on submit (file parts included)', async () => {
+    const ws = useWorkspaceState(createState(), promptDeps());
+
+    await ws.submitPromptInternal('sess_1', 'look at these', [
+      { fileId: 'f_img', kind: 'image' },
+      { fileId: 'f_vid', kind: 'video' },
+      { fileId: 'f_pdf', kind: 'file', name: 'a.pdf', mediaType: 'application/pdf', size: 42 },
+    ]);
+
+    expect(apiMock.submitPrompt).toHaveBeenCalledWith(
+      'sess_1',
+      expect.objectContaining({
+        content: [
+          { type: 'text', text: 'look at these' },
+          { type: 'image', source: { kind: 'file', fileId: 'f_img' } },
+          { type: 'video', source: { kind: 'file', fileId: 'f_vid' } },
+          { type: 'file', fileId: 'f_pdf', name: 'a.pdf', mediaType: 'application/pdf', size: 42 },
+        ],
+      }),
+    );
+  });
+
+  it('normalizes an empty attachment MIME to application/octet-stream on submit', async () => {
+    const ws = useWorkspaceState(createState(), promptDeps());
+
+    await ws.submitPromptInternal('sess_1', 'look at this', [
+      { fileId: 'f_mk', kind: 'file', name: 'Makefile', mediaType: '', size: 10 },
+    ]);
+
+    expect(apiMock.submitPrompt).toHaveBeenCalledWith(
+      'sess_1',
+      expect.objectContaining({
+        content: [
+          { type: 'text', text: 'look at this' },
+          { type: 'file', fileId: 'f_mk', name: 'Makefile', mediaType: 'application/octet-stream', size: 10 },
+        ],
+      }),
+    );
+  });
 });
 
 // Regression: a search-triggered full session-list reload must not clobber the
diff --git a/apps/vis/server/src/lib/context-projector.ts b/apps/vis/server/src/lib/context-projector.ts
index df9271b3a..76cdec458 100644
--- a/apps/vis/server/src/lib/context-projector.ts
+++ b/apps/vis/server/src/lib/context-projector.ts
@@ -217,6 +217,9 @@ export function projectContext(
         }
         break;
       }
+      case 'context.update_token_count':
+        contextTokens = rec.tokenCount;
+        break;
       case 'context.clear':
         if (mode === 'model') {
           messages = [];
diff --git a/apps/vis/server/src/lib/session-store.ts b/apps/vis/server/src/lib/session-store.ts
index f10f7ad9d..fc74fa94c 100644
--- a/apps/vis/server/src/lib/session-store.ts
+++ b/apps/vis/server/src/lib/session-store.ts
@@ -20,15 +20,15 @@ export function isSafeAgentId(id: string): boolean {
 }
 
 interface StateJson {
-  createdAt?: string;
-  updatedAt?: string;
+  createdAt?: string | number;
+  updatedAt?: string | number;
   title?: string;
   isCustomTitle?: boolean;
   lastPrompt?: string;
   // Agent metadata comes from an untrusted state.json (a corrupt or imported
   // bundle may hold non-object entries like `{ "main": null }`), so the value
   // type allows null and inventoryAgents skips anything that isn't an object.
-  agents?: Record<string, { homedir: string; type: 'main' | 'sub' | 'independent'; parentAgentId: string | null; swarmItem?: string } | null>;
+  agents?: Record<string, { type: 'main' | 'sub' | 'independent'; parentAgentId?: string | null; swarmItem?: string } | null>;
   custom?: Record<string, unknown>;
 }
 
@@ -103,7 +103,7 @@ async function readImportedDetail(home: string, importId: string): Promise<Sessi
   // `agents` map. When the inventory comes back empty, fall back to probing
   // `agents/*` on disk so routes that require an agent (wire/context/…) still
   // resolve `main`.
-  let agents = await inventoryAgents(sessionDir, state, true);
+  let agents = await inventoryAgents(sessionDir, state);
   if (agents.length === 0) {
     agents = await discoverAgentsFromDisk(sessionDir);
   }
@@ -254,7 +254,7 @@ async function readSessionIndex(home: string): Promise<Map<string, SessionIndexE
   return out;
 }
 
-async function inventoryAgents(sessionDir: string, state: StateJson, deriveHomedir = false): Promise<AgentInfo[]> {
+async function inventoryAgents(sessionDir: string, state: StateJson): Promise<AgentInfo[]> {
   const result: AgentInfo[] = [];
   for (const [id, meta] of Object.entries(state.agents ?? {})) {
     if (!isSafeAgentId(id)) continue;
@@ -280,11 +280,8 @@ async function inventoryAgents(sessionDir: string, state: StateJson, deriveHomed
     result.push({
       agentId: id,
       type: meta.type,
-      parentAgentId: meta.parentAgentId,
-      // For imported bundles the persisted homedir is the exporting machine's
-      // absolute path; re-derive it from the local extraction so blob reads
-      // (which join homedir) resolve under the imported directory.
-      homedir: deriveHomedir ? join(sessionDir, 'agents', id) : meta.homedir,
+      parentAgentId: meta.parentAgentId ?? null,
+      homedir: join(sessionDir, 'agents', id),
       wireExists: readable,
       wireRecordCount: info.count,
       wireProtocolVersion: info.protocolVersion,
@@ -360,7 +357,8 @@ async function scanWire(path: string): Promise<{ count: number; protocolVersion:
   return { count, protocolVersion };
 }
 
-function parseTs(input: string | undefined): number {
+function parseTs(input: string | number | undefined): number {
+  if (typeof input === 'number') return Number.isFinite(input) ? input : 0;
   if (!input) return 0;
   const n = Date.parse(input);
   return Number.isFinite(n) ? n : 0;
diff --git a/apps/vis/server/test/fixtures/build.ts b/apps/vis/server/test/fixtures/build.ts
index e0149c0bd..03bc97631 100644
--- a/apps/vis/server/test/fixtures/build.ts
+++ b/apps/vis/server/test/fixtures/build.ts
@@ -1,9 +1,8 @@
-import { cp, mkdir, readFile, writeFile, rm } from 'node:fs/promises';
+import { cp, mkdir, writeFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-/** Copy a fixture session into a temp dir, rewriting state.json.agents.*.homedir
- *  to the real path so wire-reader / agent-tree can resolve them. */
+/** Copy a fixture session into a temporary KIMI_CODE_HOME. */
 export async function buildSessionFixture(name: string): Promise<{
   home: string;
   sessionDir: string;
@@ -16,14 +15,6 @@ export async function buildSessionFixture(name: string): Promise<{
   await mkdir(sessionsDir, { recursive: true });
   await cp(src, sessionDir, { recursive: true });
 
-  // Rewrite homedir placeholders.
-  const statePath = join(sessionDir, 'state.json');
-  const state = JSON.parse(await readFile(statePath, 'utf8'));
-  for (const id of Object.keys(state.agents)) {
-    state.agents[id].homedir = join(sessionDir, 'agents', id);
-  }
-  await writeFile(statePath, JSON.stringify(state, null, 2));
-
   // Write session_index.jsonl.
   await writeFile(
     join(home, 'session_index.jsonl'),
diff --git a/apps/vis/server/test/lib/context-projector.test.ts b/apps/vis/server/test/lib/context-projector.test.ts
index 0a5ded18f..1268753aa 100644
--- a/apps/vis/server/test/lib/context-projector.test.ts
+++ b/apps/vis/server/test/lib/context-projector.test.ts
@@ -785,6 +785,16 @@ describe('context-projector', () => {
     expect(proj.contextTokens).toBe(20); // 10+5+2+3, absolute (not summed across usage.record)
   });
 
+  it('uses context.update_token_count as the latest absolute context-token snapshot', () => {
+    const entries = [
+      { lineNo: 1, data: { type: 'context.update_token_count' as const, tokenCount: 42 }, raw: {} },
+    ];
+
+    const proj = projectContext(entries as any);
+
+    expect(proj.contextTokens).toBe(42);
+  });
+
   // ---- Fix ②: contextTokens updates on clear / compaction lifecycle events ---
   // agent-core ContextMemory sets _tokenCount on clear() (→ 0) and
   // applyCompaction(result) (→ result.tokensAfter), not only on step.end. These
diff --git a/apps/vis/server/test/lib/session-store.test.ts b/apps/vis/server/test/lib/session-store.test.ts
index b01caaa05..c6c596459 100644
--- a/apps/vis/server/test/lib/session-store.test.ts
+++ b/apps/vis/server/test/lib/session-store.test.ts
@@ -234,6 +234,53 @@ describe('session-store', () => {
     expect(sub.parentAgentId).toBe('main');
   });
 
+  it('ignores persisted agent homedirs and uses the standard paths', async () => {
+    const { home, sessionDir, cleanup: c } = await buildSessionFixture('sample-main');
+    cleanup = c;
+    const { readFile, writeFile } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    const statePath = join(sessionDir, 'state.json');
+    const state = JSON.parse(await readFile(statePath, 'utf8'));
+    delete state.agents.main.parentAgentId;
+    await writeFile(statePath, JSON.stringify(state));
+
+    const detail = await readSessionDetail(home, 'session_fixture');
+
+    expect(
+      detail!.agents
+        .map(({ agentId, homedir, parentAgentId }) => ({ agentId, homedir, parentAgentId }))
+        .toSorted((a, b) => a.agentId.localeCompare(b.agentId)),
+    ).toEqual([
+      {
+        agentId: 'agent-0',
+        homedir: join(sessionDir, 'agents', 'agent-0'),
+        parentAgentId: 'main',
+      },
+      {
+        agentId: 'main',
+        homedir: join(sessionDir, 'agents', 'main'),
+        parentAgentId: null,
+      },
+    ]);
+  });
+
+  it('reads v2 epoch millisecond timestamps', async () => {
+    const { home, sessionDir, cleanup: c } = await buildSessionFixture('sample-main');
+    cleanup = c;
+    const { readFile, writeFile } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    const statePath = join(sessionDir, 'state.json');
+    const state = JSON.parse(await readFile(statePath, 'utf8'));
+    state.createdAt = 1_784_012_345_678;
+    state.updatedAt = 1_784_023_456_789;
+    await writeFile(statePath, JSON.stringify(state));
+
+    const [summary] = await listSessions(home);
+
+    expect(summary!.createdAt).toBe(state.createdAt);
+    expect(summary!.updatedAt).toBe(state.updatedAt);
+  });
+
   it('surfaces swarmItem from state.json onto AgentInfo (null when absent)', async () => {
     const { home, sessionDir, cleanup: c } = await buildSessionFixture('sample-main');
     cleanup = c;
diff --git a/apps/vis/web/src/components/wire/renderers.tsx b/apps/vis/web/src/components/wire/renderers.tsx
index 6ec3eb67f..126ac3bde 100644
--- a/apps/vis/web/src/components/wire/renderers.tsx
+++ b/apps/vis/web/src/components/wire/renderers.tsx
@@ -217,6 +217,12 @@ export const WIRE_RENDERERS: RendererMap = {
     detail: (r) => <LoopEventDetail event={r.event} />,
   },
 
+  'context.update_token_count': {
+    tone: 'meta',
+    label: 'tokens',
+    headline: (r) => ({ main: <Dim>context {r.tokenCount} tok</Dim> }),
+  },
+
   'context.clear': {
     tone: 'warning',
     label: 'clear',
diff --git a/apps/vis/web/src/lib/analysis.ts b/apps/vis/web/src/lib/analysis.ts
index c1798ecf6..24a83e7ae 100644
--- a/apps/vis/web/src/lib/analysis.ts
+++ b/apps/vis/web/src/lib/analysis.ts
@@ -279,6 +279,17 @@ export function analyzeWire(entries: readonly WireEntry[]): Analysis {
         if (current) current.cancelled = true;
         break;
 
+      case 'context.update_token_count':
+        contextTokens = rec.tokenCount;
+        contextSeries.push({
+          lineNo: entry.lineNo,
+          time: t,
+          turnIndex: current?.index ?? -1,
+          step: -1,
+          contextTokens,
+        });
+        if (contextTokens > peakContext) peakContext = contextTokens;
+        break;
       case 'context.clear':
         contextTokens = 0;
         break;
diff --git a/apps/vis/web/test/analysis.test.ts b/apps/vis/web/test/analysis.test.ts
index 225e3ee92..f8986674d 100644
--- a/apps/vis/web/test/analysis.test.ts
+++ b/apps/vis/web/test/analysis.test.ts
@@ -131,4 +131,15 @@ describe('analyzeWire', () => {
     expect(a.contextSeries.map((p) => p.contextTokens)).toEqual([200, 200]);
     expect(a.summary.peakContextTokens).toBe(200);
   });
+
+  it('uses context.update_token_count as the absolute context-window fill', () => {
+    line = 0;
+    const a = analyzeWire([
+      e({ type: 'context.update_token_count', tokenCount: 42 }, 1),
+    ]);
+
+    expect(a.summary.contextTokens).toBe(42);
+    expect(a.summary.peakContextTokens).toBe(42);
+    expect(a.contextSeries.map((point) => point.contextTokens)).toEqual([42]);
+  });
 });
diff --git a/apps/vscode/.vscode-test.mjs b/apps/vscode/.vscode-test.mjs
new file mode 100644
index 000000000..f728f012c
--- /dev/null
+++ b/apps/vscode/.vscode-test.mjs
@@ -0,0 +1,5 @@
+import { defineConfig } from "@vscode/test-cli";
+
+export default defineConfig({
+  files: "out/test/**/*.test.js",
+});
diff --git a/apps/vscode/.vscode/launch.json b/apps/vscode/.vscode/launch.json
new file mode 100644
index 000000000..6a674b7ea
--- /dev/null
+++ b/apps/vscode/.vscode/launch.json
@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Kimi Code: Extension Development Host (isolated)",
+      "type": "extensionHost",
+      "request": "launch",
+      "preLaunchTask": "vscode: dev",
+      "args": [
+        "--extensionDevelopmentPath=${workspaceFolder}",
+        "--user-data-dir=${workspaceFolder}/../../.tmp/vscode-extension-dev/user-data",
+        "--extensions-dir=${workspaceFolder}/../../.tmp/vscode-extension-dev/extensions",
+        "--disable-workspace-trust",
+        "--skip-welcome",
+        "--skip-release-notes",
+        "${workspaceFolder}/../../.tmp/vscode-extension-dev/workspace"
+      ],
+      "env": {
+        "KIMI_CODE_HOME": "${workspaceFolder}/../../.tmp/vscode-extension-dev/kimi-home"
+      },
+      "outFiles": ["${workspaceFolder}/dist/**/*.js", "${workspaceFolder}/dist/**/*.mjs"],
+      "sourceMaps": true,
+      "resolveSourceMapLocations": [
+        "${workspaceFolder}/**",
+        "!**/node_modules/**"
+      ]
+    }
+  ]
+}
diff --git a/apps/vscode/.vscode/tasks.json b/apps/vscode/.vscode/tasks.json
new file mode 100644
index 000000000..948c22a2b
--- /dev/null
+++ b/apps/vscode/.vscode/tasks.json
@@ -0,0 +1,77 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "vscode: prepare isolated dev",
+      "type": "process",
+      "command": "pnpm",
+      "args": ["run", "dev:prepare"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "vscode: watch extension",
+      "type": "process",
+      "command": "pnpm",
+      "args": ["run", "dev:extension"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "isBackground": true,
+      "problemMatcher": {
+        "owner": "typescript",
+        "fileLocation": "absolute",
+        "pattern": {
+          "regexp": "^(.*?):(\\d+):(\\d+):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        },
+        "background": {
+          "activeOnStart": true,
+          "beginsPattern": ".*",
+          "endsPattern": "Extension dev build complete; watching for changes"
+        }
+      }
+    },
+    {
+      "label": "vscode: watch webview",
+      "type": "process",
+      "command": "pnpm",
+      "args": ["run", "dev:webview"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "isBackground": true,
+      "problemMatcher": {
+        "owner": "vite",
+        "fileLocation": "absolute",
+        "pattern": {
+          "regexp": "^(.*?):(\\d+):(\\d+):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        },
+        "background": {
+          "activeOnStart": true,
+          "beginsPattern": ".*",
+          "endsPattern": "built in \\d+.*ms"
+        }
+      }
+    },
+    {
+      "label": "vscode: dev",
+      "dependsOrder": "parallel",
+      "dependsOn": [
+        "vscode: prepare isolated dev",
+        "vscode: watch extension",
+        "vscode: watch webview"
+      ],
+      "problemMatcher": []
+    }
+  ]
+}
diff --git a/apps/vscode/.vscodeignore b/apps/vscode/.vscodeignore
new file mode 100644
index 000000000..726951204
--- /dev/null
+++ b/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
+../**
diff --git a/apps/vscode/CHANGELOG.md b/apps/vscode/CHANGELOG.md
new file mode 100644
index 000000000..e54cbf63b
--- /dev/null
+++ b/apps/vscode/CHANGELOG.md
@@ -0,0 +1,64 @@
+# Changelog
+
+## 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.
diff --git a/apps/vscode/LICENSE b/apps/vscode/LICENSE
new file mode 100644
index 000000000..7a4a3ea24
--- /dev/null
+++ b/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.
\ No newline at end of file
diff --git a/apps/vscode/README.md b/apps/vscode/README.md
new file mode 100644
index 000000000..ef73e4249
--- /dev/null
+++ b/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)
diff --git a/apps/vscode/docs/node-sdk-migration.md b/apps/vscode/docs/node-sdk-migration.md
new file mode 100644
index 000000000..92ba893d0
--- /dev/null
+++ b/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["v1 agent-core"]
+  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:
+
+- `userAgentProduct: "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 `@moonshot-ai/agent-core`.
+- 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 v1 agent-core 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.
diff --git a/apps/vscode/package.json b/apps/vscode/package.json
new file mode 100644
index 000000000..cfcc4f4d0
--- /dev/null
+++ b/apps/vscode/package.json
@@ -0,0 +1,312 @@
+{
+  "name": "kimi-code",
+  "publisher": "moonshot-ai",
+  "displayName": "Kimi Code",
+  "description": "Official Kimi Code plugin for VS Code",
+  "version": "0.6.1",
+  "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 all tool calls"
+        },
+        "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",
+    "@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",
+    "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-sdk": "workspace:^",
+    "@moonshot-ai/migration-legacy": "workspace:^",
+    "@radix-ui/react-accordion": "^1.2.12",
+    "@tabler/icons-react": "^3.36.0",
+    "ahooks": "^3.9.6",
+    "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"
+  }
+}
diff --git a/apps/vscode/resources/kimi-icon-storefront.png b/apps/vscode/resources/kimi-icon-storefront.png
new file mode 100644
index 000000000..033c0f4fb
Binary files /dev/null and b/apps/vscode/resources/kimi-icon-storefront.png differ
diff --git a/apps/vscode/resources/kimi-icon.svg b/apps/vscode/resources/kimi-icon.svg
new file mode 100644
index 000000000..db4631b8e
--- /dev/null
+++ b/apps/vscode/resources/kimi-icon.svg
@@ -0,0 +1,33 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+  <!-- body outline -->
+  <rect
+    x="3"
+    y="4.5"
+    width="18"
+    height="13"
+    rx="2.2"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="1.6"
+  />
+
+  <!-- left eye (filled) -->
+  <rect
+    x="9.6"
+    y="8.0"
+    width="1.4"
+    height="2.6"
+    rx="0.45"
+    fill="currentColor"
+  />
+
+  <!-- right eye (filled) -->
+  <rect
+    x="15.6"
+    y="8.0"
+    width="1.4"
+    height="2.6"
+    rx="0.45"
+    fill="currentColor"
+  />
+</svg>
diff --git a/apps/vscode/scripts/extension-host-smoke.d.mts b/apps/vscode/scripts/extension-host-smoke.d.mts
new file mode 100644
index 000000000..eb723df5b
--- /dev/null
+++ b/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>;
diff --git a/apps/vscode/scripts/extension-host-smoke.mjs b/apps/vscode/scripts/extension-host-smoke.mjs
new file mode 100644
index 000000000..03eeb2090
--- /dev/null
+++ b/apps/vscode/scripts/extension-host-smoke.mjs
@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { runTests, runVSCodeCommand } from "@vscode/test-electron";
+
+import { isMainModule } from "./vsix-targets.mjs";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const appDir = resolve(scriptDir, "..");
+const defaultCachePath = join(tmpdir(), "kimi-vscode-test-cache");
+
+export async function runExtensionHostSmoke(options = {}) {
+  const version = options.version ?? "stable";
+  const cacheRoot = resolve(options.cachePath ?? process.env.VSCODE_TEST_CACHE ?? defaultCachePath);
+  const vsixPath = resolve(options.vsixPath ?? defaultVsixPath());
+  await access(vsixPath);
+  await mkdir(cacheRoot, { recursive: true });
+
+  // A stable request must never reuse an older stable download. @vscode/test-electron
+  // falls back to a cached build when version discovery fails, which would turn an
+  // offline run into a false green. Exact versions remain cached by version.
+  const disposableCache = version === "stable";
+  const cachePath = disposableCache
+    ? await mkdtemp(join(cacheRoot, "stable-"))
+    : cacheRoot;
+
+  const root = await mkdtemp(join(tmpdir(), "kvh-"));
+  const paths = {
+    root,
+    extensions: join(root, "ext"),
+    installUserData: join(root, "install"),
+    userData: join(root, "user"),
+    kimiHome: join(root, "home"),
+    osHome: join(root, "os-home"),
+    workspace: join(root, "ws"),
+    harness: join(root, "harness"),
+    report: join(root, "extension-host-report.json"),
+  };
+
+  try {
+    await Promise.all([
+      paths.extensions,
+      paths.installUserData,
+      paths.userData,
+      paths.kimiHome,
+      paths.osHome,
+      paths.workspace,
+      paths.harness,
+    ].map((path) => mkdir(path, { recursive: true })));
+    await writeFile(join(paths.workspace, "README.md"), "# Kimi VSIX Extension Host smoke\n", "utf8");
+    await writeHarnessManifest(paths.harness);
+
+    const installProfileArgs = [
+      `--extensions-dir=${paths.extensions}`,
+      `--user-data-dir=${paths.installUserData}`,
+    ];
+    const profileArgs = [
+      `--extensions-dir=${paths.extensions}`,
+      `--user-data-dir=${paths.userData}`,
+    ];
+    const downloadOptions = { version, cachePath };
+    const install = await runVSCodeCommand(
+      ["--install-extension", vsixPath, "--force", ...installProfileArgs],
+      downloadOptions,
+    );
+    const installOutput = `${install.stdout}\n${install.stderr}`;
+    if (!/successfully installed|was successfully installed/i.test(installOutput)) {
+      throw new Error(`VSIX installation did not report success:\n${installOutput.trim()}`);
+    }
+
+    await runTests({
+      ...downloadOptions,
+      extensionDevelopmentPath: paths.harness,
+      extensionTestsPath: join(appDir, "test", "extension-host", "index.cjs"),
+      launchArgs: [
+        paths.workspace,
+        ...profileArgs,
+        "--disable-workspace-trust",
+        "--skip-welcome",
+        "--skip-release-notes",
+      ],
+      extensionTestsEnv: {
+        KIMI_CODE_HOME: paths.kimiHome,
+        KIMI_VSCODE_SMOKE_OS_HOME: paths.osHome,
+        KIMI_VSCODE_SMOKE_REPORT: paths.report,
+        KIMI_VSCODE_SMOKE_VSIX: basename(vsixPath),
+      },
+    });
+
+    const report = JSON.parse(await readFile(paths.report, "utf8"));
+    if (typeof report.vscode !== "string" || report.vscode.length === 0) {
+      throw new Error("Extension Host smoke did not report its actual VS Code version");
+    }
+    if (version !== "stable" && report.vscode !== version) {
+      throw new Error(
+        `Extension Host ran VS Code ${report.vscode}, expected requested version ${version}`,
+      );
+    }
+
+    return { version, vscodeVersion: report.vscode, vsixPath, cachePath };
+  } finally {
+    await Promise.all([
+      rm(root, { recursive: true, force: true }),
+      disposableCache ? rm(cachePath, { recursive: true, force: true }) : Promise.resolve(),
+    ]);
+  }
+}
+
+function defaultVsixPath() {
+  const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : process.arch;
+  return join(appDir, "artifacts", "vsix", `kimi-code-${process.platform}-${arch}.vsix`);
+}
+
+async function writeHarnessManifest(directory) {
+  await writeFile(
+    join(directory, "package.json"),
+    JSON.stringify({
+      name: "kimi-vscode-extension-host-smoke",
+      displayName: "Kimi VSCode Extension Host Smoke",
+      publisher: "local-test",
+      version: "0.0.0",
+      engines: { vscode: "^1.70.0" },
+      main: "./extension.cjs",
+      activationEvents: ["*"],
+    }),
+    "utf8",
+  );
+  await writeFile(
+    join(directory, "extension.cjs"),
+    "exports.activate = function activate() {}; exports.deactivate = function deactivate() {};\n",
+    "utf8",
+  );
+}
+
+function parseArguments(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--") continue;
+    if (argument === "--version") {
+      options.version = requiredValue(argv[++index], argument);
+    } else if (argument === "--vsix") {
+      options.vsixPath = requiredValue(argv[++index], argument);
+    } else if (argument === "--cache-path") {
+      options.cachePath = requiredValue(argv[++index], argument);
+    } else if (argument === "--help" || argument === "-h") {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown option: ${argument}`);
+    }
+  }
+  return options;
+}
+
+function requiredValue(value, flag) {
+  if (value === undefined || value.startsWith("-")) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.help) {
+    console.log("Usage: node scripts/extension-host-smoke.mjs [--version <stable|x.y.z>] [--vsix <path>] [--cache-path <path>]");
+    return;
+  }
+  const result = await runExtensionHostSmoke(options);
+  console.log(
+    `VSIX Extension Host smoke passed: ${result.vsixPath} on VS Code ${result.vscodeVersion} (requested ${result.version})`,
+  );
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`VSIX Extension Host smoke failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    process.exitCode = 1;
+  });
+}
diff --git a/apps/vscode/scripts/local-cli.mjs b/apps/vscode/scripts/local-cli.mjs
new file mode 100644
index 000000000..ccc29ae7e
--- /dev/null
+++ b/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;
+}
diff --git a/apps/vscode/scripts/ovsx-publish.mjs b/apps/vscode/scripts/ovsx-publish.mjs
new file mode 100644
index 000000000..05809c6bc
--- /dev/null
+++ b/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;
+  });
+}
diff --git a/apps/vscode/scripts/prepare-dev.mjs b/apps/vscode/scripts/prepare-dev.mjs
new file mode 100644
index 000000000..81f9fb8a9
--- /dev/null
+++ b/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;
+  });
+}
diff --git a/apps/vscode/scripts/publish-args.mjs b/apps/vscode/scripts/publish-args.mjs
new file mode 100644
index 000000000..ce2f095c2
--- /dev/null
+++ b/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');
+}
diff --git a/apps/vscode/scripts/vsix-package.mjs b/apps/vscode/scripts/vsix-package.mjs
new file mode 100644
index 000000000..0558e1eb8
--- /dev/null
+++ b/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;
+  });
+}
diff --git a/apps/vscode/scripts/vsix-publish.mjs b/apps/vscode/scripts/vsix-publish.mjs
new file mode 100644
index 000000000..e79524786
--- /dev/null
+++ b/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;
+  });
+}
diff --git a/apps/vscode/scripts/vsix-targets.mjs b/apps/vscode/scripts/vsix-targets.mjs
new file mode 100644
index 000000000..b3314ad41
--- /dev/null
+++ b/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;
+}
diff --git a/apps/vscode/scripts/vsix-verify.mjs b/apps/vscode/scripts/vsix-verify.mjs
new file mode 100644
index 000000000..b1e05219e
--- /dev/null
+++ b/apps/vscode/scripts/vsix-verify.mjs
@@ -0,0 +1,487 @@
+#!/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;
+  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;
+  });
+}
diff --git a/apps/vscode/scripts/watch-extension.mjs b/apps/vscode/scripts/watch-extension.mjs
new file mode 100644
index 000000000..35ed284cd
--- /dev/null
+++ b/apps/vscode/scripts/watch-extension.mjs
@@ -0,0 +1,97 @@
+#!/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'),
+  ...[
+    'agent-core',
+    '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;
+  });
+}
diff --git a/apps/vscode/scripts/zip.mjs b/apps/vscode/scripts/zip.mjs
new file mode 100644
index 000000000..27df84d44
--- /dev/null
+++ b/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}`);
+}
diff --git a/apps/vscode/shared/bridge.ts b/apps/vscode/shared/bridge.ts
new file mode 100644
index 000000000..805c1f32f
--- /dev/null
+++ b/apps/vscode/shared/bridge.ts
@@ -0,0 +1,324 @@
+/**
+ * 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");
+    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>";
+}
diff --git a/apps/vscode/shared/errors.ts b/apps/vscode/shared/errors.ts
new file mode 100644
index 000000000..4640b54ff
--- /dev/null
+++ b/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";
+}
diff --git a/apps/vscode/shared/fork-turn-index.ts b/apps/vscode/shared/fork-turn-index.ts
new file mode 100644
index 000000000..43268b578
--- /dev/null
+++ b/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
+  );
+}
diff --git a/apps/vscode/shared/legacy-sdk.ts b/apps/vscode/shared/legacy-sdk.ts
new file mode 100644
index 000000000..03c5bafbd
--- /dev/null
+++ b/apps/vscode/shared/legacy-sdk.ts
@@ -0,0 +1,227 @@
+/**
+ * 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;
+}
+
+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');
+}
diff --git a/apps/vscode/shared/types.ts b/apps/vscode/shared/types.ts
new file mode 100644
index 000000000..422aa5acc
--- /dev/null
+++ b/apps/vscode/shared/types.ts
@@ -0,0 +1,58 @@
+import type { RunResult, StreamEvent } from "./legacy-sdk";
+
+export interface SessionConfig {
+  model: string;
+  thinking?: boolean;
+  effort?: string;
+}
+
+export interface ProjectFile {
+  path: string;
+  name: string;
+  isDirectory: boolean;
+}
+
+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;
+}
+
+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";
diff --git a/apps/vscode/shared/utils.ts b/apps/vscode/shared/utils.ts
new file mode 100644
index 000000000..625f6c9ea
--- /dev/null
+++ b/apps/vscode/shared/utils.ts
@@ -0,0 +1,3 @@
+export function cleanSystemTags(text: string): string {
+  return text.replace(/<system>.*?<\/system>\s*/gs, "").trim();
+}
diff --git a/apps/vscode/src/KimiWebviewProvider.ts b/apps/vscode/src/KimiWebviewProvider.ts
new file mode 100644
index 000000000..2fed3fa09
--- /dev/null
+++ b/apps/vscode/src/KimiWebviewProvider.ts
@@ -0,0 +1,182 @@
+import * as vscode from "vscode";
+import type { KimiHarness } from "@moonshot-ai/kimi-code-sdk";
+import { Events } from "../shared/bridge";
+import { BridgeHandler } from "./bridge-handler";
+
+function getNonce(): string {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let nonce = "";
+  for (let i = 0; i < 32; i++) {
+    nonce += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return nonce;
+}
+
+/**
+ * Manages webview instances (sidebar and panels).
+ * Each webview gets a unique viewId for session isolation.
+ */
+export class KimiWebviewProvider implements vscode.WebviewViewProvider {
+  private webviews = new Map<string, vscode.Webview>();
+  private bridgeHandler: BridgeHandler;
+
+  constructor(
+    private readonly extensionUri: vscode.Uri,
+    context: vscode.ExtensionContext,
+    showLogs: () => void,
+    writeLog: (message: string) => void,
+  ) {
+    this.bridgeHandler = new BridgeHandler(
+      this.broadcastInternal.bind(this),
+      context.workspaceState,
+      context.globalStorageUri.fsPath,
+      this.reloadWebview.bind(this),
+      showLogs,
+      writeLog,
+    );
+  }
+
+  dispose(): void {
+    void this.bridgeHandler.dispose();
+  }
+
+  shutdown(): Promise<void> {
+    return this.bridgeHandler.dispose();
+  }
+
+  get harness(): KimiHarness {
+    return this.bridgeHandler.runtime.harness;
+  }
+
+  resolveWebviewView(webviewView: vscode.WebviewView): void {
+    const webviewId = `sidebar_${crypto.randomUUID()}`;
+    this.setupWebview(webviewId, webviewView.webview);
+
+    webviewView.onDidDispose(() => {
+      void this.bridgeHandler.disposeView(webviewId);
+      this.webviews.delete(webviewId);
+    });
+  }
+
+  createPanel(): vscode.WebviewPanel {
+    const webviewId = `panel_${crypto.randomUUID()}`;
+
+    const panel = vscode.window.createWebviewPanel("kimiPanel", "Kimi Code", vscode.ViewColumn.One, {
+      enableScripts: true,
+      retainContextWhenHidden: true,
+      localResourceRoots: [this.extensionUri],
+    });
+
+    this.setupWebview(webviewId, panel.webview);
+
+    panel.onDidDispose(() => {
+      void this.bridgeHandler.disposeView(webviewId);
+      this.webviews.delete(webviewId);
+    });
+
+    return panel;
+  }
+
+  broadcast(event: string, data: unknown): void {
+    this.broadcastInternal(event, data);
+  }
+
+  async insertEditorMention(documentUri: vscode.Uri, selection: vscode.Selection): Promise<boolean> {
+    let inserted = false;
+    await Promise.all(
+      [...this.webviews.keys()].map(async (webviewId) => {
+        const mention = await this.bridgeHandler.getEditorMention(webviewId, documentUri, selection);
+        if (mention === null) return;
+        inserted = true;
+        this.broadcastInternal(Events.InsertMention, { mention }, webviewId);
+      }),
+    );
+    return inserted;
+  }
+
+  private setupWebview(webviewId: string, webview: vscode.Webview): void {
+    webview.options = {
+      enableScripts: true,
+      localResourceRoots: [this.extensionUri],
+    };
+
+    webview.html = this.getHtml(webviewId, webview);
+    this.webviews.set(webviewId, webview);
+
+    webview.onDidReceiveMessage(async (msg: unknown) => {
+      const result = await this.bridgeHandler.handle(msg, webviewId);
+      webview.postMessage(result);
+    });
+  }
+
+  private broadcastInternal(event: string, data: unknown, targetWebviewId?: string): void {
+    const msg = { event, data };
+
+    if (targetWebviewId) {
+      void this.webviews.get(targetWebviewId)?.postMessage(msg);
+    } else {
+      this.webviews.forEach((webview) => {
+        void webview.postMessage(msg);
+      });
+    }
+  }
+
+  private reloadWebview(webviewId: string): void {
+    const webview = this.webviews.get(webviewId);
+    if (webview) {
+      webview.html = this.getHtml(webviewId, webview);
+    }
+  }
+
+  reloadAllWebviews(): void {
+    this.webviews.forEach((webview, webviewId) => {
+      webview.html = this.getHtml(webviewId, webview);
+    });
+  }
+
+  async resetAllWebviews(): Promise<void> {
+    await Promise.all(
+      [...this.webviews.keys()].map((webviewId) => this.bridgeHandler.disposeView(webviewId)),
+    );
+    this.reloadAllWebviews();
+  }
+
+  getBaselineContent(sessionId: string, filePath: string): Promise<string> {
+    return this.bridgeHandler.getBaselineContent(sessionId, filePath);
+  }
+
+  async setYoloModeForActiveSessions(enabled: boolean): Promise<void> {
+    await this.bridgeHandler.runtime.setYoloModeForActiveSessions(enabled);
+  }
+
+  private getHtml(webviewId: string, webview: vscode.Webview): string {
+    const scriptUri = webview.asWebviewUri(vscode.Uri.joinPath(this.extensionUri, "dist", "webview.js"));
+    const baseUri = webview.asWebviewUri(this.extensionUri).toString();
+    const nonce = getNonce();
+
+    const csp = [
+      `default-src 'none'`,
+      `style-src ${webview.cspSource} 'unsafe-inline'`,
+      `img-src ${webview.cspSource} data: blob:`,
+      `font-src ${webview.cspSource}`,
+      `media-src ${webview.cspSource} data: blob:`,
+      `connect-src ${webview.cspSource}`,
+      `worker-src ${webview.cspSource} blob:`,
+      `script-src 'nonce-${nonce}' ${webview.cspSource}`,
+    ].join("; ");
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="Content-Security-Policy" content="${csp}">
+  <title>Kimi Code</title>
+</head>
+<body data-baseuri="${baseUri}" data-webviewid="${webviewId}">
+  <div id="root"></div>
+  <script nonce="${nonce}" src="${scriptUri.toString()}"></script>
+</body>
+</html>`;
+  }
+}
diff --git a/apps/vscode/src/bridge-handler.ts b/apps/vscode/src/bridge-handler.ts
new file mode 100644
index 000000000..d1a5f5a7f
--- /dev/null
+++ b/apps/vscode/src/bridge-handler.ts
@@ -0,0 +1,336 @@
+import * as path from "node:path";
+import * as vscode from "vscode";
+
+import {
+  validateRpcMessage,
+  type RpcMethod,
+  type RpcResult,
+} from "../shared/bridge";
+import { VSCodeSettings } from "./config/vscode-settings";
+import { handlers, type BroadcastFn, type HandlerContext, type ReloadWebviewFn, type ShowLogsFn } from "./handlers";
+import { BaselineManager, type BaselineSession } from "./managers/baseline.manager";
+import { FileManager } from "./managers/file.manager";
+import { KimiRuntime } from "./runtime/kimi-runtime";
+import type { SessionRuntime } from "./runtime/session-runtime";
+import { areSameFsPath } from "./utils/fs-path";
+import {
+  isWorkspacePathContained,
+  isWorkspacePathContainedSync,
+  relativeWorkspacePath,
+  resolveWorkspacePath,
+  type WorkspacePath,
+  workDirUriFromPath,
+} from "./utils/workspace-path";
+
+export class BridgeHandler {
+  readonly baselineManager: BaselineManager;
+  readonly runtime: KimiRuntime;
+
+  private readonly customWorkDirs = new Map<string, string>();
+  private readonly fileManager: FileManager;
+
+  constructor(
+    private readonly broadcast: BroadcastFn,
+    private readonly workspaceState: vscode.Memento,
+    globalStoragePath: string,
+    private readonly reloadWebview: ReloadWebviewFn,
+    private readonly showLogs: ShowLogsFn,
+    private readonly writeLog: (message: string) => void,
+  ) {
+    this.runtime = new KimiRuntime({
+      version: VSCodeSettings.getExtensionConfig().version,
+      broadcast,
+      captureBaseline: (session, filePath, webviewIds) => {
+        this.captureFileBaseline(session, filePath, webviewIds);
+      },
+      log: (message, error) => this.logRuntimeError(message, error),
+    });
+    this.baselineManager = new BaselineManager(globalStoragePath, this.runtime.harness.homeDir);
+    this.fileManager = new FileManager(this.baselineManager, broadcast);
+  }
+
+  async handle(value: unknown, webviewId: string): Promise<RpcResult> {
+    const startedAt = Date.now();
+    const validation = validateRpcMessage(value);
+    if (!validation.ok) {
+      this.trace(validation.id, validation.method, Date.now() - startedAt, false);
+      this.logRuntimeError(`Bridge request rejected: ${validation.method}`, validation.error);
+      return { id: validation.id, error: validation.error };
+    }
+
+    const msg = validation.message;
+    try {
+      const result = await this.dispatch(msg.method, msg.params, webviewId);
+      this.trace(msg.id, msg.method, Date.now() - startedAt, true);
+      return { id: msg.id, result };
+    } catch (error) {
+      this.trace(msg.id, msg.method, Date.now() - startedAt, false);
+      this.logRuntimeError(`Bridge request failed: ${msg.method}`, error);
+      return {
+        id: msg.id,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  private get workspaceRoot(): string | null {
+    return this.workspaceRootUri?.fsPath ?? null;
+  }
+
+  private get workspaceRootUri(): vscode.Uri | null {
+    return vscode.workspace.workspaceFolders?.[0]?.uri ?? null;
+  }
+
+  private getWorkDir(webviewId: string): string | null {
+    return this.customWorkDirs.get(webviewId) ?? this.workspaceRoot;
+  }
+
+  private getWorkDirUri(webviewId: string): vscode.Uri | null {
+    const workspaceRoot = this.workspaceRoot;
+    const workspaceRootUri = this.workspaceRootUri;
+    const workDir = this.getWorkDir(webviewId);
+    if (workspaceRoot === null || workspaceRootUri === null || workDir === null) return null;
+    return workDirUriFromPath(workspaceRootUri, workspaceRoot, workDir) ?? null;
+  }
+
+  private async setCustomWorkDir(webviewId: string, workDir: string | null): Promise<void> {
+    const workspaceRoot = this.workspaceRoot;
+    const workspaceRootUri = this.workspaceRootUri;
+    if (workspaceRoot === null || workspaceRootUri === null) throw new Error("No workspace folder open");
+    if (workDir !== null) {
+      const workDirUri = workDirUriFromPath(workspaceRootUri, workspaceRoot, workDir);
+      if (workDirUri === undefined || !(await isWorkspacePathContained(workspaceRootUri, workDirUri))) {
+        throw new Error("Working directory must be within the workspace");
+      }
+    }
+    if (workDir && workDir !== this.workspaceRoot) {
+      this.customWorkDirs.set(webviewId, workDir);
+    } else {
+      this.customWorkDirs.delete(webviewId);
+    }
+    await this.runtime.detachView(webviewId);
+    this.fileManager.clearSession(webviewId);
+  }
+
+  private requireWorkDir(webviewId: string): string {
+    const workDir = this.getWorkDir(webviewId);
+    if (!workDir) throw new Error("No workspace folder open");
+    return workDir;
+  }
+
+  private requireWorkDirUri(webviewId: string): vscode.Uri {
+    const workDirUri = this.getWorkDirUri(webviewId);
+    if (!workDirUri) throw new Error("No workspace folder open");
+    return workDirUri;
+  }
+
+  private async dispatch(method: RpcMethod, params: unknown, webviewId: string): Promise<unknown> {
+    if (!Object.hasOwn(handlers, method)) throw new Error(`Unknown method: ${method}`);
+    const handler = handlers[method];
+    if (!handler) throw new Error(`Unknown method: ${method}`);
+    return handler(params, this.createContext(webviewId));
+  }
+
+  private createContext(webviewId: string): HandlerContext {
+    return {
+      webviewId,
+      workDir: this.getWorkDir(webviewId),
+      workDirUri: this.getWorkDirUri(webviewId),
+      workspaceRoot: this.workspaceRoot,
+      workspaceRootUri: this.workspaceRootUri,
+      workspaceState: this.workspaceState,
+      requireWorkDir: () => this.requireWorkDir(webviewId),
+      requireWorkDirUri: () => this.requireWorkDirUri(webviewId),
+      broadcast: this.broadcast,
+      fileManager: this.fileManager,
+      baselineManager: this.baselineManager,
+      runtime: this.runtime,
+      harness: this.runtime.harness,
+      reloadWebview: () => this.reloadWebview(webviewId),
+      showLogs: this.showLogs,
+      logError: (message, error) => this.logRuntimeError(message, error),
+      getSession: () => this.runtime.getSessionForView(webviewId),
+      getSessionId: () => this.fileManager.getSessionId(webviewId),
+      getOrCreateSession: async (model, effort, sessionId) => {
+        const runtime = await this.runtime.openSession({
+          webviewId,
+          workDir: this.requireWorkDir(webviewId),
+          model,
+          effort,
+          yoloMode: VSCodeSettings.yoloMode,
+          ...(sessionId === undefined ? {} : { sessionId }),
+        });
+        this.fileManager.setSession(webviewId, baselineSession(runtime));
+        return runtime;
+      },
+      resumeSession: async (sessionId) => {
+        const current = this.runtime.getSession(sessionId);
+        const session =
+          current?.session ??
+          (await this.runtime.harness.resumeSession({ id: sessionId, includeSubagents: true }));
+        if (!areSameFsPath(session.workDir, this.requireWorkDir(webviewId))) {
+          if (current === undefined) {
+            await session.close().catch((error: unknown) => {
+              this.logRuntimeError("Unable to close a rejected session", error);
+            });
+          }
+          throw new Error("The selected session belongs to a different working directory.");
+        }
+        const runtime = await this.runtime.attachResumedSession(
+          webviewId,
+          session,
+          VSCodeSettings.yoloMode,
+        );
+        this.fileManager.setSession(webviewId, baselineSession(runtime));
+        return runtime;
+      },
+      closeSession: async () => {
+        await this.runtime.detachView(webviewId);
+        this.fileManager.clearSession(webviewId);
+      },
+      saveAllDirty: () => this.saveAllDirty(),
+      setCustomWorkDir: (workDir) => this.setCustomWorkDir(webviewId, workDir),
+    };
+  }
+
+  private async saveAllDirty(): Promise<void> {
+    const dirty = vscode.workspace.textDocuments.filter((document) => document.isDirty && !document.isUntitled);
+    await Promise.all(dirty.map((document) => document.save()));
+  }
+
+  async disposeView(webviewId: string): Promise<void> {
+    await this.runtime.detachView(webviewId);
+    this.customWorkDirs.delete(webviewId);
+    this.fileManager.disposeView(webviewId);
+  }
+
+  async getEditorMention(
+    webviewId: string,
+    documentUri: vscode.Uri,
+    selection: vscode.Selection,
+  ): Promise<string | null> {
+    const workDirUri = this.getWorkDirUri(webviewId);
+    if (workDirUri === null || !(await isWorkspacePathContained(workDirUri, documentUri))) return null;
+    const relativePath = relativeWorkspacePath(workDirUri, documentUri);
+    if (relativePath === undefined) return null;
+
+    if (selection.isEmpty) return `@${relativePath}`;
+    return selection.start.line === selection.end.line
+      ? `@${relativePath}:${selection.start.line + 1}`
+      : `@${relativePath}:${selection.start.line + 1}-${selection.end.line + 1}`;
+  }
+
+  captureFileBaseline(
+    session: BaselineSession,
+    filePath: string,
+    webviewIds: readonly string[],
+  ): void {
+    const workspaceRoot = this.workspaceRoot;
+    const workspaceRootUri = this.workspaceRootUri;
+    if (workspaceRoot === null || workspaceRootUri === null) return;
+
+    const workDirUri = workDirUriFromPath(workspaceRootUri, workspaceRoot, session.workDir);
+    if (
+      workDirUri === undefined ||
+      !isWorkspacePathContainedSync(workspaceRootUri, workDirUri)
+    ) {
+      this.logRuntimeError(
+        "Unable to capture a file baseline",
+        new Error("Session working directory is outside the workspace"),
+      );
+      return;
+    }
+
+    const resolved = resolveSessionFilePath(workDirUri, session.workDir, filePath);
+    if (
+      resolved === undefined ||
+      !isWorkspacePathContainedSync(workDirUri, resolved.uri, { allowMissing: true })
+    ) {
+      this.logRuntimeError(
+        "Unable to capture a file baseline",
+        new Error("File is outside the session working directory"),
+      );
+      return;
+    }
+
+    const capture = this.baselineManager.capture(session, resolved.uri.fsPath);
+    void capture
+      .then(async () => {
+        await Promise.all(
+          webviewIds.map(async (webviewId) => {
+            this.fileManager.trackFile(webviewId, resolved.uri.fsPath);
+            await this.fileManager.refreshChanges(webviewId);
+          }),
+        );
+      })
+      .catch((error) => {
+        this.logRuntimeError("Unable to capture a file baseline", error);
+      });
+  }
+
+  async dispose(): Promise<void> {
+    this.fileManager.dispose();
+    await this.runtime.dispose();
+  }
+
+  async getBaselineContent(sessionId: string, filePath: string): Promise<string> {
+    const active = this.runtime.getSession(sessionId)?.summary;
+    const summary = active ?? (await this.runtime.harness.listSessions({ sessionId }))[0];
+    if (summary === undefined) throw new Error("Session was not found.");
+    return this.baselineManager.getContent(baselineSummary(summary), filePath);
+  }
+
+  private trace(id: string, method: string, durationMs: number, ok: boolean): void {
+    // Deliberately exclude params, prompt text, file paths, and credentials.
+    const line = `[bridge] id=${id} method=${method} ok=${String(ok)} durationMs=${durationMs}`;
+    console.debug(`[kimi-vscode] ${line}`);
+    this.writeLog(line);
+  }
+
+  private logRuntimeError(message: string, error?: unknown): void {
+    const detail = errorDetail(error);
+    const line = `${message}${detail ? `: ${detail}` : ""}`;
+    console.error(`[kimi-vscode] ${line}`);
+    this.writeLog(line);
+  }
+}
+
+function errorDetail(error: unknown): string {
+  if (error === undefined) return "";
+  if (error instanceof Error) return `${error.name}: ${error.message}`;
+  if (typeof error === "string") return error;
+  if (typeof error === "number" || typeof error === "bigint" || typeof error === "boolean") {
+    return String(error);
+  }
+  return "Unknown error";
+}
+
+function baselineSession(runtime: SessionRuntime): BaselineSession {
+  return baselineSummary({
+    id: runtime.id,
+    workDir: runtime.session.workDir,
+    metadata: runtime.summary?.metadata,
+  });
+}
+
+function baselineSummary(summary: Pick<BaselineSession, "id" | "workDir" | "metadata">): BaselineSession {
+  return {
+    id: summary.id,
+    workDir: summary.workDir,
+    ...(summary.metadata === undefined ? {} : { metadata: summary.metadata }),
+  };
+}
+
+function resolveSessionFilePath(
+  workDirUri: vscode.Uri,
+  workDir: string,
+  filePath: string,
+): WorkspacePath | undefined {
+  if (path.isAbsolute(filePath) || path.win32.isAbsolute(filePath)) {
+    const uri = workDirUriFromPath(workDirUri, workDir, filePath);
+    if (uri === undefined) return undefined;
+    const relativePath = relativeWorkspacePath(workDirUri, uri);
+    return relativePath === undefined ? undefined : { uri, relativePath };
+  }
+  return resolveWorkspacePath(workDirUri, filePath);
+}
diff --git a/apps/vscode/src/config/vscode-settings.ts b/apps/vscode/src/config/vscode-settings.ts
new file mode 100644
index 000000000..9bca3b126
--- /dev/null
+++ b/apps/vscode/src/config/vscode-settings.ts
@@ -0,0 +1,64 @@
+import * as vscode from "vscode";
+import type { ExtensionConfig } from "../../shared/types";
+
+declare const __EXTENSION_VERSION__: string;
+const EXTENSION_VERSION = typeof __EXTENSION_VERSION__ !== "undefined" ? __EXTENSION_VERSION__ : "0.0.0";
+
+function getConfig() {
+  return vscode.workspace.getConfiguration("kimi");
+}
+
+export const VSCodeSettings = {
+  get yoloMode(): boolean {
+    return getConfig().get<boolean>("yoloMode", false);
+  },
+
+  get autosave(): boolean {
+    return getConfig().get<boolean>("autosave", true);
+  },
+
+  get enableNewConversationShortcut(): boolean {
+    return getConfig().get<boolean>("enableNewConversationShortcut", false);
+  },
+
+  get useCtrlEnterToSend(): boolean {
+    return getConfig().get<boolean>("useCtrlEnterToSend", false);
+  },
+
+  get showThinkingContent(): boolean {
+    return getConfig().get<boolean>("showThinkingContent", false);
+  },
+
+  get showThinkingExpanded(): boolean {
+    return getConfig().get<boolean>("showThinkingExpanded", false);
+  },
+
+  get editorContext(): "never" | "onConversationStart" | "onFileChange" {
+    return getConfig().get<"never" | "onConversationStart" | "onFileChange">("editorContext", "never");
+  },
+
+  getExtensionConfig(): ExtensionConfig {
+    return {
+      yoloMode: this.yoloMode,
+      autosave: this.autosave,
+      useCtrlEnterToSend: this.useCtrlEnterToSend,
+      enableNewConversationShortcut: this.enableNewConversationShortcut,
+      showThinkingContent: this.showThinkingContent,
+      showThinkingExpanded: this.showThinkingExpanded,
+      version: EXTENSION_VERSION,
+    };
+  },
+};
+
+export function onSettingsChange(callback: (changedKeys: string[]) => void): vscode.Disposable {
+  return vscode.workspace.onDidChangeConfiguration((e) => {
+    if (!e.affectsConfiguration("kimi")) {
+      return;
+    }
+    const keys = ["yoloMode", "autosave", "enableNewConversationShortcut", "useCtrlEnterToSend", "showThinkingContent", "showThinkingExpanded", "editorContext"];
+    const changedKeys = keys.filter((key) => e.affectsConfiguration(`kimi.${key}`));
+    if (changedKeys.length > 0) {
+      callback(changedKeys);
+    }
+  });
+}
diff --git a/apps/vscode/src/extension.ts b/apps/vscode/src/extension.ts
new file mode 100644
index 000000000..4418526fb
--- /dev/null
+++ b/apps/vscode/src/extension.ts
@@ -0,0 +1,280 @@
+import * as vscode from "vscode";
+
+import { Events } from "../shared/bridge";
+import { KimiWebviewProvider } from "./KimiWebviewProvider";
+import { onSettingsChange, VSCodeSettings } from "./config/vscode-settings";
+import {
+  LegacyMigrationManager,
+  type LegacyMigrationDiscovery,
+  type LegacyMigrationRunResult,
+} from "./migration";
+import { updateLoginContext } from "./utils/context";
+
+let outputChannel: vscode.OutputChannel | undefined;
+let provider: KimiWebviewProvider | undefined;
+
+const LEGACY_REAUTH_NOTICE_KEY = "kimi.legacyMigration.reauthNotice.v1";
+const LEGACY_WARNING_NOTICE_KEY = "kimi.legacyMigration.warningNotice.v1";
+
+export async function activate(context: vscode.ExtensionContext): Promise<void> {
+  outputChannel = vscode.window.createOutputChannel("Kimi Code");
+  const remoteInfo = vscode.env.remoteName ? ` (remote: ${vscode.env.remoteName})` : "";
+  log(`Kimi Code ${VSCodeSettings.getExtensionConfig().version} activating${remoteInfo}`);
+
+  provider = new KimiWebviewProvider(
+    context.extensionUri,
+    context,
+    () => outputChannel?.show(),
+    (message) => log(message),
+  );
+  context.subscriptions.push(provider, outputChannel);
+
+  let isLoggedIn = false;
+  try {
+    isLoggedIn = await updateLoginContext(provider.harness);
+  } catch (error) {
+    logError("Unable to determine login status", error);
+  }
+
+  context.subscriptions.push(
+    vscode.workspace.registerTextDocumentContentProvider("kimi-baseline", {
+      provideTextDocumentContent: async (uri) => {
+        const sessionId = new URLSearchParams(uri.query).get("sessionId");
+        if (!sessionId || !provider) return "";
+        const relativePath = decodeURIComponent(uri.path.replace(/^\//, ""));
+        try {
+          return await provider.getBaselineContent(sessionId, relativePath);
+        } catch (error) {
+          logError("Unable to open baseline content", error);
+          return "";
+        }
+      },
+    }),
+  );
+
+  context.subscriptions.push(
+    onSettingsChange((changedKeys) => {
+      provider?.broadcast(Events.ExtensionConfigChanged, {
+        config: VSCodeSettings.getExtensionConfig(),
+        changedKeys,
+      });
+      if (changedKeys.includes("yoloMode")) {
+        void provider
+          ?.setYoloModeForActiveSessions(VSCodeSettings.yoloMode)
+          .catch((error) => logError("Unable to update session permission", error));
+      }
+    }),
+    vscode.window.registerWebviewViewProvider("kimi.webview", provider, {
+      webviewOptions: { retainContextWhenHidden: true },
+    }),
+  );
+
+  const migrationManager = new LegacyMigrationManager({
+    targetHome: provider.harness.homeDir,
+    workspaceRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath,
+    legacyEnvironmentVariables: vscode.workspace
+      .getConfiguration("kimi")
+      .get<unknown>("environmentVariables"),
+  });
+  let migrationInFlight: Promise<void> | undefined;
+  const runMigration = (retry: boolean): Promise<void> => {
+    if (migrationInFlight !== undefined) return migrationInFlight;
+    migrationInFlight = performMigration(migrationManager, retry).finally(() => {
+      migrationInFlight = undefined;
+    });
+    return migrationInFlight;
+  };
+
+  const commands: Record<string, () => void | Promise<void>> = {
+    "kimi.clearAllState": async () => {
+      await context.globalState.update("kimi.config", undefined);
+      await context.globalState.update("kimi.mcpServers", undefined);
+      await context.workspaceState.update("kimi.mcpEnabled", undefined);
+      await vscode.window.showInformationMessage("Kimi: Extension UI state cleared.");
+    },
+    "kimi.openInTab": () => {
+      provider?.createPanel();
+    },
+    "kimi.openInSideBar": async () => {
+      await vscode.commands.executeCommand("kimi.webview.focus");
+    },
+    "kimi.focusInput": async () => {
+      await vscode.commands.executeCommand("kimi.webview.focus");
+      provider?.broadcast(Events.FocusInput, {});
+    },
+    "kimi.insertMention": async () => {
+      const editor = vscode.window.activeTextEditor;
+      if (!editor) {
+        await vscode.window.showWarningMessage("No active editor");
+        return;
+      }
+      await vscode.commands.executeCommand("kimi.webview.focus");
+      if (!(await provider?.insertEditorMention(editor.document.uri, editor.selection))) {
+        await vscode.window.showWarningMessage("The active file is outside the selected working directory.");
+      }
+    },
+    "kimi.newConversation": async () => {
+      await vscode.commands.executeCommand("kimi.webview.focus");
+      provider?.broadcast(Events.NewConversation, {});
+    },
+    "kimi.showLogs": () => outputChannel?.show(),
+    "kimi.resetKimi": () => provider?.resetAllWebviews(),
+    "kimi.logout": async () => {
+      await vscode.commands.executeCommand("kimi.webview.focus");
+      await vscode.window.showInformationMessage("Use the logout button in Kimi settings.");
+    },
+    "kimi.migrateLegacyData": () => runMigration(true),
+  };
+
+  for (const [id, handler] of Object.entries(commands)) {
+    context.subscriptions.push(vscode.commands.registerCommand(id, handler));
+  }
+
+  void offerLegacyMigration(
+    migrationManager,
+    () => runMigration(false),
+    context.globalState,
+    isLoggedIn,
+  ).catch((error) => {
+    logError("Unable to check for legacy Kimi data", error);
+  });
+  log("Kimi Code activated");
+}
+
+export async function deactivate(): Promise<void> {
+  log("Kimi Code deactivating");
+  await provider?.shutdown();
+  provider = undefined;
+}
+
+function log(message: string): void {
+  outputChannel?.appendLine(`[${new Date().toISOString()}] ${message}`);
+}
+
+function logError(message: string, error: unknown): void {
+  const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  log(`${message}: ${detail}`);
+}
+
+async function offerLegacyMigration(
+  manager: LegacyMigrationManager,
+  migrate: () => Promise<void>,
+  globalState: vscode.Memento,
+  isLoggedIn: boolean,
+): Promise<void> {
+  const discovery = await manager.discover();
+  logMigrationDiscovery(discovery);
+  const reauthNotice = legacyReauthNotice(discovery, isLoggedIn);
+  const warningNotice =
+    discovery.warnings.length === 0
+      ? null
+      : "Some legacy Kimi data could not be inspected. Use “Kimi Code: Migrate Legacy Data” to retry.";
+  if (discovery.prompt === null) {
+    if (reauthNotice !== null && !globalState.get<boolean>(LEGACY_REAUTH_NOTICE_KEY, false)) {
+      await vscode.window.showWarningMessage(reauthNotice);
+      await globalState.update(LEGACY_REAUTH_NOTICE_KEY, true);
+    }
+    if (
+      discovery.warnings.length > 0 &&
+      !globalState.get<boolean>(LEGACY_WARNING_NOTICE_KEY, false)
+    ) {
+      const action = await vscode.window.showWarningMessage(
+        warningNotice ?? "Some legacy Kimi data could not be inspected.",
+        "Show Logs",
+      );
+      await globalState.update(LEGACY_WARNING_NOTICE_KEY, true);
+      if (action === "Show Logs") outputChannel?.show();
+    }
+    return;
+  }
+
+  const action = await vscode.window.showInformationMessage(
+    [discovery.prompt.message, reauthNotice, warningNotice]
+      .filter((message) => message !== null)
+      .join(" "),
+    ...discovery.prompt.actions.map(({ label }) => label),
+  );
+  if (reauthNotice !== null) await globalState.update(LEGACY_REAUTH_NOTICE_KEY, true);
+  if (warningNotice !== null) await globalState.update(LEGACY_WARNING_NOTICE_KEY, true);
+  if (action === "Migrate Now") await migrate();
+}
+
+function legacyReauthNotice(
+  discovery: LegacyMigrationDiscovery,
+  isLoggedIn: boolean,
+): string | null {
+  const kimiLogins = isLoggedIn ? 0 : discovery.notices.oauthLoginsRequiringRelogin.length;
+  const mcpLogins = discovery.notices.mcpOauthServersRequiringReauth.length;
+  if (kimiLogins === 0 && mcpLogins === 0) return null;
+  if (kimiLogins > 0 && mcpLogins > 0) {
+    return "Legacy OAuth credentials are not copied. Sign in to Kimi Code and authorize your MCP servers again.";
+  }
+  return kimiLogins > 0
+    ? "Legacy OAuth credentials are not copied. Sign in to Kimi Code again."
+    : "Legacy MCP OAuth credentials are not copied. Authorize those MCP servers again.";
+}
+
+async function performMigration(
+  manager: LegacyMigrationManager,
+  retry: boolean,
+): Promise<void> {
+  log(`${retry ? "Retrying" : "Starting"} legacy Kimi data migration`);
+  const result = retry ? await manager.retry() : await manager.migrateNow();
+  logMigrationResult(result);
+
+  if (result.status === "completed" || result.status === "partial") {
+    try {
+      await provider?.harness.getConfig({ reload: true });
+      await provider?.resetAllWebviews();
+    } catch (error) {
+      logError("Migration finished, but the runtime config could not be reloaded", error);
+    }
+  }
+
+  const reauthCount =
+    result.notices.oauthLoginsRequiringRelogin.length +
+    result.notices.mcpOauthServersRequiringReauth.length;
+  const reauthNotice =
+    reauthCount === 0
+      ? ""
+      : ` ${reauthCount} OAuth connection(s) must be signed in again.`;
+  const message = `${result.message}${reauthNotice}`;
+  const needsLogs =
+    result.status === "partial" ||
+    result.status === "failed" ||
+    result.warnings.length > 0 ||
+    result.manualActions.length > 0;
+
+  if (result.status === "failed") {
+    const action = await vscode.window.showErrorMessage(message, "Show Logs");
+    if (action === "Show Logs") outputChannel?.show();
+  } else if (needsLogs) {
+    const action = await vscode.window.showWarningMessage(message, "Show Logs");
+    if (action === "Show Logs") outputChannel?.show();
+  } else {
+    await vscode.window.showInformationMessage(message);
+  }
+}
+
+function logMigrationDiscovery(discovery: LegacyMigrationDiscovery): void {
+  for (const warning of discovery.warnings) log(`Legacy migration warning: ${warning.message}`);
+  for (const source of discovery.suppressedSources) {
+    log(`Legacy migration already completed for ${source.sourceHome}`);
+  }
+}
+
+function logMigrationResult(result: LegacyMigrationRunResult): void {
+  const { totals } = result;
+  log(
+    `Legacy migration ${result.status}: config=${totals.configFiles} mcp=${totals.mcpServers} history=${totals.userHistoryEntries} skills=${totals.skills} sessions=${totals.sessions} alreadyMigrated=${totals.alreadyMigratedSessions} skipped=${totals.skippedItems} conflicts=${totals.conflicts} failures=${totals.failures}`,
+  );
+  for (const warning of result.warnings) log(`Legacy migration warning: ${warning.message}`);
+  for (const source of result.sources) {
+    for (const failure of source.failures) {
+      log(`Legacy migration failure (${failure.sourceHome}): ${failure.message}`);
+    }
+  }
+  for (const action of result.manualActions) log(`Legacy migration action: ${action}`);
+}
+
+export { log };
diff --git a/apps/vscode/src/handlers/auth.handler.ts b/apps/vscode/src/handlers/auth.handler.ts
new file mode 100644
index 000000000..6ddac4bcf
--- /dev/null
+++ b/apps/vscode/src/handlers/auth.handler.ts
@@ -0,0 +1,53 @@
+import * as vscode from "vscode";
+
+import { Events, Methods } from "../../shared/bridge";
+import type { LoginResult } from "../../shared/legacy-sdk";
+import type { LoginStatus } from "../../shared/types";
+import { updateLoginContext } from "../utils/context";
+import type { Handler } from "./types";
+
+export const authHandlers: Record<string, Handler<any, any>> = {
+  [Methods.CheckLoginStatus]: async (_, ctx): Promise<LoginStatus> => {
+    return { loggedIn: await updateLoginContext(ctx.harness) };
+  },
+
+  [Methods.Login]: async (_, ctx): Promise<LoginResult> => {
+    try {
+      await ctx.harness.auth.login(undefined, {
+        onDeviceCode: async (authorization) => {
+          const url = authorization.verificationUriComplete || authorization.verificationUri;
+          ctx.broadcast(Events.LoginUrl, { url }, ctx.webviewId);
+          await vscode.env.openExternal(vscode.Uri.parse(url));
+        },
+      });
+      await updateLoginContext(ctx.harness);
+      return { success: true };
+    } catch (error) {
+      ctx.logError("Kimi login failed", error);
+      await updateLoginContext(ctx.harness).catch((statusError: unknown) => {
+        ctx.logError("Unable to refresh login status after a failed login", statusError);
+      });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+
+  [Methods.Logout]: async (_, ctx): Promise<LoginResult> => {
+    try {
+      await ctx.harness.auth.logout();
+      await updateLoginContext(ctx.harness);
+      return { success: true };
+    } catch (error) {
+      ctx.logError("Kimi logout failed", error);
+      await updateLoginContext(ctx.harness).catch((statusError: unknown) => {
+        ctx.logError("Unable to refresh login status after a failed logout", statusError);
+      });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
diff --git a/apps/vscode/src/handlers/chat.handler.ts b/apps/vscode/src/handlers/chat.handler.ts
new file mode 100644
index 000000000..21608381e
--- /dev/null
+++ b/apps/vscode/src/handlers/chat.handler.ts
@@ -0,0 +1,210 @@
+import * as vscode from "vscode";
+import { isKimiError } from "@moonshot-ai/kimi-code-sdk";
+
+import { Events, Methods } from "../../shared/bridge";
+import type { ApprovalResponse, ContentPart } from "../../shared/legacy-sdk";
+import { getUserMessage } from "../../shared/errors";
+import type { ErrorPhase } from "../../shared/types";
+import { VSCodeSettings } from "../config/vscode-settings";
+import type { SessionRuntime } from "../runtime/session-runtime";
+import { isWorkspacePathContained, relativeWorkspacePath } from "../utils/workspace-path";
+import { parseHostSlashCommand, runHostSlashCommand } from "./slash-command";
+import type { Handler } from "./types";
+
+interface StreamChatParams {
+  content: string | ContentPart[];
+  model: string;
+  effort?: string;
+  thinking?: boolean;
+  planMode?: boolean;
+  sessionId?: string;
+}
+
+interface RespondApprovalParams {
+  requestId: string;
+  response: ApprovalResponse;
+}
+
+interface RespondQuestionParams {
+  rpcRequestId: string;
+  questionRequestId: string;
+  answers: Record<string, string>;
+}
+
+const injectedEditorContextSessions = new Map<string, string>();
+
+async function buildSystemContext(sessionId: string, ctx: Parameters<Handler>[1]): Promise<string> {
+  const mode = VSCodeSettings.editorContext;
+  if (mode === "never") return "";
+
+  const editor = vscode.window.activeTextEditor;
+  if (!editor || !ctx.workDirUri || !(await isWorkspacePathContained(ctx.workDirUri, editor.document.uri))) {
+    return "";
+  }
+
+  const document = editor.document;
+  const relativePath = relativeWorkspacePath(ctx.workDirUri, document.uri);
+  if (relativePath === undefined) return "";
+  const lastPath = injectedEditorContextSessions.get(sessionId);
+  if (mode === "onConversationStart" && lastPath !== undefined) return "";
+  if (mode === "onFileChange" && lastPath === relativePath) return "";
+
+  injectedEditorContextSessions.set(sessionId, relativePath);
+  const selection = editor.selection;
+  const selectionInfo = selection.isEmpty
+    ? ""
+    : ` (L${selection.start.line + 1}-${selection.end.line + 1} selected)`;
+  const unsavedInfo = document.isDirty ? ", unsaved" : "";
+  return `<system>Editor context (use only if relevant to user's query): ${relativePath}:${selection.active.line + 1}${selectionInfo}${unsavedInfo}.</system>\n`;
+}
+
+function prependSystemContext(content: string | ContentPart[], context: string): string | ContentPart[] {
+  if (!context) return content;
+  if (typeof content === "string") return `${content}\n${context}`;
+
+  const index = content.findIndex((part) => part.type === "text");
+  if (index < 0) return [{ type: "text", text: context }, ...content];
+  const copy = [...content];
+  const text = copy[index] as Extract<ContentPart, { type: "text" }>;
+  copy[index] = { type: "text", text: context + text.text };
+  return copy;
+}
+
+const streamChat: Handler<StreamChatParams, { done: boolean }> = async (params, ctx) => {
+  if (!ctx.workDir) {
+    emitPreflightError(ctx, "NO_WORKSPACE", "Please open a folder to start.");
+    void vscode.window.showWarningMessage("Kimi: Please open a folder first.", "Open Folder").then((action) => {
+      if (action) void vscode.commands.executeCommand("vscode.openFolder");
+    });
+    return { done: false };
+  }
+
+  if (VSCodeSettings.autosave) {
+    try {
+      await ctx.saveAllDirty();
+    } catch (error) {
+      emitCaughtError(ctx, error, "preflight");
+      return { done: false };
+    }
+  }
+
+  let runtime: SessionRuntime;
+  try {
+    runtime = await ctx.getOrCreateSession(
+      params.model,
+      params.effort ?? (params.thinking === true ? "on" : "off"),
+      params.sessionId,
+    );
+  } catch (error) {
+    emitCaughtError(ctx, error, "preflight");
+    return { done: false };
+  }
+
+  try {
+    const status = await runtime.session.getStatus();
+    if (params.planMode !== undefined && status.planMode !== params.planMode) {
+      await runtime.session.setPlanMode(params.planMode);
+    }
+    runtime.announceSessionStart(status.model);
+  } catch (error) {
+    emitCaughtError(ctx, error, "preflight", runtime.id);
+    return { done: false };
+  }
+
+  const slash = parseHostSlashCommand(params.content);
+  if (slash !== undefined) {
+    try {
+      return { done: await runHostSlashCommand(runtime, slash, ctx) };
+    } catch (error) {
+      emitCaughtError(ctx, error, "runtime", runtime.id);
+      return { done: false };
+    }
+  }
+
+  const systemContext = await buildSystemContext(runtime.id, ctx);
+  try {
+    const result = await runtime.prompt(prependSystemContext(params.content, systemContext));
+    return { done: result.status === "finished" };
+  } catch (error) {
+    emitCaughtError(ctx, error, "runtime", runtime.id);
+    return { done: false };
+  }
+};
+
+const abortChat: Handler<void, { aborted: boolean }> = async (_, ctx) => {
+  const runtime = ctx.getSession();
+  if (runtime !== undefined) await runtime.cancel();
+  return { aborted: true };
+};
+
+const respondApproval: Handler<RespondApprovalParams, { ok: boolean }> = async (params, ctx) => {
+  return { ok: ctx.getSession()?.respondApproval(params.requestId, params.response) ?? false };
+};
+
+const respondQuestion: Handler<RespondQuestionParams, { ok: boolean }> = async (params, ctx) => {
+  const id = params.questionRequestId || params.rpcRequestId;
+  return { ok: ctx.getSession()?.respondQuestion(id, params.answers) ?? false };
+};
+
+const setPlanMode: Handler<{ enabled: boolean }, { ok: boolean; planMode: boolean }> = async (params, ctx) => {
+  const runtime = ctx.getSession();
+  if (runtime === undefined) return { ok: false, planMode: false };
+  await runtime.session.setPlanMode(params.enabled);
+  return { ok: true, planMode: params.enabled };
+};
+
+const steerChat: Handler<{ content: string | ContentPart[] }, { ok: boolean }> = async (params, ctx) => {
+  const runtime = ctx.getSession();
+  if (runtime === undefined || !runtime.isBusy) return { ok: false };
+  await runtime.steer(params.content);
+  return { ok: true };
+};
+
+const resetSession: Handler<void, { ok: boolean }> = async (_, ctx) => {
+  const runtime = ctx.getSession();
+  if (runtime !== undefined) injectedEditorContextSessions.delete(runtime.id);
+  await ctx.closeSession();
+  ctx.fileManager.clearTracked(ctx.webviewId);
+  return { ok: true };
+};
+
+export const chatHandlers: Record<string, Handler<any, any>> = {
+  [Methods.StreamChat]: streamChat,
+  [Methods.AbortChat]: abortChat,
+  [Methods.RespondApproval]: respondApproval,
+  [Methods.RespondQuestion]: respondQuestion,
+  [Methods.SetPlanMode]: setPlanMode,
+  [Methods.SteerChat]: steerChat,
+  [Methods.ResetSession]: resetSession,
+};
+
+function emitCaughtError(
+  ctx: Parameters<Handler>[1],
+  error: unknown,
+  phase: ErrorPhase,
+  sessionId?: string,
+): void {
+  const code = isKimiError(error) ? error.code : "internal";
+  const detail = error instanceof Error ? error.message : String(error);
+  ctx.logError(`Chat ${phase} request failed`, error);
+  ctx.broadcast(
+    Events.StreamEvent,
+    {
+      type: "error",
+      code,
+      message: getUserMessage(code, detail),
+      detail,
+      phase,
+      ...(sessionId === undefined ? {} : { _sessionId: sessionId }),
+    },
+    ctx.webviewId,
+  );
+}
+
+function emitPreflightError(ctx: Parameters<Handler>[1], code: string, message: string): void {
+  ctx.broadcast(
+    Events.StreamEvent,
+    { type: "error", code, message, phase: "preflight" },
+    ctx.webviewId,
+  );
+}
diff --git a/apps/vscode/src/handlers/config.handler.ts b/apps/vscode/src/handlers/config.handler.ts
new file mode 100644
index 000000000..705edaa20
--- /dev/null
+++ b/apps/vscode/src/handlers/config.handler.ts
@@ -0,0 +1,149 @@
+import * as vscode from "vscode";
+import {
+  effectiveModelAlias,
+  type KimiConfig as SdkKimiConfig,
+  type ModelAlias,
+  type ThinkingEffort,
+} from "@moonshot-ai/kimi-code-sdk";
+
+import { Methods } from "../../shared/bridge";
+import type {
+  KimiConfig as WebviewKimiConfig,
+  ModelConfig,
+  SlashCommandInfo,
+} from "../../shared/legacy-sdk";
+import type { ExtensionConfig, SessionConfig } from "../../shared/types";
+import { VSCodeSettings } from "../config/vscode-settings";
+import type { Handler } from "./types";
+
+const SLASH_COMMANDS: SlashCommandInfo[] = [
+  { name: "init", aliases: [], description: "Analyze the codebase and generate AGENTS.md" },
+  { name: "compact", aliases: [], description: "Compact the conversation context" },
+  { name: "clear", aliases: ["reset"], description: "Clear the context" },
+  { name: "yolo", aliases: [], description: "Toggle YOLO mode (auto-approve all actions)" },
+  {
+    name: "afk",
+    aliases: [],
+    description: "Toggle afk mode (auto-dismiss questions and auto-approve tool calls)",
+  },
+  { name: "plan", aliases: [], description: "Toggle plan mode. Usage: /plan [on|off|view|clear]" },
+  {
+    name: "add-dir",
+    aliases: [],
+    description: "Add a directory to the workspace. Usage: /add-dir <path>",
+  },
+  { name: "export", aliases: [], description: "Export current session context to a markdown file" },
+  { name: "import", aliases: [], description: "Import context from a file or session ID" },
+];
+
+const saveConfig: Handler<SessionConfig, { ok: boolean }> = async (params, ctx) => {
+  const effort = sessionConfigEffort(params);
+  await ctx.harness.setConfig({
+    defaultModel: params.model,
+    thinking: thinkingConfig(effort),
+  });
+
+  const runtime = ctx.getSession();
+  if (runtime !== undefined) {
+    const status = await runtime.session.getStatus();
+    if (status.model !== params.model) await runtime.session.setModel(params.model);
+    if (status.thinkingEffort !== effort) await runtime.session.setThinking(effort);
+  }
+  return { ok: true };
+};
+
+const getExtensionConfig: Handler<void, ExtensionConfig> = async () => {
+  return VSCodeSettings.getExtensionConfig();
+};
+
+const openSettings: Handler<void, { ok: boolean }> = async () => {
+  await vscode.commands.executeCommand("workbench.action.openSettings", "kimi");
+  return { ok: true };
+};
+
+const getModels: Handler<void, WebviewKimiConfig> = async (_, ctx) => {
+  const config = await ctx.harness.getConfig({ reload: true });
+  return toWebviewConfig(config);
+};
+
+const getSlashCommands: Handler<void, SlashCommandInfo[]> = async (_, ctx) => {
+  if (!ctx.workDir) return SLASH_COMMANDS;
+  try {
+    const skills = await ctx.harness.listWorkspaceSkills(ctx.workDir);
+    const skillCommands = skills
+      .filter((skill) => isUserActivatableSkill(skill.type))
+      .toSorted((left, right) => left.name.localeCompare(right.name))
+      .map((skill) => ({
+        name: `skill:${skill.name}`,
+        aliases: [],
+        description: skill.description ?? "",
+      }));
+    return [...SLASH_COMMANDS, ...skillCommands];
+  } catch (error) {
+    ctx.logError("Unable to list workspace skills", error);
+    return SLASH_COMMANDS;
+  }
+};
+
+const showLogs: Handler<void, { ok: boolean }> = async (_, ctx) => {
+  ctx.showLogs();
+  return { ok: true };
+};
+
+const reloadWebview: Handler<void, { ok: boolean }> = async (_, ctx) => {
+  await ctx.closeSession();
+  ctx.fileManager.clearTracked(ctx.webviewId);
+  ctx.reloadWebview();
+  return { ok: true };
+};
+
+export const configHandlers = {
+  [Methods.SaveConfig]: saveConfig,
+  [Methods.GetExtensionConfig]: getExtensionConfig,
+  [Methods.OpenSettings]: openSettings,
+  [Methods.GetModels]: getModels,
+  [Methods.GetSlashCommands]: getSlashCommands,
+  [Methods.ShowLogs]: showLogs,
+  [Methods.ReloadWebview]: reloadWebview,
+} as Record<string, Handler<any, any>>;
+
+export function toWebviewConfig(config: SdkKimiConfig): WebviewKimiConfig {
+  const models: ModelConfig[] = Object.entries(config.models ?? {})
+    .map(([id, model]) => toWebviewModel(id, model))
+    .toSorted((left, right) => left.name.localeCompare(right.name));
+  return {
+    defaultModel: config.defaultModel ?? models[0]?.id ?? null,
+    defaultThinking: config.thinking?.enabled !== false,
+    defaultThinkingEffort: config.thinking?.effort,
+    models,
+  };
+}
+
+function toWebviewModel(id: string, model: ModelAlias): ModelConfig {
+  const effective = effectiveModelAlias(model);
+  return {
+    id,
+    name: effective.displayName ?? effective.model ?? id,
+    provider: effective.provider,
+    capabilities: [...(effective.capabilities ?? [])],
+    adaptive_thinking: effective.adaptiveThinking,
+    support_efforts:
+      effective.supportEfforts === undefined ? undefined : [...effective.supportEfforts],
+    default_effort: effective.defaultEffort,
+  };
+}
+
+function sessionConfigEffort(config: SessionConfig): ThinkingEffort {
+  if (config.effort !== undefined) return config.effort as ThinkingEffort;
+  return config.thinking === true ? "on" : "off";
+}
+
+function thinkingConfig(effort: ThinkingEffort): { enabled: boolean; effort?: string } {
+  if (effort === "off") return { enabled: false };
+  if (effort === "on") return { enabled: true };
+  return { enabled: true, effort };
+}
+
+function isUserActivatableSkill(type: string | undefined): boolean {
+  return type === undefined || type === "prompt" || type === "inline" || type === "flow";
+}
diff --git a/apps/vscode/src/handlers/file.handler.ts b/apps/vscode/src/handlers/file.handler.ts
new file mode 100644
index 000000000..50457e8cf
--- /dev/null
+++ b/apps/vscode/src/handlers/file.handler.ts
@@ -0,0 +1,226 @@
+import * as path from "node:path";
+import * as vscode from "vscode";
+
+import { Events, Methods } from "../../shared/bridge";
+import type { FileChange, ProjectFile } from "../../shared/types";
+import type { BaselineSession } from "../managers/baseline.manager";
+import {
+  isWorkspacePathContained,
+  resolveWorkspacePath,
+  type WorkspacePath,
+} from "../utils/workspace-path";
+import type { Handler } from "./types";
+
+interface GetProjectFilesParams {
+  query?: string;
+  directory?: string;
+}
+interface PickMediaParams { maxCount?: number; includeVideo?: boolean }
+interface FilePathParams { filePath: string }
+interface OptionalFilePathParams { filePath?: string }
+interface PathsParams { paths: string[] }
+interface CheckFilesExistParams { paths: string[] }
+
+const IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp"];
+const VIDEO_EXTENSIONS = ["mp4", "webm", "mov"];
+const IMAGE_MIME_TYPES: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+};
+
+const getProjectFiles: Handler<GetProjectFilesParams | undefined, ProjectFile[]> = async (params, ctx) => {
+  if (!ctx.workDirUri) return [];
+  return params?.directory !== undefined
+    ? ctx.fileManager.listDirectory(ctx.workDirUri, params.directory)
+    : ctx.fileManager.searchFiles(ctx.workDirUri, params?.query);
+};
+
+const pickMedia: Handler<PickMediaParams, string[]> = async (params) => {
+  const maxCount = params.maxCount ?? 9;
+  const includeVideo = params.includeVideo ?? true;
+  const filters: Record<string, string[]> = { Images: IMAGE_EXTENSIONS };
+  if (includeVideo) {
+    filters["Videos"] = VIDEO_EXTENSIONS;
+    filters["All Media"] = [...IMAGE_EXTENSIONS, ...VIDEO_EXTENSIONS];
+  }
+  const uris = await vscode.window.showOpenDialog({ canSelectMany: true, filters, title: "Select Media" });
+  if (!uris) return [];
+
+  const results: string[] = [];
+  for (const uri of uris.slice(0, maxCount)) {
+    try {
+      const extension = path.extname(uri.fsPath).toLowerCase().slice(1);
+      const isVideo = VIDEO_EXTENSIONS.includes(extension);
+      const stat = await vscode.workspace.fs.stat(uri);
+      if (stat.size > (isVideo ? 20 : 10) * 1024 * 1024) continue;
+      const bytes = await vscode.workspace.fs.readFile(uri);
+      results.push(`data:${mediaMime(extension)};base64,${Buffer.from(bytes).toString("base64")}`);
+    } catch {
+      // Skip a file that disappears or cannot be read without failing the whole picker.
+    }
+  }
+  return results;
+};
+
+const openFile: Handler<FilePathParams, { ok: boolean }> = async ({ filePath }, ctx) => {
+  const resolved = await resolveExistingWorkspaceFile(ctx.requireWorkDirUri(), filePath);
+  if (resolved === undefined) return { ok: false };
+  await vscode.commands.executeCommand("vscode.open", resolved.uri);
+  return { ok: true };
+};
+
+const openFileDiff: Handler<FilePathParams, { ok: boolean }> = async ({ filePath }, ctx) => {
+  const sessionId = ctx.getSessionId();
+  const resolved = await resolveExistingWorkspaceFile(ctx.requireWorkDirUri(), filePath);
+  if (!sessionId || resolved === undefined) return { ok: false };
+
+  const baselineUri = vscode.Uri.from({
+    scheme: "kimi-baseline",
+    path: `/${resolved.relativePath}`,
+    query: new URLSearchParams({ sessionId }).toString(),
+  });
+  await vscode.commands.executeCommand(
+    "vscode.diff",
+    baselineUri,
+    resolved.uri,
+    `${path.basename(resolved.relativePath)} (changes from Kimi)`,
+  );
+  return { ok: true };
+};
+
+const trackFiles: Handler<PathsParams, FileChange[]> = async ({ paths }, ctx) => {
+  const session = requireBaselineSession(ctx);
+  const workDirUri = ctx.requireWorkDirUri();
+  for (const filePath of paths) {
+    const resolved = await resolveWorkspaceFile(workDirUri, filePath, true);
+    if (resolved !== undefined) ctx.fileManager.trackFile(ctx.webviewId, resolved.uri.fsPath);
+  }
+  const changes = await ctx.baselineManager.getChanges(session);
+  ctx.broadcast(Events.FileChangesUpdated, changes, ctx.webviewId);
+  return changes;
+};
+
+const clearTrackedFiles: Handler<void, { ok: boolean }> = async (_, ctx) => {
+  ctx.fileManager.clearTracked(ctx.webviewId);
+  ctx.broadcast(Events.FileChangesUpdated, [], ctx.webviewId);
+  return { ok: true };
+};
+
+const revertFiles: Handler<OptionalFilePathParams, { ok: boolean }> = async (params, ctx) => {
+  const session = requireBaselineSession(ctx);
+  if (params.filePath) {
+    const resolved = await resolveWorkspaceFile(ctx.requireWorkDirUri(), params.filePath, true);
+    if (resolved === undefined) return { ok: false };
+    await ctx.baselineManager.undo(session, resolved.relativePath);
+  } else {
+    await ctx.baselineManager.undoAll(session);
+    ctx.fileManager.clearTracked(ctx.webviewId);
+  }
+  await ctx.fileManager.refreshChanges(ctx.webviewId);
+  return { ok: true };
+};
+
+const keepChanges: Handler<OptionalFilePathParams, { ok: boolean }> = async (params, ctx) => {
+  const session = requireBaselineSession(ctx);
+  if (params.filePath) {
+    const resolved = await resolveWorkspaceFile(ctx.requireWorkDirUri(), params.filePath, true);
+    if (resolved === undefined) return { ok: false };
+    await ctx.baselineManager.keep(session, resolved.relativePath);
+    ctx.fileManager.getTracked(ctx.webviewId).delete(resolved.uri.fsPath);
+  } else {
+    await ctx.baselineManager.keepAll(session);
+    ctx.fileManager.clearTracked(ctx.webviewId);
+  }
+  await ctx.fileManager.refreshChanges(ctx.webviewId);
+  return { ok: true };
+};
+
+const checkFileExists: Handler<FilePathParams, boolean> = async ({ filePath }, ctx) => {
+  if (!ctx.workDirUri) return false;
+  return (await resolveExistingWorkspaceFile(ctx.workDirUri, filePath)) !== undefined;
+};
+
+const checkFilesExist: Handler<CheckFilesExistParams, Record<string, boolean>> = async ({ paths }, ctx) => {
+  if (!ctx.workDirUri) return {};
+  return Object.fromEntries(
+    await Promise.all(
+      paths.map(async (filePath) => [
+        filePath,
+        (await resolveExistingWorkspaceFile(ctx.workDirUri!, filePath)) !== undefined,
+      ] as const),
+    ),
+  );
+};
+
+const getImageDataUri: Handler<FilePathParams, string | null> = async ({ filePath }, ctx) => {
+  if (!ctx.workDirUri) return null;
+  const resolved = await resolveExistingWorkspaceFile(ctx.workDirUri, decodeURIComponent(filePath));
+  if (resolved === undefined) return null;
+  const mime = IMAGE_MIME_TYPES[path.extname(resolved.relativePath).toLowerCase()];
+  if (!mime) return null;
+  try {
+    const bytes = await vscode.workspace.fs.readFile(resolved.uri);
+    return `data:${mime};base64,${Buffer.from(bytes).toString("base64")}`;
+  } catch {
+    return null;
+  }
+};
+
+export const fileHandlers: Record<string, Handler<any, any>> = {
+  [Methods.GetProjectFiles]: getProjectFiles,
+  [Methods.PickMedia]: pickMedia,
+  [Methods.OpenFile]: openFile,
+  [Methods.OpenFileDiff]: openFileDiff,
+  [Methods.TrackFiles]: trackFiles,
+  [Methods.ClearTrackedFiles]: clearTrackedFiles,
+  [Methods.RevertFiles]: revertFiles,
+  [Methods.KeepChanges]: keepChanges,
+  [Methods.CheckFileExists]: checkFileExists,
+  [Methods.CheckFilesExist]: checkFilesExist,
+  [Methods.GetImageDataUri]: getImageDataUri,
+};
+
+function requireBaselineSession(ctx: Parameters<Handler>[1]): BaselineSession {
+  const session = ctx.fileManager.getSession(ctx.webviewId);
+  if (session === null) throw new Error("No active session.");
+  return session;
+}
+
+async function resolveWorkspaceFile(
+  workDirUri: vscode.Uri,
+  filePath: string,
+  allowMissing = false,
+): Promise<WorkspacePath | undefined> {
+  const resolved = resolveWorkspacePath(workDirUri, filePath);
+  if (resolved === undefined || !(await isWorkspacePathContained(workDirUri, resolved.uri, { allowMissing }))) {
+    return undefined;
+  }
+  return resolved;
+}
+
+async function resolveExistingWorkspaceFile(
+  workDirUri: vscode.Uri,
+  filePath: string,
+): Promise<WorkspacePath | undefined> {
+  const resolved = await resolveWorkspaceFile(workDirUri, filePath);
+  if (resolved === undefined) return undefined;
+  try {
+    await vscode.workspace.fs.stat(resolved.uri);
+    return resolved;
+  } catch {
+    return undefined;
+  }
+}
+
+function mediaMime(extension: string): string {
+  return ({
+    png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp",
+    mp4: "video/mp4", webm: "video/webm", mov: "video/quicktime",
+  } as Record<string, string>)[extension] ?? "application/octet-stream";
+}
diff --git a/apps/vscode/src/handlers/index.ts b/apps/vscode/src/handlers/index.ts
new file mode 100644
index 000000000..fa0a72b14
--- /dev/null
+++ b/apps/vscode/src/handlers/index.ts
@@ -0,0 +1,20 @@
+import { configHandlers } from "./config.handler";
+import { mcpHandlers } from "./mcp.handler";
+import { sessionHandlers } from "./session.handler";
+import { chatHandlers } from "./chat.handler";
+import { fileHandlers } from "./file.handler";
+import { workspaceHandlers } from "./workspace.handler";
+import { authHandlers } from "./auth.handler";
+import type { Handler } from "./types";
+
+export type { Handler, HandlerContext, BroadcastFn, ReloadWebviewFn, ShowLogsFn } from "./types";
+
+export const handlers: Record<string, Handler<any, any>> = {
+  ...workspaceHandlers,
+  ...configHandlers,
+  ...mcpHandlers,
+  ...sessionHandlers,
+  ...chatHandlers,
+  ...fileHandlers,
+  ...authHandlers,
+};
diff --git a/apps/vscode/src/handlers/mcp.handler.ts b/apps/vscode/src/handlers/mcp.handler.ts
new file mode 100644
index 000000000..a310f64de
--- /dev/null
+++ b/apps/vscode/src/handlers/mcp.handler.ts
@@ -0,0 +1,301 @@
+import * as vscode from "vscode";
+import type { McpServerConfig as SdkMcpServerConfig, McpTestResult } from "@moonshot-ai/kimi-code-sdk";
+
+import { Events, Methods } from "../../shared/bridge";
+import {
+  MCP_SECRET_MASK,
+  type MCPServerConfig,
+  type MCPTestResult,
+  type UpdateMCPServerRequest,
+} from "../../shared/legacy-sdk";
+import type { Handler } from "./types";
+
+const SENSITIVE_MCP_KEY_WORDS = new Set([
+  "authorization",
+  "cookie",
+  "credential",
+  "credentials",
+  "passwd",
+  "password",
+  "secret",
+  "token",
+]);
+
+interface NameParams { name: string }
+
+export const mcpHandlers: Record<string, Handler<any, any>> = {
+  [Methods.GetMCPServers]: async (_, ctx): Promise<MCPServerConfig[]> => {
+    return toWebviewServers(await ctx.harness.listMcpServers());
+  },
+
+  [Methods.AddMCPServer]: async (params: MCPServerConfig, ctx): Promise<MCPServerConfig[]> => {
+    const server = restoreMaskedSecrets(undefined, params);
+    const servers = toWebviewServers(await ctx.harness.addMcpServer(toSdkServer(server)));
+    ctx.broadcast(Events.MCPServersChanged, servers);
+    return servers;
+  },
+
+  [Methods.UpdateMCPServer]: async (
+    params: UpdateMCPServerRequest | MCPServerConfig,
+    ctx,
+  ): Promise<MCPServerConfig[]> => {
+    const request = normalizeUpdateRequest(params);
+    const current = (await ctx.harness.listMcpServers()).find(
+      (server) => server.name === request.originalName,
+    );
+    const edited = restoreMaskedSecrets(current, request.server);
+    const next = mergeEditableServer(current, edited, request.replaceEditableFields);
+    const servers = toWebviewServers(
+      await updateOrRenameServer(ctx.harness, request.originalName, current, next),
+    );
+    ctx.broadcast(Events.MCPServersChanged, servers);
+    return servers;
+  },
+
+  [Methods.RemoveMCPServer]: async ({ name }: NameParams, ctx): Promise<MCPServerConfig[]> => {
+    const servers = toWebviewServers(await ctx.harness.removeMcpServer(name));
+    ctx.broadcast(Events.MCPServersChanged, servers);
+    return servers;
+  },
+
+  [Methods.AuthMCP]: async ({ name }: NameParams, ctx) => {
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: `Kimi: Authenticating "${name}"...`,
+        cancellable: false,
+      },
+      async () => {
+        try {
+          await ctx.harness.authenticateMcpServer(name, {
+            onAuthorizationUrl: async (url) => vscode.env.openExternal(vscode.Uri.parse(url)),
+          });
+          await vscode.window.showInformationMessage(`Kimi: OAuth completed for "${name}"`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          await vscode.window.showErrorMessage(`Kimi: OAuth failed for "${name}": ${message}`);
+          throw error;
+        }
+      },
+    );
+    return { ok: true };
+  },
+
+  [Methods.ResetAuthMCP]: async ({ name }: NameParams, ctx) => {
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: `Kimi: Resetting auth for "${name}"...`,
+        cancellable: false,
+      },
+      async () => {
+        try {
+          await ctx.harness.resetMcpServerAuth(name);
+          await vscode.window.showInformationMessage(`Kimi: Auth reset for "${name}"`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          await vscode.window.showErrorMessage(`Kimi: Reset auth failed for "${name}": ${message}`);
+          throw error;
+        }
+      },
+    );
+    return { ok: true };
+  },
+
+  [Methods.TestMCP]: async ({ name }: NameParams, ctx): Promise<MCPTestResult> => {
+    void vscode.window.showInformationMessage(`Kimi: Testing MCP server "${name}"...`);
+    const result = toWebviewTestResult(await ctx.harness.testMcpServer(name, {
+      cwd: ctx.workDir ?? undefined,
+    }));
+    if (!result.success) {
+      ctx.logError(`MCP server test failed for "${name}"`, new Error(result.output));
+    }
+    return result;
+  },
+};
+
+function toWebviewServers(servers: readonly SdkMcpServerConfig[]): MCPServerConfig[] {
+  return servers
+    .filter((server) => server.transport === "stdio" || server.transport === "http")
+    .map((server) => {
+      if (server.transport === "stdio") {
+        return { ...server, env: maskSecretValues(server.env) } as MCPServerConfig;
+      }
+      return { ...server, headers: maskSecretValues(server.headers) } as MCPServerConfig;
+    });
+}
+
+function maskSecretValues(values: Record<string, string> | undefined): Record<string, string> | undefined {
+  if (values === undefined) return undefined;
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    isSensitiveMcpKey(key) ? MCP_SECRET_MASK : value,
+  ]));
+}
+
+function isSensitiveMcpKey(key: string): boolean {
+  const words = key
+    .replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+  const compact = words.join("");
+  return words.some((word) => SENSITIVE_MCP_KEY_WORDS.has(word))
+    || words.includes("key")
+    || compact === "proxyauthorization"
+    || compact === "setcookie"
+    || compact.endsWith("apikey")
+    || compact.endsWith("accesskey")
+    || compact.endsWith("privatekey");
+}
+
+function restoreMaskedSecrets(
+  current: SdkMcpServerConfig | undefined,
+  edited: MCPServerConfig,
+): MCPServerConfig {
+  if (edited.transport === "stdio") {
+    const currentEnv = current?.transport === "stdio" ? current.env : undefined;
+    return {
+      ...edited,
+      env: restoreMaskedRecord("environment variable", currentEnv, edited.env, false),
+    };
+  }
+  const currentHeaders = current?.transport === "http" ? current.headers : undefined;
+  return {
+    ...edited,
+    headers: restoreMaskedRecord("header", currentHeaders, edited.headers, true),
+  };
+}
+
+function restoreMaskedRecord(
+  label: string,
+  current: Record<string, string> | undefined,
+  edited: Record<string, string> | undefined,
+  caseInsensitiveKeys: boolean,
+): Record<string, string> | undefined {
+  if (edited === undefined) return undefined;
+  return Object.fromEntries(Object.entries(edited).map(([key, value]) => {
+    if (value !== MCP_SECRET_MASK) return [key, value];
+    const stored = findStoredSecret(current, key, caseInsensitiveKeys);
+    if (stored === undefined) {
+      throw new Error(`Cannot preserve masked MCP ${label} "${key}" because no stored value exists`);
+    }
+    return [key, stored];
+  }));
+}
+
+function findStoredSecret(
+  current: Record<string, string> | undefined,
+  key: string,
+  caseInsensitiveKeys: boolean,
+): string | undefined {
+  if (current === undefined) return undefined;
+  if (Object.hasOwn(current, key)) return current[key];
+  if (!caseInsensitiveKeys) return undefined;
+  const normalized = key.toLowerCase();
+  const match = Object.entries(current).find(([storedKey]) => storedKey.toLowerCase() === normalized);
+  return match?.[1];
+}
+
+function toSdkServer(server: MCPServerConfig): SdkMcpServerConfig {
+  const name = server.name.trim();
+  if (server.transport === "stdio") {
+    return {
+      name,
+      transport: "stdio",
+      command: server.command?.trim() ?? "",
+      args: server.args,
+      env: server.env,
+    };
+  }
+  return {
+    name,
+    transport: "http",
+    url: server.url?.trim() ?? "",
+    headers: server.headers,
+    auth: server.auth,
+    bearerTokenEnvVar: server.bearerTokenEnvVar,
+  };
+}
+
+function mergeEditableServer(
+  current: SdkMcpServerConfig | undefined,
+  edited: MCPServerConfig,
+  replaceEditableFields: boolean,
+): SdkMcpServerConfig {
+  const next = toSdkServer(edited);
+  if (current === undefined || current.transport !== next.transport) return next;
+  if (!replaceEditableFields) {
+    return mergeReleasedFormUpdate(current, next);
+  }
+  return { ...current, ...next } as SdkMcpServerConfig;
+}
+
+function mergeReleasedFormUpdate(
+  current: SdkMcpServerConfig,
+  next: SdkMcpServerConfig,
+): SdkMcpServerConfig {
+  const defined = Object.fromEntries(
+    Object.entries(next).filter(([, value]) => value !== undefined),
+  );
+  return { ...current, ...defined } as SdkMcpServerConfig;
+}
+
+function normalizeUpdateRequest(
+  params: UpdateMCPServerRequest | MCPServerConfig,
+): {
+  readonly originalName: string;
+  readonly server: MCPServerConfig;
+  readonly replaceEditableFields: boolean;
+} {
+  if ("server" in params) {
+    return {
+      originalName: params.originalName.trim(),
+      server: params.server,
+      replaceEditableFields: true,
+    };
+  }
+  return {
+    originalName: params.name.trim(),
+    server: params,
+    replaceEditableFields: false,
+  };
+}
+
+async function updateOrRenameServer(
+  harness: Pick<
+    Parameters<Handler>[1]["harness"],
+    "addMcpServer" | "updateMcpServer" | "removeMcpServer"
+  >,
+  originalName: string,
+  current: SdkMcpServerConfig | undefined,
+  next: SdkMcpServerConfig,
+): Promise<readonly SdkMcpServerConfig[]> {
+  if (next.name === originalName) {
+    return harness.updateMcpServer(next);
+  }
+  if (current === undefined) {
+    throw new Error(`MCP server "${originalName}" was not found`);
+  }
+
+  await harness.addMcpServer(next);
+  try {
+    return await harness.removeMcpServer(originalName);
+  } catch (error) {
+    await harness.removeMcpServer(next.name).catch(() => undefined);
+    throw error;
+  }
+}
+
+function toWebviewTestResult(result: McpTestResult): MCPTestResult {
+  return { success: result.success, output: sanitizeMcpDiagnostic(result.output) };
+}
+
+function sanitizeMcpDiagnostic(output: string): string {
+  return output
+    .replaceAll(/\bBearer\s+[^\s,;]+/gi, "Bearer [redacted]")
+    .replaceAll(
+      /(["']?(?:authorization|cookie|credentials?|password|passwd|secret|token|api[-_ ]?key)["']?\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,;]+)/gi,
+      "$1[redacted]",
+    );
+}
diff --git a/apps/vscode/src/handlers/session.handler.ts b/apps/vscode/src/handlers/session.handler.ts
new file mode 100644
index 000000000..817d6960b
--- /dev/null
+++ b/apps/vscode/src/handlers/session.handler.ts
@@ -0,0 +1,274 @@
+import * as path from "node:path";
+import * as vscode from "vscode";
+import type { SessionSummary } from "@moonshot-ai/kimi-code-sdk";
+
+import { Events, Methods } from "../../shared/bridge";
+import type { SessionInfo } from "../../shared/legacy-sdk";
+import type { BaselineSession } from "../managers/baseline.manager";
+import { replaySessionToWebviewEvents } from "../runtime/replay-adapter";
+import { areSameFsPath, isFsPathInsideOrEqual } from "../utils/fs-path";
+import {
+  isWorkspacePathContained,
+  workDirUriFromPath,
+} from "../utils/workspace-path";
+import type { Handler } from "./types";
+
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+
+interface LoadHistoryParams {
+  kimiSessionId: string;
+}
+
+interface DeleteSessionParams {
+  sessionId: string;
+}
+
+interface ForkSessionParams {
+  sessionId: string;
+  turnIndex: number;
+}
+
+export const sessionHandlers: Record<string, Handler<any, any>> = {
+  [Methods.GetKimiSessions]: async (_, ctx): Promise<SessionInfo[]> => {
+    if (!ctx.workDir) return [];
+    return (await ctx.harness.listSessions({ workDir: ctx.workDir })).map(toSessionInfo);
+  },
+
+  [Methods.GetAllKimiSessions]: async (_, ctx): Promise<SessionInfo[]> => {
+    if (!ctx.workspaceRoot) return [];
+    return (await ctx.harness.listSessions())
+      .filter((session) => isInsideOrEqual(ctx.workspaceRoot!, session.workDir))
+      .map(toSessionInfo);
+  },
+
+  [Methods.GetRegisteredWorkDirs]: async (_, ctx): Promise<string[]> => {
+    if (!ctx.workspaceRoot) return [];
+    const sessions = await ctx.harness.listSessions();
+    return [
+      ...new Set(
+        sessions
+          .map((session) => session.workDir)
+          .filter((workDir) => isInsideOrEqual(ctx.workspaceRoot!, workDir)),
+      ),
+    ].toSorted();
+  },
+
+  [Methods.SetWorkDir]: async (params: { workDir: string | null }, ctx) => {
+    if (!ctx.workspaceRoot || !ctx.workspaceRootUri) return { ok: false };
+    const target = params.workDir;
+    if (target) {
+      const targetUri = workDirUriFromPath(ctx.workspaceRootUri, ctx.workspaceRoot, target);
+      if (targetUri === undefined || !(await isWorkspacePathContained(ctx.workspaceRootUri, targetUri))) {
+        return { ok: false };
+      }
+    }
+    try {
+      await ctx.setCustomWorkDir(target);
+    } catch {
+      return { ok: false };
+    }
+    return { ok: true, workDir: target ?? ctx.workspaceRoot };
+  },
+
+  [Methods.BrowseWorkDir]: async (_, ctx) => {
+    if (!ctx.workspaceRoot || !ctx.workspaceRootUri) return { ok: false, workDir: null };
+    const workspaceUri = ctx.workspaceRootUri;
+    let subdirectories: string[] = [];
+    try {
+      const entries = await vscode.workspace.fs.readDirectory(workspaceUri);
+      subdirectories = entries
+        .filter(([name, type]) => type === vscode.FileType.Directory && !name.startsWith("."))
+        .map(([name]) => name)
+        .toSorted();
+    } catch {
+      // The native picker remains available when directory enumeration fails.
+    }
+
+    const picked = await vscode.window.showQuickPick(
+      [
+        { label: "$(folder) Browse...", description: "Open folder picker", alwaysShow: true },
+        { label: "", kind: vscode.QuickPickItemKind.Separator },
+        ...subdirectories.map((name) => ({
+          label: `$(folder) ${name}`,
+          description: path.join(ctx.workspaceRoot!, name),
+        })),
+      ],
+      { placeHolder: "Select a subdirectory or browse...", title: "Working Directory" },
+    );
+    if (!picked) return { ok: false, workDir: null };
+
+    let selectedUri: vscode.Uri;
+    if (picked.label === "$(folder) Browse...") {
+      const result = await vscode.window.showOpenDialog({
+        canSelectFiles: false,
+        canSelectFolders: true,
+        canSelectMany: false,
+        defaultUri: workspaceUri,
+        openLabel: "Select Working Directory",
+      });
+      if (!result?.[0]) return { ok: false, workDir: null };
+      selectedUri = result[0];
+    } else if (picked.description) {
+      const pickedUri = workDirUriFromPath(workspaceUri, ctx.workspaceRoot, picked.description);
+      if (pickedUri === undefined) return { ok: false, workDir: null };
+      selectedUri = pickedUri;
+    } else {
+      return { ok: false, workDir: null };
+    }
+
+    if (!(await isWorkspacePathContained(workspaceUri, selectedUri))) {
+      await vscode.window.showWarningMessage("Selected directory must be within the workspace.");
+      return { ok: false, workDir: null };
+    }
+    const selected = selectedUri.fsPath;
+    await ctx.setCustomWorkDir(selected === ctx.workspaceRoot ? null : selected);
+    return { ok: true, workDir: selected };
+  },
+
+  [Methods.LoadKimiSessionHistory]: async (params: LoadHistoryParams, ctx) => {
+    if (!ctx.workDir || !isSessionId(params.kimiSessionId)) return [];
+    const runtime = await ctx.resumeSession(params.kimiSessionId);
+    if (!areSameFsPath(runtime.session.workDir, ctx.workDir)) {
+      await ctx.closeSession();
+      throw new Error("The selected session belongs to a different working directory.");
+    }
+
+    let history: ReturnType<typeof replaySessionToWebviewEvents>;
+    try {
+      const resumeState = runtime.session.getResumeState();
+      if (resumeState?.agents["main"] === undefined) {
+        throw new Error("Session history is unavailable.");
+      }
+      history = replaySessionToWebviewEvents(resumeState, runtime.id);
+    } catch (error) {
+      await ctx.closeSession();
+      throw error;
+    }
+
+    ctx.fileManager.clearTracked(ctx.webviewId);
+    const baseline = baselineSession(runtime.summary ?? {
+      id: runtime.id,
+      workDir: runtime.session.workDir,
+    });
+    try {
+      const changes = await ctx.baselineManager.getChanges(baseline);
+      for (const change of changes) {
+        ctx.fileManager.trackFile(ctx.webviewId, path.join(baseline.workDir, change.path));
+      }
+      ctx.broadcast(Events.FileChangesUpdated, changes, ctx.webviewId);
+    } catch (error) {
+      ctx.logError("Unable to restore session file changes", error);
+      ctx.broadcast(Events.FileChangesUpdated, [], ctx.webviewId);
+      void Promise.resolve(
+        vscode.window.showWarningMessage(
+          "Kimi: This conversation opened, but its file change history is unavailable.",
+          "Show Logs",
+        ),
+      )
+        .then((action) => {
+          if (action === "Show Logs") ctx.showLogs();
+        })
+        .catch((noticeError: unknown) => {
+          ctx.logError("Unable to show the file change warning", noticeError);
+        });
+    }
+    return history;
+  },
+
+  [Methods.DeleteKimiSession]: async (params: DeleteSessionParams, ctx): Promise<{ ok: boolean }> => {
+    if (!isSessionId(params.sessionId) || !ctx.workspaceRoot) return { ok: false };
+    const summary = (await ctx.harness.listSessions({ sessionId: params.sessionId }))[0];
+    if (summary === undefined || !isInsideOrEqual(ctx.workspaceRoot, summary.workDir)) {
+      return { ok: false };
+    }
+    const affectedViews = ctx.runtime.getSession(params.sessionId)?.subscribers ?? [];
+    await ctx.runtime.deleteSession(params.sessionId);
+    await ctx.baselineManager.deleteSession(params.sessionId);
+    for (const webviewId of affectedViews) {
+      ctx.fileManager.clearSession(webviewId);
+      ctx.broadcast(Events.FileChangesUpdated, [], webviewId);
+      if (webviewId !== ctx.webviewId) {
+        ctx.broadcast(Events.NewConversation, {}, webviewId);
+      }
+    }
+    return { ok: true };
+  },
+
+  [Methods.ForkKimiSession]: async (params: ForkSessionParams, ctx) => {
+    if (!ctx.workDir || !isSessionId(params.sessionId) || !Number.isInteger(params.turnIndex) || params.turnIndex < 0) {
+      return null;
+    }
+    const summaries = await ctx.harness.listSessions({ sessionId: params.sessionId });
+    const sourceSummary = summaries[0];
+    if (
+      sourceSummary === undefined ||
+      !ctx.workspaceRoot ||
+      !isInsideOrEqual(ctx.workspaceRoot, sourceSummary.workDir)
+    ) return null;
+
+    const forkSettledSession = async () => {
+      const fork = await ctx.harness.forkSession({ id: params.sessionId, turnIndex: params.turnIndex });
+      const targetSummary = fork.summary;
+      if (targetSummary === undefined) {
+        await fork.close();
+        throw new Error("Forked session metadata is unavailable.");
+      }
+
+      let materializeError: unknown;
+      try {
+        await ctx.baselineManager.materializeToFork(
+          baselineSession(sourceSummary),
+          baselineSession(targetSummary),
+        );
+      } catch (error) {
+        materializeError = error;
+      }
+
+      try {
+        await fork.close();
+      } catch (error) {
+        ctx.logError("Unable to close a forked session", error);
+      }
+      if (materializeError !== undefined) {
+        await ctx.harness.deleteSession(targetSummary.id).catch((error: unknown) => {
+          ctx.logError(`Unable to remove failed fork "${targetSummary.id}"`, error);
+        });
+        await ctx.baselineManager.deleteSession(targetSummary.id).catch((error: unknown) => {
+          ctx.logError(`Unable to remove failed fork baseline "${targetSummary.id}"`, error);
+        });
+        throw materializeError instanceof Error
+          ? materializeError
+          : new Error("Unable to materialize the forked session baseline.", {
+              cause: materializeError,
+            });
+      }
+      return { sessionId: targetSummary.id };
+    };
+
+    const active = ctx.runtime.getSession(params.sessionId);
+    return active === undefined
+      ? forkSettledSession()
+      : active.runExclusiveAfterCancelling(forkSettledSession);
+  },
+};
+
+function toSessionInfo(summary: SessionSummary): SessionInfo {
+  return {
+    id: summary.id,
+    workDir: summary.workDir,
+    updatedAt: summary.updatedAt,
+    brief: summary.title ?? summary.lastPrompt ?? "",
+  };
+}
+
+function baselineSession(summary: Pick<SessionSummary, "id" | "workDir" | "metadata">): BaselineSession {
+  return { id: summary.id, workDir: summary.workDir, metadata: summary.metadata };
+}
+
+function isInsideOrEqual(root: string, candidate: string): boolean {
+  return isFsPathInsideOrEqual(root, candidate);
+}
+
+function isSessionId(value: string): boolean {
+  return SESSION_ID.test(value);
+}
diff --git a/apps/vscode/src/handlers/slash-command.ts b/apps/vscode/src/handlers/slash-command.ts
new file mode 100644
index 000000000..e23c9ac1d
--- /dev/null
+++ b/apps/vscode/src/handlers/slash-command.ts
@@ -0,0 +1,312 @@
+import type { Stats } from "node:fs";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import * as vscode from "vscode";
+
+import type { SessionRuntime } from "../runtime/session-runtime";
+import {
+  buildExportMarkdown,
+  isImportableTextFile,
+  isSensitiveFile,
+  stringifyContextHistory,
+} from "../utils/session-context";
+import type { HandlerContext } from "./types";
+
+const HOST_COMMANDS = new Set([
+  "init",
+  "compact",
+  "clear",
+  "reset",
+  "yolo",
+  "afk",
+  "plan",
+  "add-dir",
+  "export",
+  "import",
+]);
+const MAX_IMPORT_BYTES = 10 * 1024 * 1024;
+
+export interface HostSlashCommand {
+  readonly name: string;
+  readonly args: string;
+  readonly raw: string;
+}
+
+export function parseHostSlashCommand(content: string | readonly unknown[]): HostSlashCommand | undefined {
+  if (typeof content !== "string") return undefined;
+  const raw = content.trim();
+  const match = /^\/([^\s]+)(?:\s+(.*))?\s*$/s.exec(raw);
+  if (match === null) return undefined;
+  const name = match[1]!.toLowerCase();
+  if (!HOST_COMMANDS.has(name) && !name.startsWith("skill:")) return undefined;
+  return { name, args: match[2]?.trim() ?? "", raw };
+}
+
+export async function runHostSlashCommand(
+  runtime: SessionRuntime,
+  command: HostSlashCommand,
+  ctx: HandlerContext,
+): Promise<boolean> {
+  if (command.name.startsWith("skill:")) {
+    const skillName = command.name.slice("skill:".length);
+    const result = await runtime.runTurnAction(command.raw, () =>
+      runtime.session.activateSkill(skillName, command.args || undefined));
+    return result.status === "finished";
+  }
+
+  const actionId = runtime.beginHostAction(command.raw, command.name === "import");
+  const emit = (text: string): void => runtime.emitHostText(text, actionId);
+  try {
+    if (command.name === "import") {
+      const result = await importContext(runtime, command.args, ctx);
+      emit(result.message);
+      if (result.sensitive) {
+        void vscode.window.showWarningMessage(
+          "Kimi: The imported file may contain API keys, tokens, or credentials.",
+        );
+      }
+    } else {
+      switch (command.name) {
+        case "init":
+          await runtime.session.init();
+          emit("AGENTS.md has been generated.");
+          break;
+        case "compact":
+          await runtime.compactHostAction(actionId, command.args || undefined);
+          emit("The context has been compacted.");
+          break;
+        case "clear":
+        case "reset":
+          await runtime.session.clearContext();
+          emit("The context has been cleared.");
+          break;
+        case "yolo":
+          await toggleLegacyPermission(runtime, "yolo", emit);
+          break;
+        case "afk":
+          await toggleLegacyPermission(runtime, "afk", emit);
+          break;
+        case "plan":
+          await runPlanCommand(runtime, command.args, emit);
+          break;
+        case "add-dir":
+          await runAddDirCommand(runtime, command.args, emit);
+          break;
+        case "export":
+          await exportContext(runtime, command.args, emit);
+          break;
+      }
+    }
+
+    if (runtime.wasHostActionCancelled(actionId)) return false;
+    runtime.completeHostAction("finished", actionId);
+    return true;
+  } catch (error) {
+    if (runtime.wasHostActionCancelled(actionId)) return false;
+    runtime.failHostAction(actionId);
+    throw error;
+  } finally {
+    runtime.releaseHostAction(actionId);
+  }
+}
+
+async function toggleLegacyPermission(
+  runtime: SessionRuntime,
+  kind: "yolo" | "afk",
+  emit: (text: string) => void,
+): Promise<void> {
+  const flags = await runtime.toggleLegacyApproval(kind);
+
+  if (kind === "yolo") {
+    emit(flags.yolo
+      ? "You only live once! All actions will be auto-approved."
+      : flags.afk
+        ? "Yolo disabled, but afk is still on — tool calls remain auto-approved."
+        : "You only die once! Actions will require approval.");
+    return;
+  }
+  emit(flags.afk
+    ? "afk mode enabled. Questions will be auto-dismissed and tool calls auto-approved."
+    : flags.yolo
+      ? "afk mode disabled. You are back at the keyboard. Yolo is still on."
+      : "afk mode disabled. You are back at the keyboard.");
+}
+
+async function runPlanCommand(
+  runtime: SessionRuntime,
+  args: string,
+  emit: (text: string) => void,
+): Promise<void> {
+  const subcommand = args.trim().toLowerCase();
+  if (subcommand === "view") {
+    const plan = await runtime.session.getPlan();
+    emit(plan?.content.trim() || "No plan file found for this session.");
+    return;
+  }
+  if (subcommand === "clear") {
+    await runtime.session.clearPlan();
+    emit("Plan cleared.");
+    return;
+  }
+  const status = await runtime.session.getStatus();
+  const enabled = subcommand === "on" ? true : subcommand === "off" ? false : !status.planMode;
+  if (subcommand && subcommand !== "on" && subcommand !== "off") {
+    throw new Error(`Unknown plan subcommand: ${subcommand}`);
+  }
+  if (status.planMode !== enabled) await runtime.session.setPlanMode(enabled);
+  if (!enabled) {
+    emit("Plan mode OFF. All tools are now available.");
+    return;
+  }
+  const plan = await runtime.session.getPlan().catch(() => null);
+  emit(plan?.path
+    ? `Plan mode ON. Plan file: ${plan.path}`
+    : "Plan mode ON.");
+}
+
+async function runAddDirCommand(
+  runtime: SessionRuntime,
+  args: string,
+  emit: (text: string) => void,
+): Promise<void> {
+  const input = stripMatchingQuotes(args.trim());
+  if (!input || input.toLowerCase() === "list") {
+    const dirs = runtime.session.summary?.additionalDirs ?? [];
+    emit(dirs.length === 0
+      ? "No additional directories. Usage: /add-dir <path>"
+      : ["Additional directories:", ...dirs.map((path) => `  - ${path}`)].join("\n"));
+    return;
+  }
+  const result = await runtime.session.addAdditionalDir(input, { persist: false });
+  emit(`Added directory to workspace: ${result.additionalDirs.at(-1) ?? input}`);
+}
+
+async function exportContext(
+  runtime: SessionRuntime,
+  args: string,
+  emit: (text: string) => void,
+): Promise<void> {
+  const context = await runtime.session.getContext();
+  if (context.history.length === 0) {
+    emit("No messages to export.");
+    return;
+  }
+  const now = new Date();
+  const defaultName = defaultExportName(runtime.id, now);
+  const outputPath = await resolveExportPath(args, runtime.session.workDir, defaultName);
+  const markdown = buildExportMarkdown({
+    sessionId: runtime.id,
+    workDir: runtime.session.workDir,
+    history: context.history,
+    tokenCount: context.tokenCount,
+    now,
+  });
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, markdown, "utf8");
+  emit(
+    `Exported ${String(context.history.length)} messages to ${outputPath}\n\n` +
+    "Note: The exported file may contain sensitive information. Please be cautious when sharing it externally.",
+  );
+  void vscode.window.showInformationMessage("Kimi: Session exported.", "Open File").then((action) => {
+    if (action !== "Open File") return;
+    void vscode.window.showTextDocument(vscode.Uri.file(outputPath));
+  });
+}
+
+async function importContext(
+  runtime: SessionRuntime,
+  args: string,
+  ctx: HandlerContext,
+): Promise<{ message: string; sensitive: boolean }> {
+  const target = stripMatchingQuotes(args.trim());
+  if (!target) throw new Error("Usage: /import <file_path or session_id>");
+
+  const candidate = resolveUserPath(target, runtime.session.workDir);
+  const file = await fileInfo(candidate);
+  if (file?.isDirectory()) throw new Error("The specified path is a directory; please provide a file to import.");
+  if (file?.isFile()) {
+    if (!isImportableTextFile(candidate)) {
+      throw new Error(`Unsupported file type '${candidate.slice(candidate.lastIndexOf("."))}'. /import only supports text-based files.`);
+    }
+    if (file.size > MAX_IMPORT_BYTES) {
+      throw new Error(`File is too large (${(file.size / 1024 / 1024).toFixed(1)} MB). Maximum import size is 10 MB.`);
+    }
+    const bytes = await readFile(candidate);
+    let content: string;
+    try {
+      content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch {
+      throw new Error(`Cannot import '${basename(candidate)}': the file is not valid UTF-8 text.`);
+    }
+    if (!content.trim()) throw new Error("The file is empty, nothing to import.");
+    const source = `file '${basename(candidate)}'`;
+    await runtime.session.importContext(content, source);
+    return {
+      message: `Imported context from ${source} (${String(content.length)} chars).`,
+      sensitive: isSensitiveFile(basename(candidate)),
+    };
+  }
+
+  if (target === runtime.id) throw new Error("Cannot import the current session into itself.");
+  const summary = (await ctx.harness.listSessions({
+    workDir: runtime.session.workDir,
+    sessionId: target,
+  })).find((session) => session.id === target);
+  if (summary === undefined) throw new Error(`'${target}' is not a valid file path or session ID.`);
+
+  const activeSource = ctx.runtime.getSession(target)?.session;
+  const sourceSession = activeSource ?? await ctx.harness.resumeSession({ id: target });
+  try {
+    const sourceContext = await sourceSession.getContext();
+    if (sourceContext.history.length === 0) throw new Error("The source session has no messages.");
+    const content = stringifyContextHistory(sourceContext.history);
+    if (Buffer.byteLength(content, "utf8") > MAX_IMPORT_BYTES) {
+      throw new Error("Session content is too large. Maximum import size is 10 MB.");
+    }
+    const source = `session '${target}'`;
+    await runtime.session.importContext(content, source);
+    return {
+      message: `Imported context from ${source} (${String(content.length)} chars).`,
+      sensitive: false,
+    };
+  } finally {
+    if (activeSource === undefined) await sourceSession.close();
+  }
+}
+
+async function resolveExportPath(args: string, workDir: string, defaultName: string): Promise<string> {
+  const raw = stripMatchingQuotes(args.trim());
+  if (!raw) return join(workDir, defaultName);
+  const resolved = resolveUserPath(raw, workDir);
+  const info = await fileInfo(resolved);
+  return raw.endsWith("/") || raw.endsWith("\\") || info?.isDirectory()
+    ? join(resolved, defaultName)
+    : resolved;
+}
+
+function defaultExportName(sessionId: string, now: Date): string {
+  const timestamp = now.toISOString().replaceAll(/[-:]/g, "").replace("T", "-").slice(0, 15);
+  return `kimi-export-${sessionId.slice(0, 8)}-${timestamp}.md`;
+}
+
+function resolveUserPath(value: string, workDir: string): string {
+  const expanded = value === "~" ? homedir() : value.startsWith("~/") ? join(homedir(), value.slice(2)) : value;
+  return isAbsolute(expanded) ? expanded : resolve(workDir, expanded);
+}
+
+async function fileInfo(path: string): Promise<Stats | undefined> {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function stripMatchingQuotes(value: string): string {
+  if (value.length < 2) return value;
+  const first = value[0];
+  const last = value.at(-1);
+  return (first === last && (first === '"' || first === "'")) ? value.slice(1, -1) : value;
+}
diff --git a/apps/vscode/src/handlers/types.ts b/apps/vscode/src/handlers/types.ts
new file mode 100644
index 000000000..c50fe482b
--- /dev/null
+++ b/apps/vscode/src/handlers/types.ts
@@ -0,0 +1,41 @@
+import type * as vscode from "vscode";
+import type { FileManager } from "../managers/file.manager";
+import type { BaselineManager } from "../managers/baseline.manager";
+import type { KimiHarness } from "@moonshot-ai/kimi-code-sdk";
+import type { KimiRuntime } from "../runtime/kimi-runtime";
+import type { SessionRuntime } from "../runtime/session-runtime";
+
+export type BroadcastFn = (event: string, data: unknown, webviewId?: string) => void;
+
+export type ReloadWebviewFn = (webviewId: string) => void;
+
+export type ShowLogsFn = () => void;
+
+export interface HandlerContext {
+  webviewId: string;
+  workDir: string | null;
+  workDirUri: vscode.Uri | null;
+  workspaceRoot: string | null;
+  workspaceRootUri: vscode.Uri | null;
+  workspaceState: vscode.Memento;
+  requireWorkDir: () => string;
+  requireWorkDirUri: () => vscode.Uri;
+  broadcast: BroadcastFn;
+  fileManager: FileManager;
+  baselineManager: BaselineManager;
+  runtime: KimiRuntime;
+  harness: KimiHarness;
+  reloadWebview: () => void;
+  showLogs: () => void;
+  logError: (message: string, error: unknown) => void;
+
+  getSession: () => SessionRuntime | undefined;
+  getSessionId: () => string | null;
+  getOrCreateSession: (model: string, effort: string, sessionId?: string) => Promise<SessionRuntime>;
+  resumeSession: (sessionId: string) => Promise<SessionRuntime>;
+  closeSession: () => Promise<void>;
+  saveAllDirty: () => Promise<void>;
+  setCustomWorkDir: (workDir: string | null) => Promise<void>;
+}
+
+export type Handler<TParams = void, TResult = unknown> = (params: TParams, ctx: HandlerContext) => Promise<TResult>;
diff --git a/apps/vscode/src/handlers/workspace.handler.ts b/apps/vscode/src/handlers/workspace.handler.ts
new file mode 100644
index 000000000..401e5bcdc
--- /dev/null
+++ b/apps/vscode/src/handlers/workspace.handler.ts
@@ -0,0 +1,44 @@
+import * as vscode from "vscode";
+import { Methods } from "../../shared/bridge";
+import type { Handler } from "./types";
+import type { WorkspaceStatus } from "shared/types";
+
+const INPUT_HISTORY_KEY = "kimi.inputHistory";
+const MAX_HISTORY_SIZE = 100;
+
+const checkWorkspace: Handler<void, WorkspaceStatus> = async (_, ctx) => {
+  return {
+    hasWorkspace: ctx.workDir !== null,
+    path: ctx.workDir ?? undefined,
+    workspaceRoot: ctx.workspaceRoot ?? undefined,
+  };
+};
+
+const openFolder: Handler<void, { ok: boolean }> = async () => {
+  await vscode.commands.executeCommand("vscode.openFolder");
+  return { ok: true };
+};
+
+const getInputHistory: Handler<void, string[]> = async (_, ctx) => {
+  return ctx.workspaceState.get<string[]>(INPUT_HISTORY_KEY, []);
+};
+
+const addInputHistory: Handler<{ text: string }, { ok: boolean }> = async ({ text }, ctx) => {
+  const history = ctx.workspaceState.get<string[]>(INPUT_HISTORY_KEY, []);
+  // 避免重复添加相同的最近一条
+  if (history[history.length - 1] !== text) {
+    history.push(text);
+    if (history.length > MAX_HISTORY_SIZE) {
+      history.shift();
+    }
+    await ctx.workspaceState.update(INPUT_HISTORY_KEY, history);
+  }
+  return { ok: true };
+};
+
+export const workspaceHandlers: Record<string, Handler<any, any>> = {
+  [Methods.CheckWorkspace]: checkWorkspace,
+  [Methods.OpenFolder]: openFolder,
+  [Methods.GetInputHistory]: getInputHistory,
+  [Methods.AddInputHistory]: addInputHistory,
+};
diff --git a/apps/vscode/src/managers/baseline.manager.ts b/apps/vscode/src/managers/baseline.manager.ts
new file mode 100644
index 000000000..46498aafe
--- /dev/null
+++ b/apps/vscode/src/managers/baseline.manager.ts
@@ -0,0 +1,864 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import {
+  lstat,
+  mkdir,
+  readFile,
+  readdir,
+  realpath,
+  rename,
+  rm,
+  stat,
+  unlink,
+  writeFile,
+} from 'node:fs/promises';
+import * as path from 'node:path';
+
+import type { FileChange } from '../../shared/types';
+import { relativeFsPath } from '../utils/fs-path';
+
+const MANIFEST_VERSION = 1;
+const SNAPSHOT_HASH = /^[a-f0-9]{64}$/;
+
+export interface BaselineSession {
+  readonly id: string;
+  readonly workDir: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+interface ManifestEntry {
+  readonly snapshot: string;
+  readonly existedBefore: boolean;
+}
+
+interface BaselineManifestV1 {
+  readonly version: 1;
+  readonly sessionId: string;
+  readonly entries: Readonly<Record<string, ManifestEntry>>;
+  readonly acceptedLegacyPaths: readonly string[];
+}
+
+interface MutableManifest {
+  version: 1;
+  sessionId: string;
+  entries: Record<string, ManifestEntry>;
+  acceptedLegacyPaths: string[];
+}
+
+interface ResolvedFile {
+  readonly absolutePath: string;
+  readonly relativePath: string;
+}
+
+interface BaselineValue {
+  readonly content: string;
+  readonly existedBefore: boolean;
+}
+
+export class BaselineError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = 'BaselineError';
+  }
+}
+
+export class BaselineManager {
+  private readonly baselinesRoot: string;
+  private readonly updates = new Map<string, Promise<void>>();
+
+  constructor(globalStorageRoot: string, homeNamespace = 'default') {
+    if (globalStorageRoot.length === 0) {
+      throw new BaselineError('The VSCode global storage path is empty');
+    }
+    if (homeNamespace.length === 0) {
+      throw new BaselineError('The Kimi home namespace is empty');
+    }
+    this.baselinesRoot = path.join(globalStorageRoot, 'baselines', hash(homeNamespace));
+  }
+
+  /**
+   * Capture the file synchronously before returning control to the caller.
+   * Persistence is serialized per session and completes through the returned
+   * promise, but no `await` occurs before the original file has been read.
+   */
+  async capture(session: BaselineSession, filePath: string): Promise<void> {
+    const resolved = resolveSessionFile(session, filePath);
+    const captured = captureOriginal(resolved.absolutePath);
+
+    await this.serialize([session.id], async () => {
+      const manifest = await this.readManifest(session);
+      const localPath = equivalentPath(
+        session,
+        Object.keys(manifest.entries),
+        resolved.relativePath,
+      );
+      if (localPath !== undefined) return;
+
+      const accepted = new Set(manifest.acceptedLegacyPaths);
+      const acceptedPath = equivalentPath(session, accepted, resolved.relativePath);
+      if (acceptedPath === undefined) {
+        const legacyExists = await this.hasLegacyBaseline(session, resolved.relativePath);
+        if (legacyExists) return;
+      }
+
+      const snapshot = hash(captured.content);
+      await this.writeSnapshot(session.id, snapshot, captured.content);
+      if (acceptedPath !== undefined) accepted.delete(acceptedPath);
+
+      const next = mutableManifest(manifest);
+      next.entries[resolved.relativePath] = {
+        snapshot,
+        existedBefore: captured.existedBefore,
+      };
+      next.acceptedLegacyPaths = uniquePaths(session, accepted);
+      await this.writeManifest(next);
+    });
+  }
+
+  async getChanges(session: BaselineSession): Promise<FileChange[]> {
+    await this.waitForUpdates([session.id]);
+    const manifest = await this.readManifest(session);
+    const relativePaths = await this.effectivePaths(session, manifest);
+    const changes: FileChange[] = [];
+
+    for (const relativePath of relativePaths) {
+      const baseline = await this.readEffectiveBaseline(session, relativePath, manifest);
+      if (baseline === undefined) continue;
+
+      const resolved = resolveSessionFile(session, relativePath);
+      const currentContent = await readCurrentFile(resolved.absolutePath);
+      if (currentContent === undefined) {
+        if (baseline.existedBefore) {
+          changes.push({
+            path: relativePath,
+            status: 'Deleted',
+            additions: 0,
+            deletions: countLines(baseline.content),
+          });
+        }
+        continue;
+      }
+
+      if (!baseline.existedBefore) {
+        changes.push({
+          path: relativePath,
+          status: 'Added',
+          additions: countLines(currentContent),
+          deletions: 0,
+        });
+        continue;
+      }
+
+      if (currentContent !== baseline.content) {
+        const diff = computeLineDiff(baseline.content, currentContent);
+        changes.push({
+          path: relativePath,
+          status: 'Modified',
+          additions: diff.additions,
+          deletions: diff.deletions,
+        });
+      }
+    }
+
+    return changes;
+  }
+
+  async getContent(session: BaselineSession, filePath: string): Promise<string> {
+    await this.waitForUpdates([session.id]);
+    const resolved = resolveSessionFile(session, filePath);
+    const manifest = await this.readManifest(session);
+    const baseline = await this.readEffectiveBaseline(session, resolved.relativePath, manifest);
+    if (baseline === undefined) {
+      throw new BaselineError(
+        `No baseline exists for "${resolved.relativePath}" in session "${session.id}"`,
+      );
+    }
+    return baseline.content;
+  }
+
+  async undo(session: BaselineSession, filePath: string): Promise<void> {
+    const resolved = resolveSessionFile(session, filePath);
+    await this.serialize([session.id], async () => {
+      const manifest = await this.readManifest(session);
+      const baseline = await this.readEffectiveBaseline(session, resolved.relativePath, manifest);
+      if (baseline === undefined) {
+        throw new BaselineError(
+          `No baseline exists for "${resolved.relativePath}" in session "${session.id}"`,
+        );
+      }
+      await restoreFile(session.workDir, resolved.absolutePath, baseline);
+    });
+  }
+
+  async undoAll(session: BaselineSession): Promise<void> {
+    await this.serialize([session.id], async () => {
+      const manifest = await this.readManifest(session);
+      const relativePaths = await this.effectivePaths(session, manifest);
+      for (const relativePath of relativePaths) {
+        const baseline = await this.readEffectiveBaseline(session, relativePath, manifest);
+        if (baseline === undefined) continue;
+        await restoreFile(
+          session.workDir,
+          resolveSessionFile(session, relativePath).absolutePath,
+          baseline,
+        );
+      }
+    });
+  }
+
+  async keep(session: BaselineSession, filePath: string): Promise<void> {
+    const resolved = resolveSessionFile(session, filePath);
+    await this.serialize([session.id], async () => {
+      const manifest = await this.readManifest(session);
+      const localPath = equivalentPath(
+        session,
+        Object.keys(manifest.entries),
+        resolved.relativePath,
+      );
+      const hadLocal = localPath !== undefined;
+      const hasLegacy = await this.hasLegacyBaseline(session, resolved.relativePath);
+      if (!hadLocal && !hasLegacy) return;
+
+      const next = mutableManifest(manifest);
+      if (localPath !== undefined) delete next.entries[localPath];
+      const accepted = new Set(next.acceptedLegacyPaths);
+      const acceptedPath = equivalentPath(session, accepted, resolved.relativePath);
+      if (acceptedPath !== undefined) accepted.delete(acceptedPath);
+      if (hasLegacy) accepted.add(resolved.relativePath);
+      next.acceptedLegacyPaths = uniquePaths(session, accepted);
+
+      await this.writeManifest(next);
+      await this.removeUnreferencedSnapshots(session.id, next);
+    });
+  }
+
+  async keepAll(session: BaselineSession): Promise<void> {
+    await this.serialize([session.id], async () => {
+      const manifest = await this.readManifest(session);
+      const legacyPaths = await this.listLegacyPaths(session);
+      const next = mutableManifest(manifest);
+      next.entries = {};
+      next.acceptedLegacyPaths = uniquePaths(session, [
+        ...next.acceptedLegacyPaths,
+        ...legacyPaths,
+      ]);
+
+      await this.writeManifest(next);
+      await this.removeUnreferencedSnapshots(session.id, next);
+    });
+  }
+
+  async materializeToFork(source: BaselineSession, target: BaselineSession): Promise<void> {
+    if (source.id === target.id) {
+      throw new BaselineError('Cannot materialize a baseline fork onto the source session');
+    }
+
+    await this.serialize([source.id, target.id], async () => {
+      const sourceManifest = await this.readManifest(source);
+      const sourcePaths = await this.effectivePaths(source, sourceManifest);
+      const values = new Map<string, BaselineValue>();
+      for (const relativePath of sourcePaths) {
+        const baseline = await this.readEffectiveBaseline(source, relativePath, sourceManifest);
+        if (baseline !== undefined) values.set(relativePath, baseline);
+      }
+
+      const targetManifest = await this.readManifest(target);
+      const next = mutableManifest(targetManifest);
+      const accepted = uniquePaths(target, [
+        ...next.acceptedLegacyPaths,
+        ...sourceManifest.acceptedLegacyPaths,
+      ]);
+
+      for (const [relativePath, baseline] of values) {
+        const existingPath = equivalentPath(target, Object.keys(next.entries), relativePath);
+        if (existingPath !== undefined) continue;
+        const snapshot = hash(baseline.content);
+        await this.writeSnapshot(target.id, snapshot, baseline.content);
+        next.entries[relativePath] = {
+          snapshot,
+          existedBefore: baseline.existedBefore,
+        };
+      }
+
+      next.acceptedLegacyPaths = accepted;
+      await this.writeManifest(next);
+    });
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    requireSessionId(sessionId);
+    await this.serialize([sessionId], async () => {
+      await rm(this.sessionRoot(sessionId), { recursive: true, force: true });
+    });
+  }
+
+  private async effectivePaths(
+    session: BaselineSession,
+    manifest: BaselineManifestV1,
+  ): Promise<string[]> {
+    const paths = new Map<string, string>();
+    for (const relativePath of Object.keys(manifest.entries)) {
+      paths.set(pathComparisonKey(session, relativePath), relativePath);
+    }
+    const accepted = new Set(
+      manifest.acceptedLegacyPaths.map((relativePath) =>
+        pathComparisonKey(session, relativePath),
+      ),
+    );
+    for (const relativePath of await this.listLegacyPaths(session)) {
+      const key = pathComparisonKey(session, relativePath);
+      if (!accepted.has(key) && !paths.has(key)) paths.set(key, relativePath);
+    }
+    return [...paths.values()].toSorted();
+  }
+
+  private async readEffectiveBaseline(
+    session: BaselineSession,
+    relativePath: string,
+    manifest: BaselineManifestV1,
+  ): Promise<BaselineValue | undefined> {
+    const localPath = equivalentPath(session, Object.keys(manifest.entries), relativePath);
+    const local = localPath === undefined ? undefined : manifest.entries[localPath];
+    if (localPath !== undefined && local !== undefined) {
+      const content = await this.readSnapshot(session.id, local.snapshot, localPath);
+      return { content, existedBefore: local.existedBefore };
+    }
+
+    if (equivalentPath(session, manifest.acceptedLegacyPaths, relativePath) !== undefined) {
+      return undefined;
+    }
+    return this.readLegacyBaseline(session, relativePath);
+  }
+
+  private async readManifest(session: BaselineSession): Promise<BaselineManifestV1> {
+    requireSession(session);
+    let text: string;
+    try {
+      text = await readFile(this.manifestPath(session.id), 'utf-8');
+    } catch (error) {
+      if (isErrorCode(error, 'ENOENT')) return emptyManifest(session.id);
+      throw new BaselineError(`Unable to read baseline manifest for session "${session.id}"`, {
+        cause: error,
+      });
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(text) as unknown;
+    } catch (error) {
+      throw new BaselineError(`Baseline manifest for session "${session.id}" is invalid JSON`, {
+        cause: error,
+      });
+    }
+    return parseManifest(parsed, session);
+  }
+
+  private async writeManifest(manifest: BaselineManifestV1): Promise<void> {
+    if (
+      Object.keys(manifest.entries).length === 0 &&
+      manifest.acceptedLegacyPaths.length === 0
+    ) {
+      await rm(this.sessionRoot(manifest.sessionId), { recursive: true, force: true });
+      return;
+    }
+
+    const text = `${JSON.stringify(manifest, null, 2)}\n`;
+    await atomicWrite(this.manifestPath(manifest.sessionId), text);
+  }
+
+  private async writeSnapshot(sessionId: string, snapshot: string, content: string): Promise<void> {
+    const snapshotPath = this.snapshotPath(sessionId, snapshot);
+    try {
+      const existing = await readFile(snapshotPath, 'utf-8');
+      if (hash(existing) !== snapshot) {
+        throw new BaselineError(
+          `Baseline snapshot "${snapshot}" for session "${sessionId}" is corrupt`,
+        );
+      }
+      return;
+    } catch (error) {
+      if (!isErrorCode(error, 'ENOENT')) {
+        if (error instanceof BaselineError) throw error;
+        throw new BaselineError(
+          `Unable to inspect baseline snapshot "${snapshot}" for session "${sessionId}"`,
+          { cause: error },
+        );
+      }
+    }
+    await atomicWrite(snapshotPath, content);
+  }
+
+  private async readSnapshot(
+    sessionId: string,
+    snapshot: string,
+    relativePath: string,
+  ): Promise<string> {
+    let content: string;
+    try {
+      content = await readFile(this.snapshotPath(sessionId, snapshot), 'utf-8');
+    } catch (error) {
+      throw new BaselineError(
+        `Unable to read baseline snapshot for "${relativePath}" in session "${sessionId}"`,
+        { cause: error },
+      );
+    }
+    if (hash(content) !== snapshot) {
+      throw new BaselineError(
+        `Baseline snapshot for "${relativePath}" in session "${sessionId}" is corrupt`,
+      );
+    }
+    return content;
+  }
+
+  private async removeUnreferencedSnapshots(
+    sessionId: string,
+    manifest: BaselineManifestV1,
+  ): Promise<void> {
+    const snapshotsDir = this.snapshotsRoot(sessionId);
+    let names: string[];
+    try {
+      names = await readdir(snapshotsDir);
+    } catch (error) {
+      if (isErrorCode(error, 'ENOENT')) return;
+      throw new BaselineError(`Unable to clean baseline snapshots for session "${sessionId}"`, {
+        cause: error,
+      });
+    }
+
+    const referenced = new Set(Object.values(manifest.entries).map((entry) => entry.snapshot));
+    await Promise.all(
+      names.map(async (name) => {
+        if (referenced.has(name)) return;
+        await rm(path.join(snapshotsDir, name), { force: true });
+      }),
+    );
+  }
+
+  private async listLegacyPaths(session: BaselineSession): Promise<string[]> {
+    const root = legacyBaselineRoot(session);
+    if (root === undefined) return [];
+
+    const result: string[] = [];
+    await walkLegacyBaselines(root, '', result);
+    return result.toSorted();
+  }
+
+  private async hasLegacyBaseline(
+    session: BaselineSession,
+    relativePath: string,
+  ): Promise<boolean> {
+    const legacyPath = legacyBaselinePath(session, relativePath);
+    if (legacyPath === undefined) return false;
+    try {
+      const info = await stat(legacyPath);
+      if (!info.isFile()) {
+        throw new BaselineError(`Legacy baseline "${relativePath}" is not a regular file`);
+      }
+      return true;
+    } catch (error) {
+      if (isErrorCode(error, 'ENOENT')) return false;
+      if (error instanceof BaselineError) throw error;
+      throw new BaselineError(`Unable to inspect legacy baseline "${relativePath}"`, {
+        cause: error,
+      });
+    }
+  }
+
+  private async readLegacyBaseline(
+    session: BaselineSession,
+    relativePath: string,
+  ): Promise<BaselineValue | undefined> {
+    const legacyPath = legacyBaselinePath(session, relativePath);
+    if (legacyPath === undefined) return undefined;
+
+    let info;
+    try {
+      info = await stat(legacyPath);
+    } catch (error) {
+      if (isErrorCode(error, 'ENOENT')) return undefined;
+      throw new BaselineError(`Unable to inspect legacy baseline "${relativePath}"`, {
+        cause: error,
+      });
+    }
+    if (!info.isFile()) {
+      throw new BaselineError(`Legacy baseline "${relativePath}" is not a regular file`);
+    }
+
+    try {
+      const content = await readFile(legacyPath, 'utf-8');
+      return { content, existedBefore: content.length > 0 };
+    } catch (error) {
+      throw new BaselineError(`Unable to read legacy baseline "${relativePath}"`, {
+        cause: error,
+      });
+    }
+  }
+
+  private async serialize<T>(sessionIds: readonly string[], operation: () => Promise<T>): Promise<T> {
+    const ids = [...new Set(sessionIds)].toSorted();
+    for (const id of ids) requireSessionId(id);
+
+    const previous = ids.map((id) => this.updates.get(id) ?? Promise.resolve());
+    const run = Promise.all(previous).then(operation);
+    const settled = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    for (const id of ids) this.updates.set(id, settled);
+    void settled.then(() => {
+      for (const id of ids) {
+        if (this.updates.get(id) === settled) this.updates.delete(id);
+      }
+    });
+    return run;
+  }
+
+  private async waitForUpdates(sessionIds: readonly string[]): Promise<void> {
+    await Promise.all(sessionIds.map((id) => this.updates.get(id) ?? Promise.resolve()));
+  }
+
+  private sessionRoot(sessionId: string): string {
+    return path.join(this.baselinesRoot, hash(sessionId));
+  }
+
+  private manifestPath(sessionId: string): string {
+    return path.join(this.sessionRoot(sessionId), 'manifest.json');
+  }
+
+  private snapshotsRoot(sessionId: string): string {
+    return path.join(this.sessionRoot(sessionId), 'snapshots');
+  }
+
+  private snapshotPath(sessionId: string, snapshot: string): string {
+    if (!SNAPSHOT_HASH.test(snapshot)) {
+      throw new BaselineError(`Invalid baseline snapshot hash "${snapshot}"`);
+    }
+    return path.join(this.snapshotsRoot(sessionId), snapshot);
+  }
+}
+
+function emptyManifest(sessionId: string): BaselineManifestV1 {
+  return { version: MANIFEST_VERSION, sessionId, entries: {}, acceptedLegacyPaths: [] };
+}
+
+function mutableManifest(manifest: BaselineManifestV1): MutableManifest {
+  return {
+    version: MANIFEST_VERSION,
+    sessionId: manifest.sessionId,
+    entries: { ...manifest.entries },
+    acceptedLegacyPaths: [...manifest.acceptedLegacyPaths],
+  };
+}
+
+function parseManifest(value: unknown, session: BaselineSession): BaselineManifestV1 {
+  if (!isRecord(value) || value['version'] !== MANIFEST_VERSION) {
+    throw new BaselineError(`Unsupported baseline manifest for session "${session.id}"`);
+  }
+  if (value['sessionId'] !== session.id) {
+    throw new BaselineError(`Baseline manifest does not belong to session "${session.id}"`);
+  }
+
+  const rawEntries = value['entries'];
+  const rawAccepted = value['acceptedLegacyPaths'];
+  if (!isRecord(rawEntries) || !Array.isArray(rawAccepted)) {
+    throw new BaselineError(`Invalid baseline manifest for session "${session.id}"`);
+  }
+
+  const entries: Record<string, ManifestEntry> = {};
+  const entryKeys = new Set<string>();
+  for (const [rawPath, rawEntry] of Object.entries(rawEntries)) {
+    if (
+      !isRecord(rawEntry) ||
+      typeof rawEntry['snapshot'] !== 'string' ||
+      !SNAPSHOT_HASH.test(rawEntry['snapshot']) ||
+      typeof rawEntry['existedBefore'] !== 'boolean'
+    ) {
+      throw new BaselineError(`Invalid baseline entry "${rawPath}" in session "${session.id}"`);
+    }
+    const relativePath = resolveSessionFile(session, rawPath).relativePath;
+    const comparisonKey = pathComparisonKey(session, relativePath);
+    if (relativePath !== rawPath || entryKeys.has(comparisonKey)) {
+      throw new BaselineError(`Unsafe baseline path "${rawPath}" in session "${session.id}"`);
+    }
+    entryKeys.add(comparisonKey);
+    entries[relativePath] = {
+      snapshot: rawEntry['snapshot'],
+      existedBefore: rawEntry['existedBefore'],
+    };
+  }
+
+  const acceptedLegacyPaths: string[] = [];
+  for (const rawPath of rawAccepted) {
+    if (typeof rawPath !== 'string') {
+      throw new BaselineError(`Invalid accepted legacy path in session "${session.id}"`);
+    }
+    const relativePath = resolveSessionFile(session, rawPath).relativePath;
+    if (relativePath !== rawPath) {
+      throw new BaselineError(`Unsafe accepted legacy path "${rawPath}" in session "${session.id}"`);
+    }
+    if (equivalentPath(session, acceptedLegacyPaths, relativePath) === undefined) {
+      acceptedLegacyPaths.push(relativePath);
+    }
+  }
+
+  return {
+    version: MANIFEST_VERSION,
+    sessionId: session.id,
+    entries,
+    acceptedLegacyPaths: uniquePaths(session, acceptedLegacyPaths),
+  };
+}
+
+function equivalentPath(
+  session: BaselineSession,
+  paths: Iterable<string>,
+  candidate: string,
+): string | undefined {
+  const candidateKey = pathComparisonKey(session, candidate);
+  for (const existing of paths) {
+    if (pathComparisonKey(session, existing) === candidateKey) return existing;
+  }
+  return undefined;
+}
+
+function uniquePaths(session: BaselineSession, paths: Iterable<string>): string[] {
+  const unique = new Map<string, string>();
+  for (const relativePath of paths) {
+    const key = pathComparisonKey(session, relativePath);
+    if (!unique.has(key)) unique.set(key, relativePath);
+  }
+  return [...unique.values()].toSorted();
+}
+
+function pathComparisonKey(session: BaselineSession, relativePath: string): string {
+  return isWindowsAbsolute(session.workDir) ? relativePath.toLowerCase() : relativePath;
+}
+
+function resolveSessionFile(session: BaselineSession, filePath: string): ResolvedFile {
+  requireSession(session);
+  if (filePath.length === 0) throw new BaselineError('The baseline file path is empty');
+
+  const windows = isWindowsAbsolute(session.workDir);
+  if (!windows && isWindowsAbsolute(filePath)) {
+    throw new BaselineError(`File "${filePath}" is outside workspace "${session.workDir}"`);
+  }
+
+  const paths = windows ? path.win32 : path;
+  const root = paths.resolve(session.workDir);
+  const absolutePath = paths.resolve(root, filePath);
+  const relativePath = paths.relative(root, absolutePath);
+  const parentPrefix = `..${paths.sep}`;
+  if (
+    relativePath.length === 0 ||
+    relativePath === '..' ||
+    relativePath.startsWith(parentPrefix) ||
+    paths.isAbsolute(relativePath)
+  ) {
+    throw new BaselineError(`File "${filePath}" is outside workspace "${session.workDir}"`);
+  }
+
+  return {
+    absolutePath,
+    relativePath: windows ? relativePath.replaceAll('\\', '/') : relativePath,
+  };
+}
+
+function isWindowsAbsolute(value: string): boolean {
+  return /^[a-zA-Z]:[\\/]/.test(value) || /^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(value);
+}
+
+function legacyBaselineRoot(session: BaselineSession): string | undefined {
+  const source = session.metadata?.['kimi_cli_source_path'];
+  if (typeof source !== 'string' || source.length === 0) return undefined;
+
+  const sourceIsWindows = isWindowsAbsolute(source);
+  if (sourceIsWindows !== (process.platform === 'win32')) return undefined;
+  if (!path.isAbsolute(source)) return undefined;
+  return path.join(source, 'baseline');
+}
+
+function legacyBaselinePath(
+  session: BaselineSession,
+  relativePath: string,
+): string | undefined {
+  const root = legacyBaselineRoot(session);
+  if (root === undefined) return undefined;
+  const resolved = resolveSessionFile(session, relativePath);
+  return path.join(root, ...resolved.relativePath.split('/'));
+}
+
+async function walkLegacyBaselines(
+  directory: string,
+  relativeDirectory: string,
+  result: string[],
+): Promise<void> {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (isErrorCode(error, 'ENOENT') && relativeDirectory.length === 0) return;
+    throw new BaselineError(`Unable to list legacy baseline directory "${directory}"`, {
+      cause: error,
+    });
+  }
+
+  for (const entry of entries) {
+    const relativePath = relativeDirectory
+      ? `${relativeDirectory}/${entry.name}`
+      : entry.name;
+    if (entry.isDirectory()) {
+      await walkLegacyBaselines(path.join(directory, entry.name), relativePath, result);
+    } else if (entry.isFile()) {
+      result.push(relativePath);
+    }
+  }
+}
+
+function captureOriginal(absolutePath: string): BaselineValue {
+  let info;
+  try {
+    info = statSync(absolutePath);
+  } catch (error) {
+    if (isErrorCode(error, 'ENOENT')) return { content: '', existedBefore: false };
+    throw new BaselineError(`Unable to inspect original file "${absolutePath}"`, {
+      cause: error,
+    });
+  }
+  if (!info.isFile()) {
+    throw new BaselineError(`Original path "${absolutePath}" is not a regular file`);
+  }
+
+  try {
+    return { content: readFileSync(absolutePath, 'utf-8'), existedBefore: true };
+  } catch (error) {
+    throw new BaselineError(`Unable to capture original file "${absolutePath}"`, {
+      cause: error,
+    });
+  }
+}
+
+async function readCurrentFile(absolutePath: string): Promise<string | undefined> {
+  try {
+    return await readFile(absolutePath, 'utf-8');
+  } catch (error) {
+    if (isErrorCode(error, 'ENOENT')) return undefined;
+    throw new BaselineError(`Unable to read current file "${absolutePath}"`, { cause: error });
+  }
+}
+
+async function restoreFile(
+  workDir: string,
+  absolutePath: string,
+  baseline: BaselineValue,
+): Promise<void> {
+  await requireContainedRestorePath(workDir, absolutePath);
+  if (!baseline.existedBefore) {
+    try {
+      await unlink(absolutePath);
+    } catch (error) {
+      if (!isErrorCode(error, 'ENOENT')) {
+        throw new BaselineError(`Unable to remove newly created file "${absolutePath}"`, {
+          cause: error,
+        });
+      }
+    }
+    return;
+  }
+
+  try {
+    await mkdir(path.dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, baseline.content, 'utf-8');
+  } catch (error) {
+    throw new BaselineError(`Unable to restore file "${absolutePath}"`, { cause: error });
+  }
+}
+
+async function requireContainedRestorePath(workDir: string, absolutePath: string): Promise<void> {
+  try {
+    const [realWorkDir, realTarget] = await Promise.all([
+      realpath(workDir),
+      realExistingPath(absolutePath),
+    ]);
+    if (relativeFsPath(realWorkDir, realTarget) === undefined) {
+      throw new BaselineError(`Refusing to restore path outside the session workspace: "${absolutePath}"`);
+    }
+  } catch (error) {
+    if (error instanceof BaselineError) throw error;
+    throw new BaselineError(`Unable to validate restore path "${absolutePath}"`, { cause: error });
+  }
+}
+
+async function realExistingPath(candidate: string): Promise<string> {
+  let current = candidate;
+  while (true) {
+    try {
+      return await realpath(current);
+    } catch (error) {
+      if (!isErrorCode(error, 'ENOENT')) throw error;
+      let isDanglingSymlink = false;
+      try {
+        isDanglingSymlink = (await lstat(current)).isSymbolicLink();
+      } catch (lstatError) {
+        if (!isErrorCode(lstatError, 'ENOENT')) throw lstatError;
+      }
+      if (isDanglingSymlink) throw error;
+      const parent = path.dirname(current);
+      if (parent === current) throw error;
+      current = parent;
+    }
+  }
+}
+
+async function atomicWrite(targetPath: string, content: string): Promise<void> {
+  await mkdir(path.dirname(targetPath), { recursive: true, mode: 0o700 });
+  const temporaryPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporaryPath, content, { encoding: 'utf-8', mode: 0o600 });
+    await rename(temporaryPath, targetPath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => undefined);
+    throw new BaselineError(`Unable to atomically write "${targetPath}"`, { cause: error });
+  }
+}
+
+function requireSession(session: BaselineSession): void {
+  requireSessionId(session.id);
+  if (session.workDir.length === 0) throw new BaselineError('The session workspace path is empty');
+}
+
+function requireSessionId(sessionId: string): void {
+  if (sessionId.length === 0) throw new BaselineError('The baseline session id is empty');
+}
+
+function hash(value: string): string {
+  return createHash('sha256').update(value, 'utf-8').digest('hex');
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isErrorCode(error: unknown, code: string): boolean {
+  return isRecord(error) && error['code'] === code;
+}
+
+function countLines(content: string): number {
+  if (content.length === 0) return 0;
+  return content.replaceAll('\r\n', '\n').split('\n').length;
+}
+
+function computeLineDiff(
+  oldContent: string,
+  newContent: string,
+): { additions: number; deletions: number } {
+  const lines = (content: string): string[] =>
+    content.length === 0 ? [] : content.replaceAll('\r\n', '\n').split('\n');
+  const oldLines = lines(oldContent);
+  const newLines = lines(newContent);
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+  return {
+    additions: newLines.filter((line) => !oldSet.has(line)).length,
+    deletions: oldLines.filter((line) => !newSet.has(line)).length,
+  };
+}
diff --git a/apps/vscode/src/managers/file.manager.ts b/apps/vscode/src/managers/file.manager.ts
new file mode 100644
index 000000000..2e1b1f6c1
--- /dev/null
+++ b/apps/vscode/src/managers/file.manager.ts
@@ -0,0 +1,208 @@
+import * as vscode from "vscode";
+import * as path from "node:path";
+import { BaselineManager, type BaselineSession } from "./baseline.manager";
+import { Events } from "../../shared/bridge";
+import type { ProjectFile } from "../../shared/types";
+import { buildCaseInsensitiveGlobLiteral } from "../utils/string";
+import {
+  isWorkspacePathContained,
+  relativeWorkspacePath,
+  resolveWorkspacePath,
+} from "../utils/workspace-path";
+
+export type BroadcastFn = (event: string, data: unknown, webviewId?: string) => void;
+
+const IGNORE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  ".cache",
+  ".venv",
+  "venv",
+  ".gradle",
+  ".idea",
+  ".DS_Store",
+  "Thumbs.db",
+  "coverage",
+  ".nyc_output",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".tox",
+  ".eggs",
+  ".sass-cache",
+  ".parcel-cache",
+  "bower_components",
+  "jspm_packages",
+  ".turbo",
+]);
+
+const IGNORE_EXT = new Set([".lock", ".log", ".map", ".min.js", ".min.css", ".chunk.js", ".chunk.css"]);
+
+function shouldIgnore(name: string): boolean {
+  if (IGNORE_DIRS.has(name)) {
+    return true;
+  }
+  const ext = path.extname(name).toLowerCase();
+  return IGNORE_EXT.has(ext);
+}
+
+const SEARCH_EXCLUDE = `{${[...IGNORE_DIRS].map((d) => `**/${d}`).join(",")}}`;
+
+interface ViewState {
+  session: BaselineSession | null;
+  trackedFiles: Set<string>;
+}
+
+export class FileManager {
+  private viewStates = new Map<string, ViewState>();
+  private disposables: vscode.Disposable[] = [];
+
+  constructor(
+    private readonly baselineManager: BaselineManager,
+    private broadcast: BroadcastFn,
+  ) {
+    // Watch for file changes
+    const watcher = vscode.workspace.createFileSystemWatcher("**/*");
+
+    const refresh = (uri: vscode.Uri) => {
+      void this.onFileChange(uri).catch((error) => {
+        console.error("[kimi-vscode] Unable to refresh file changes", error);
+      });
+    };
+    watcher.onDidChange(refresh);
+    watcher.onDidCreate(refresh);
+    watcher.onDidDelete(refresh);
+
+    this.disposables.push(watcher);
+  }
+
+  private getViewState(webviewId: string): ViewState {
+    let state = this.viewStates.get(webviewId);
+    if (!state) {
+      state = { session: null, trackedFiles: new Set() };
+      this.viewStates.set(webviewId, state);
+    }
+    return state;
+  }
+
+  setSession(webviewId: string, session: BaselineSession): void {
+    this.getViewState(webviewId).session = session;
+  }
+
+  clearSession(webviewId: string): void {
+    const state = this.getViewState(webviewId);
+    state.session = null;
+    state.trackedFiles.clear();
+  }
+
+  getSessionId(webviewId: string): string | null {
+    return this.getViewState(webviewId).session?.id ?? null;
+  }
+
+  getSession(webviewId: string): BaselineSession | null {
+    return this.getViewState(webviewId).session;
+  }
+
+  trackFile(webviewId: string, absolutePath: string): void {
+    this.getViewState(webviewId).trackedFiles.add(absolutePath);
+  }
+
+  getTracked(webviewId: string): Set<string> {
+    return this.getViewState(webviewId).trackedFiles;
+  }
+
+  clearTracked(webviewId: string): void {
+    this.getViewState(webviewId).trackedFiles.clear();
+  }
+
+  disposeView(webviewId: string): void {
+    this.viewStates.delete(webviewId);
+  }
+
+  private async onFileChange(uri: vscode.Uri): Promise<void> {
+    const absolutePath = uri.fsPath;
+
+    for (const [webviewId, state] of this.viewStates) {
+      if (!state.session || !state.trackedFiles.has(absolutePath)) {
+        continue;
+      }
+
+      await this.refreshChanges(webviewId);
+    }
+  }
+
+  async refreshChanges(webviewId: string): Promise<void> {
+    const state = this.getViewState(webviewId);
+    if (state.session === null) {
+      this.broadcast(Events.FileChangesUpdated, [], webviewId);
+      return;
+    }
+    const changes = await this.baselineManager.getChanges(state.session);
+    this.broadcast(Events.FileChangesUpdated, changes, webviewId);
+  }
+
+  async searchFiles(workDirUri: vscode.Uri, query?: string): Promise<ProjectFile[]> {
+    query = query ? buildCaseInsensitiveGlobLiteral(query) : "";
+    const pattern = query ? `**/*${query}*` : "**/*";
+    const files = await vscode.workspace.findFiles(
+      new vscode.RelativePattern(workDirUri, pattern),
+      new vscode.RelativePattern(workDirUri, SEARCH_EXCLUDE),
+      200,
+    );
+    const results = await Promise.all(
+      files.map(async (uri): Promise<ProjectFile | undefined> => {
+        const relativePath = relativeWorkspacePath(workDirUri, uri);
+        if (relativePath === undefined || !(await isWorkspacePathContained(workDirUri, uri))) return undefined;
+        return {
+          path: relativePath,
+          name: path.posix.basename(relativePath),
+          isDirectory: false,
+        };
+      }),
+    );
+    return results.filter((result): result is ProjectFile => result !== undefined);
+  }
+
+  async listDirectory(workDirUri: vscode.Uri, directory: string): Promise<ProjectFile[]> {
+    const requested = resolveWorkspacePath(workDirUri, directory, { allowRoot: true });
+    if (requested === undefined || !(await isWorkspacePathContained(workDirUri, requested.uri))) return [];
+    try {
+      const entries = await vscode.workspace.fs.readDirectory(requested.uri);
+      const resolvedEntries = await Promise.all(
+        entries.map(async ([name, type]): Promise<ProjectFile | undefined> => {
+          if (shouldIgnore(name)) return undefined;
+          const relativePath = requested.relativePath ? `${requested.relativePath}/${name}` : name;
+          const entry = resolveWorkspacePath(workDirUri, relativePath);
+          if (entry === undefined || !(await isWorkspacePathContained(workDirUri, entry.uri))) return undefined;
+          return {
+            path: entry.relativePath,
+            name,
+            isDirectory: (type & vscode.FileType.Directory) !== 0,
+          };
+        }),
+      );
+      return resolvedEntries
+        .filter((entry): entry is ProjectFile => entry !== undefined)
+        .toSorted((a, b) =>
+          a.isDirectory === b.isDirectory ? a.name.localeCompare(b.name) : a.isDirectory ? -1 : 1,
+        );
+    } catch {
+      return [];
+    }
+  }
+
+  dispose(): void {
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+    this.disposables = [];
+    this.viewStates.clear();
+  }
+}
diff --git a/apps/vscode/src/migration/index.ts b/apps/vscode/src/migration/index.ts
new file mode 100644
index 000000000..6e22499bd
--- /dev/null
+++ b/apps/vscode/src/migration/index.ts
@@ -0,0 +1 @@
+export * from "./legacy-migration.manager";
diff --git a/apps/vscode/src/migration/legacy-migration.manager.ts b/apps/vscode/src/migration/legacy-migration.manager.ts
new file mode 100644
index 000000000..70d2e8c69
--- /dev/null
+++ b/apps/vscode/src/migration/legacy-migration.manager.ts
@@ -0,0 +1,705 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve, win32 } from "node:path";
+
+import {
+  detectMigration,
+  runMigration,
+  shouldSuppressMigration,
+  type MigrationPlan,
+  type MigrationReport,
+  type MigrationScope,
+} from "@moonshot-ai/migration-legacy";
+
+const FULL_MIGRATION_SCOPE = {
+  config: true,
+  mcp: true,
+  userHistory: true,
+  skills: true,
+  sessions: true,
+} satisfies MigrationScope;
+
+export type LegacyMigrationSourceOrigin = "default" | "legacy-vscode-setting";
+
+export type LegacyMigrationWarningCode =
+  | "invalid-share-dir"
+  | "relative-share-dir"
+  | "source-equals-target"
+  | "source-not-directory"
+  | "source-unreadable"
+  | "legacy-session-unreadable"
+  | "detection-failed";
+
+export interface LegacyMigrationWarning {
+  readonly code: LegacyMigrationWarningCode;
+  readonly message: string;
+  readonly sourceHome?: string;
+}
+
+export interface LegacyMigrationReauthItem {
+  readonly sourceHome: string;
+  readonly name: string;
+}
+
+export interface LegacyMigrationNotices {
+  readonly oauthLoginsRequiringRelogin: readonly LegacyMigrationReauthItem[];
+  readonly mcpOauthServersRequiringReauth: readonly LegacyMigrationReauthItem[];
+}
+
+export interface LegacyMigrationSourcePreview {
+  readonly sourceHome: string;
+  readonly origin: LegacyMigrationSourceOrigin;
+  readonly hasConfig: boolean;
+  readonly hasMcp: boolean;
+  readonly hasUserHistory: boolean;
+  readonly hasSkills: boolean;
+  readonly totalSessions: number;
+  readonly sessionIssues: number;
+}
+
+export interface LegacyMigrationPromptModel {
+  readonly kind: "legacy-migration";
+  readonly message: string;
+  readonly actions: readonly [
+    { readonly id: "now"; readonly label: "Migrate Now" },
+    { readonly id: "later"; readonly label: "Later" },
+  ];
+  readonly sources: readonly LegacyMigrationSourcePreview[];
+  readonly notices: LegacyMigrationNotices;
+}
+
+export interface LegacyMigrationDiscovery {
+  readonly prompt: LegacyMigrationPromptModel | null;
+  readonly suppressedSources: readonly LegacyMigrationSourcePreview[];
+  readonly warnings: readonly LegacyMigrationWarning[];
+  readonly notices: LegacyMigrationNotices;
+}
+
+export interface LegacyMigrationManagerOptions {
+  /** Harness-resolved homeDir. */
+  readonly targetHome: string;
+  /** Defaults to the legacy kimi-cli home (`~/.kimi`). Injectable for isolated tests. */
+  readonly defaultSourceHome?: string;
+  /** First workspace root. Used only to resolve a relative legacy KIMI_SHARE_DIR. */
+  readonly workspaceRoot?: string | null;
+  /** The removed `kimi.environmentVariables` VS Code setting, read once for migration. */
+  readonly legacyEnvironmentVariables?: unknown;
+}
+
+export type LegacyMigrationFailureCode =
+  | "run-failed"
+  | "legacy-config-unreadable"
+  | "legacy-mcp-unreadable"
+  | "session-failed";
+
+export interface LegacyMigrationFailure {
+  readonly code: LegacyMigrationFailureCode;
+  readonly sourceHome: string;
+  readonly item?: string;
+  readonly message: string;
+}
+
+export interface LegacyMigrationTotals {
+  readonly configFiles: number;
+  readonly mcpServers: number;
+  readonly userHistoryEntries: number;
+  readonly skills: number;
+  readonly sessions: number;
+  readonly alreadyMigratedSessions: number;
+  readonly skippedItems: number;
+  readonly conflicts: number;
+  readonly failures: number;
+}
+
+export interface LegacyMigrationSourceResult {
+  readonly source: LegacyMigrationSourcePreview;
+  readonly status: "completed" | "partial" | "failed";
+  readonly report?: MigrationReport;
+  readonly failures: readonly LegacyMigrationFailure[];
+  readonly error?: unknown;
+}
+
+export interface LegacyMigrationRunResult {
+  readonly status: "completed" | "partial" | "failed" | "nothing-to-migrate";
+  readonly message: string;
+  readonly sources: readonly LegacyMigrationSourceResult[];
+  readonly suppressedSources: readonly LegacyMigrationSourcePreview[];
+  readonly totals: LegacyMigrationTotals;
+  readonly warnings: readonly LegacyMigrationWarning[];
+  readonly notices: LegacyMigrationNotices;
+  readonly manualActions: readonly string[];
+}
+
+interface InspectedSource {
+  readonly preview: LegacyMigrationSourcePreview;
+  readonly plan: MigrationPlan;
+  readonly legacyMcpJsonValid: boolean;
+}
+
+interface InspectionResult {
+  readonly pending: readonly InspectedSource[];
+  readonly suppressed: readonly LegacyMigrationSourcePreview[];
+  readonly warnings: readonly LegacyMigrationWarning[];
+  readonly notices: LegacyMigrationNotices;
+}
+
+interface SourceCandidate {
+  readonly sourceHome: string;
+  readonly origin: LegacyMigrationSourceOrigin;
+}
+
+/**
+ * Coordinates legacy kimi-cli migration for the VS Code host while keeping all
+ * data translation inside the shared migration package.
+ */
+export class LegacyMigrationManager {
+  readonly targetHome: string;
+
+  private readonly defaultSourceHome: string;
+  private readonly workspaceRoot: string | null;
+  private readonly legacyEnvironmentVariables: unknown;
+
+  constructor(options: LegacyMigrationManagerOptions) {
+    if (options.targetHome.trim().length === 0) {
+      throw new Error("LegacyMigrationManager requires a non-empty targetHome.");
+    }
+    this.targetHome = resolve(options.targetHome);
+    this.defaultSourceHome = resolve(options.defaultSourceHome ?? join(homedir(), ".kimi"));
+    this.workspaceRoot =
+      options.workspaceRoot === undefined || options.workspaceRoot === null
+        ? null
+        : resolve(options.workspaceRoot);
+    this.legacyEnvironmentVariables = options.legacyEnvironmentVariables;
+  }
+
+  /** Detect first-launch work without changing the source or target. */
+  async discover(): Promise<LegacyMigrationDiscovery> {
+    const inspection = await this.inspect(false);
+    const sources = inspection.pending.map((source) => source.preview);
+    return {
+      prompt:
+        sources.length === 0
+          ? null
+          : {
+              kind: "legacy-migration",
+              message:
+                "Legacy Kimi data was found. Migrate config, MCP servers, history, skills, and sessions into Kimi Code? Your old data will be kept.",
+              actions: [
+                { id: "now", label: "Migrate Now" },
+                { id: "later", label: "Later" },
+              ],
+              sources,
+              notices: inspection.notices,
+            },
+      suppressedSources: inspection.suppressed,
+      warnings: inspection.warnings,
+      notices: inspection.notices,
+    };
+  }
+
+  /** Run the migration selected from the first-launch prompt. */
+  async migrateNow(): Promise<LegacyMigrationRunResult> {
+    return this.execute(false);
+  }
+
+  /**
+   * Explicit command-palette retry. Marker suppression is intentionally
+   * bypassed because a completed marker may also describe a partially failed
+   * run, while the shared migrator itself remains idempotent.
+   */
+  async retry(): Promise<LegacyMigrationRunResult> {
+    return this.execute(true);
+  }
+
+  private async execute(ignoreMarker: boolean): Promise<LegacyMigrationRunResult> {
+    const inspection = await this.inspect(ignoreMarker);
+    const sourceResults: LegacyMigrationSourceResult[] = [];
+
+    for (const source of inspection.pending) {
+      try {
+        const report = await runMigration({
+          // The shared package owns its migration/schema version. It must not
+          // be coupled to the VS Code extension's release version.
+          plan: source.plan,
+          scope: FULL_MIGRATION_SCOPE,
+          source: source.preview.sourceHome,
+          target: this.targetHome,
+        });
+        const failures = failuresFromReport(source, report);
+        sourceResults.push({
+          source: source.preview,
+          status: failures.length === 0 ? "completed" : "partial",
+          report,
+          failures,
+        });
+      } catch (error) {
+        sourceResults.push({
+          source: source.preview,
+          status: "failed",
+          failures: [
+            {
+              code: "run-failed",
+              sourceHome: source.preview.sourceHome,
+              message: formatError(error),
+            },
+          ],
+          error,
+        });
+      }
+    }
+
+    const status = runStatus(sourceResults);
+    const totals = aggregateTotals(sourceResults);
+    const manualActions = aggregateManualActions(sourceResults);
+    return {
+      status,
+      message: runMessage(status, totals),
+      sources: sourceResults,
+      suppressedSources: inspection.suppressed,
+      totals,
+      warnings: inspection.warnings,
+      notices: mergeRunNotices(inspection.notices, sourceResults),
+      manualActions,
+    };
+  }
+
+  private async inspect(ignoreMarker: boolean): Promise<InspectionResult> {
+    const { candidates, warnings } = this.sourceCandidates();
+    const pending: InspectedSource[] = [];
+    const suppressed: LegacyMigrationSourcePreview[] = [];
+    const oauthLoginsRequiringRelogin: LegacyMigrationReauthItem[] = [];
+    const mcpOauthServersRequiringReauth: LegacyMigrationReauthItem[] = [];
+
+    for (const candidate of candidates) {
+      const sourceCheck = await checkSourceDirectory(candidate.sourceHome);
+      if (sourceCheck === "missing") continue;
+      if (sourceCheck === "not-directory") {
+        warnings.push({
+          code: "source-not-directory",
+          sourceHome: candidate.sourceHome,
+          message: `Legacy migration source is not a directory: ${candidate.sourceHome}`,
+        });
+        continue;
+      }
+      if (sourceCheck === "unreadable") {
+        warnings.push({
+          code: "source-unreadable",
+          sourceHome: candidate.sourceHome,
+          message: `Legacy migration source cannot be read: ${candidate.sourceHome}`,
+        });
+        continue;
+      }
+
+      let plan: MigrationPlan;
+      try {
+        plan = await detectMigration({ sourcePath: candidate.sourceHome });
+      } catch (error) {
+        warnings.push({
+          code: "detection-failed",
+          sourceHome: candidate.sourceHome,
+          message: `Unable to inspect legacy data at ${candidate.sourceHome}: ${formatError(error)}`,
+        });
+        continue;
+      }
+
+      oauthLoginsRequiringRelogin.push(
+        ...plan.oauthCredentials.map((name) => ({ sourceHome: candidate.sourceHome, name })),
+      );
+      mcpOauthServersRequiringReauth.push(
+        ...plan.detectedMcpOauthServers.map((name) => ({
+          sourceHome: candidate.sourceHome,
+          name,
+        })),
+      );
+
+      const hasSkills = await directoryHasEntries(join(candidate.sourceHome, "skills"));
+      const sessionScanFailures = plan.sessionScanFailures ?? [];
+      warnings.push(
+        ...sessionScanFailures.map((failure) => ({
+          code: "legacy-session-unreadable" as const,
+          sourceHome: candidate.sourceHome,
+          message: `${failure.reason} Source: ${failure.sourcePath}`,
+        })),
+      );
+      const preview: LegacyMigrationSourcePreview = {
+        sourceHome: candidate.sourceHome,
+        origin: candidate.origin,
+        hasConfig: plan.hasConfig,
+        hasMcp: plan.hasMcp,
+        hasUserHistory: plan.hasUserHistory,
+        hasSkills,
+        totalSessions: plan.totalSessions,
+        sessionIssues: sessionScanFailures.length,
+      };
+      if (!hasMigratableData(preview)) continue;
+
+      if (
+        !ignoreMarker &&
+        shouldSuppressMigration({
+          sourceHome: candidate.sourceHome,
+          targetHome: this.targetHome,
+        })
+      ) {
+        suppressed.push(preview);
+        continue;
+      }
+
+      pending.push({
+        preview,
+        plan,
+        legacyMcpJsonValid: await isLegacyMcpJsonValid(plan, candidate.sourceHome),
+      });
+    }
+
+    return {
+      pending,
+      suppressed,
+      warnings,
+      notices: {
+        oauthLoginsRequiringRelogin: dedupeReauthItems(oauthLoginsRequiringRelogin),
+        mcpOauthServersRequiringReauth: dedupeReauthItems(
+          mcpOauthServersRequiringReauth,
+        ),
+      },
+    };
+  }
+
+  private sourceCandidates(): {
+    candidates: SourceCandidate[];
+    warnings: LegacyMigrationWarning[];
+  } {
+    const warnings: LegacyMigrationWarning[] = [];
+    const candidates: SourceCandidate[] = [
+      { sourceHome: this.defaultSourceHome, origin: "default" },
+    ];
+    const shareDir = readLegacyShareDir(this.legacyEnvironmentVariables);
+
+    if (shareDir.kind === "invalid") {
+      warnings.push({
+        code: "invalid-share-dir",
+        message: shareDir.message,
+      });
+    } else if (shareDir.kind === "value") {
+      let sourceHome: string | undefined;
+      if (isAbsolute(shareDir.value)) {
+        sourceHome = resolve(shareDir.value);
+      } else if (this.workspaceRoot === null) {
+        warnings.push({
+          code: "invalid-share-dir",
+          message:
+            "The legacy KIMI_SHARE_DIR is relative, but no workspace is open; this migration source was ignored.",
+        });
+      } else {
+        sourceHome = resolve(this.workspaceRoot, shareDir.value);
+        warnings.push({
+          code: "relative-share-dir",
+          sourceHome,
+          message: `The legacy relative KIMI_SHARE_DIR was resolved against the workspace: ${sourceHome}`,
+        });
+      }
+
+      if (sourceHome !== undefined && samePath(sourceHome, this.targetHome)) {
+        warnings.push({
+          code: "source-equals-target",
+          sourceHome,
+          message: "The legacy KIMI_SHARE_DIR resolves to the Kimi Code home and was ignored.",
+        });
+      } else if (
+        sourceHome !== undefined &&
+        !candidates.some((candidate) => samePath(candidate.sourceHome, sourceHome))
+      ) {
+        candidates.push({ sourceHome, origin: "legacy-vscode-setting" });
+      }
+    }
+
+    return { candidates, warnings };
+  }
+}
+
+function readLegacyShareDir(
+  environmentVariables: unknown,
+): { readonly kind: "missing" } | { readonly kind: "value"; readonly value: string } | {
+  readonly kind: "invalid";
+  readonly message: string;
+} {
+  if (environmentVariables === undefined) return { kind: "missing" };
+  if (
+    typeof environmentVariables !== "object" ||
+    environmentVariables === null ||
+    Array.isArray(environmentVariables)
+  ) {
+    return {
+      kind: "invalid",
+      message: "The legacy kimi.environmentVariables setting is invalid and was ignored.",
+    };
+  }
+
+  const value = (environmentVariables as Record<string, unknown>)["KIMI_SHARE_DIR"];
+  if (value === undefined) return { kind: "missing" };
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return {
+      kind: "invalid",
+      message: "The legacy KIMI_SHARE_DIR must be a non-empty string and was ignored.",
+    };
+  }
+  return { kind: "value", value };
+}
+
+async function checkSourceDirectory(
+  sourceHome: string,
+): Promise<"ok" | "missing" | "not-directory" | "unreadable"> {
+  try {
+    const sourceStat = await stat(sourceHome);
+    if (!sourceStat.isDirectory()) return "not-directory";
+  } catch (error) {
+    return isMissingError(error) ? "missing" : "unreadable";
+  }
+
+  try {
+    await readdir(sourceHome);
+    return "ok";
+  } catch {
+    return "unreadable";
+  }
+}
+
+function isMissingError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { readonly code?: unknown }).code === "ENOENT"
+  );
+}
+
+async function directoryHasEntries(path: string): Promise<boolean> {
+  try {
+    return (await readdir(path)).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function isLegacyMcpJsonValid(
+  plan: MigrationPlan,
+  sourceHome: string,
+): Promise<boolean> {
+  if (!plan.hasMcp) return true;
+  try {
+    JSON.parse(await readFile(join(sourceHome, "mcp.json"), "utf-8"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function hasMigratableData(source: LegacyMigrationSourcePreview): boolean {
+  return (
+    source.hasConfig ||
+    source.hasMcp ||
+    source.hasUserHistory ||
+    source.hasSkills ||
+    source.totalSessions > 0 ||
+    source.sessionIssues > 0
+  );
+}
+
+function failuresFromReport(
+  source: InspectedSource,
+  report: MigrationReport,
+): LegacyMigrationFailure[] {
+  const failures: LegacyMigrationFailure[] = [];
+  if (source.plan.hasConfig && !report.summary.config.migrated) {
+    failures.push({
+      code: "legacy-config-unreadable",
+      sourceHome: source.preview.sourceHome,
+      item: "config.toml",
+      message: "The legacy config.toml could not be read or parsed; review it manually.",
+    });
+  }
+  if (source.plan.hasMcp && !source.legacyMcpJsonValid) {
+    failures.push({
+      code: "legacy-mcp-unreadable",
+      sourceHome: source.preview.sourceHome,
+      item: "mcp.json",
+      message: "The legacy mcp.json could not be parsed; review it manually.",
+    });
+  }
+  failures.push(
+    ...report.summary.sessions.sessionsFailed.map((failure) => ({
+      code: "session-failed" as const,
+      sourceHome: source.preview.sourceHome,
+      item: failure.sourcePath,
+      message: failure.reason,
+    })),
+  );
+  return failures;
+}
+
+function runStatus(
+  sources: readonly LegacyMigrationSourceResult[],
+): LegacyMigrationRunResult["status"] {
+  if (sources.length === 0) return "nothing-to-migrate";
+  if (sources.every((source) => source.status === "failed")) return "failed";
+  if (sources.some((source) => source.status !== "completed")) return "partial";
+  return "completed";
+}
+
+function aggregateTotals(sources: readonly LegacyMigrationSourceResult[]): LegacyMigrationTotals {
+  let configFiles = 0;
+  let mcpServers = 0;
+  let userHistoryEntries = 0;
+  let skills = 0;
+  let sessions = 0;
+  let alreadyMigratedSessions = 0;
+  let skippedItems = 0;
+  let conflicts = 0;
+  let failures = 0;
+
+  for (const source of sources) {
+    failures += source.failures.length;
+    const summary = source.report?.summary;
+    if (summary === undefined) continue;
+    configFiles += summary.config.migrated ? 1 : 0;
+    mcpServers += summary.mcp.mergedServers.length;
+    userHistoryEntries += summary.userHistory.copied;
+    skills += summary.skills.copied;
+    sessions += summary.sessions.sessionsMigrated;
+    alreadyMigratedSessions += summary.sessions.sessionsAlreadyMigrated;
+    skippedItems +=
+      summary.userHistory.skippedExisting +
+      summary.skills.skippedExisting +
+      summary.sessions.sessionsSkippedPlaceholder +
+      summary.sessions.sessionsSkippedEmpty +
+      summary.sessions.sessionsSkippedMalformed;
+    conflicts +=
+      summary.config.configConflicts.length +
+      summary.mcp.keptNewForConflicts.length +
+      summary.sessions.sessionsConflicts.length;
+  }
+
+  return {
+    configFiles,
+    mcpServers,
+    userHistoryEntries,
+    skills,
+    sessions,
+    alreadyMigratedSessions,
+    skippedItems,
+    conflicts,
+    failures,
+  };
+}
+
+function aggregateManualActions(
+  sources: readonly LegacyMigrationSourceResult[],
+): readonly string[] {
+  const actions: string[] = [];
+  for (const source of sources) {
+    for (const failure of source.failures) {
+      if (failure.code === "run-failed") {
+        actions.push(
+          `Fix access to ${source.source.sourceHome} or the Kimi Code home, then run “Kimi Code: Migrate Legacy Data” again.`,
+        );
+      } else {
+        actions.push(
+          `${failure.message} Source: ${failure.item ?? source.source.sourceHome}`,
+        );
+      }
+    }
+
+    const summary = source.report?.summary;
+    if (summary === undefined) continue;
+    if (summary.config.wroteSiblingDueToConflict) {
+      actions.push("Review and merge config.migrated-from-kimi-cli.toml.");
+    }
+    if (summary.config.wroteTuiSibling) {
+      actions.push("Review and merge tui.migrated-from-kimi-cli.toml.");
+    }
+    if (summary.mcp.wroteSiblingDueToConflict) {
+      actions.push("Review and merge mcp.migrated-from-kimi-cli.json.");
+    }
+    if (summary.sessions.sessionsConflicts.length > 0) {
+      actions.push(
+        `${summary.sessions.sessionsConflicts.length} legacy session(s) conflicted with existing target sessions and were kept unchanged.`,
+      );
+    }
+  }
+  return [...new Set(actions)];
+}
+
+function mergeRunNotices(
+  detectionNotices: LegacyMigrationNotices,
+  sources: readonly LegacyMigrationSourceResult[],
+): LegacyMigrationNotices {
+  const oauth = [...detectionNotices.oauthLoginsRequiringRelogin];
+  const mcpOauth = [...detectionNotices.mcpOauthServersRequiringReauth];
+  for (const source of sources) {
+    const notices = source.report?.notices;
+    if (notices === undefined) continue;
+    oauth.push(
+      ...notices.oauthLoginsRequiringRelogin.map((name) => ({
+        sourceHome: source.source.sourceHome,
+        name,
+      })),
+    );
+    mcpOauth.push(
+      ...notices.mcpOauthServersRequiringReauth.map((name) => ({
+        sourceHome: source.source.sourceHome,
+        name,
+      })),
+    );
+  }
+  return {
+    oauthLoginsRequiringRelogin: dedupeReauthItems(oauth),
+    mcpOauthServersRequiringReauth: dedupeReauthItems(mcpOauth),
+  };
+}
+
+function dedupeReauthItems(
+  items: readonly LegacyMigrationReauthItem[],
+): readonly LegacyMigrationReauthItem[] {
+  const seen = new Set<string>();
+  return items.filter((item) => {
+    const key = `${pathKey(item.sourceHome)}\0${item.name}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function runMessage(
+  status: LegacyMigrationRunResult["status"],
+  totals: LegacyMigrationTotals,
+): string {
+  if (status === "nothing-to-migrate") return "No legacy Kimi data needs migration.";
+  if (status === "failed") {
+    return "Legacy migration failed. Fix the reported path or data error, then retry from the command palette.";
+  }
+  const migrated = `${totals.configFiles} config, ${totals.mcpServers} MCP server(s), ${totals.userHistoryEntries} history item(s), ${totals.skills} skill(s), and ${totals.sessions} session(s)`;
+  if (status === "partial") {
+    return `Legacy migration completed with ${totals.failures} failure(s): ${migrated}. Review the details and retry from the command palette.`;
+  }
+  return `Legacy migration complete: ${migrated}. Old data was kept.`;
+}
+
+function formatError(error: unknown): string {
+  if (!(error instanceof Error)) return String(error);
+  const messages: string[] = [];
+  let current: unknown = error;
+  while (current instanceof Error) {
+    messages.push(current.message || current.name);
+    current = current.cause;
+  }
+  return messages.join(": ");
+}
+
+function samePath(left: string, right: string): boolean {
+  return pathKey(left) === pathKey(right);
+}
+
+function pathKey(path: string): string {
+  if (process.platform === "win32") return win32.resolve(path).toLowerCase();
+  const windowsAbsolute = win32.isAbsolute(path);
+  return windowsAbsolute ? win32.resolve(path).toLowerCase() : resolve(path);
+}
diff --git a/apps/vscode/src/raw-modules.d.ts b/apps/vscode/src/raw-modules.d.ts
new file mode 100644
index 000000000..c65c77acd
--- /dev/null
+++ b/apps/vscode/src/raw-modules.d.ts
@@ -0,0 +1,4 @@
+declare module "*?raw" {
+  const text: string;
+  export default text;
+}
diff --git a/apps/vscode/src/runtime/event-adapter.ts b/apps/vscode/src/runtime/event-adapter.ts
new file mode 100644
index 000000000..55c2c4452
--- /dev/null
+++ b/apps/vscode/src/runtime/event-adapter.ts
@@ -0,0 +1,446 @@
+import type { Event } from '@moonshot-ai/kimi-code-sdk';
+
+import type {
+  DisplayBlock,
+  LegacyWireEvent,
+  StatusUpdate,
+  TokenUsage,
+  TurnBegin,
+} from '../../shared/legacy-sdk';
+import type { ErrorPhase, UIStreamEvent } from '../../shared/types';
+import { toLegacyDisplay } from './tool-display';
+
+const DEFAULT_MAIN_AGENT_ID = 'main';
+
+export interface AdapterTokenUsage {
+  readonly inputOther: number;
+  readonly output: number;
+  readonly inputCacheRead: number;
+  readonly inputCacheCreation: number;
+}
+
+export interface SubagentParent {
+  readonly parentAgentId: string;
+  readonly parentToolCallId: string;
+}
+
+export interface EventAdapterState {
+  readonly subagentParents: Readonly<Record<string, SubagentParent>>;
+  readonly turnUsageByAgent: Readonly<Record<string, AdapterTokenUsage>>;
+  readonly toolDisplays: Readonly<Record<string, readonly DisplayBlock[]>>;
+}
+
+export interface AdaptedToolCallPartEvent {
+  readonly type: 'ToolCallPart';
+  readonly payload: {
+    /** Lets the Webview update the right call when tool arguments interleave. */
+    readonly tool_call_id: string;
+    readonly arguments_part?: string | null;
+  };
+  readonly _sessionId?: string;
+}
+
+export type AdaptedUIStreamEvent = UIStreamEvent | AdaptedToolCallPartEvent;
+
+type SdkTurnEndedEvent = Extract<Event, { type: 'turn.ended' }>;
+
+export interface TurnTerminalMetadata {
+  /** Stable within one adapter stream and suitable for terminal-event de-duplication. */
+  readonly key: string;
+  readonly sessionId: string;
+  readonly agentId: string;
+  readonly turnId: number;
+  readonly reason: SdkTurnEndedEvent['reason'];
+  readonly error?: NonNullable<SdkTurnEndedEvent['error']>;
+}
+
+export interface EventAdapterResult {
+  readonly state: EventAdapterState;
+  readonly event?: AdaptedUIStreamEvent;
+  /** SessionRuntime owns conversion of this metadata to exactly one complete/error event. */
+  readonly terminal?: TurnTerminalMetadata;
+}
+
+export interface AdaptSdkEventOptions {
+  /** The SDK turn-start event intentionally does not repeat prompt content. */
+  readonly pendingInput?: TurnBegin['user_input'];
+  readonly mainAgentId?: string;
+  readonly errorPhase?: ErrorPhase;
+}
+
+export function createEventAdapterState(): EventAdapterState {
+  return {
+    subagentParents: {},
+    turnUsageByAgent: {},
+    toolDisplays: {},
+  };
+}
+
+/**
+ * Purely projects one public Node SDK event into the released Webview protocol.
+ * The returned state must be passed into the next call; the input state is never mutated.
+ */
+export function adaptSdkEvent(
+  state: EventAdapterState,
+  sdkEvent: Event,
+  options: AdaptSdkEventOptions = {},
+): EventAdapterResult {
+  const mainAgentId = options.mainAgentId ?? DEFAULT_MAIN_AGENT_ID;
+
+  if (sdkEvent.type === 'subagent.spawned') {
+    const parentAgentId = sdkEvent.parentAgentId ?? sdkEvent.callerAgentId ?? sdkEvent.agentId;
+    return {
+      state: {
+        ...state,
+        subagentParents: {
+          ...state.subagentParents,
+          [sdkEvent.subagentId]: {
+            parentAgentId,
+            parentToolCallId: scopedToolCallId(
+              parentAgentId,
+              sdkEvent.parentToolCallId,
+              mainAgentId,
+            ),
+          },
+        },
+      },
+    };
+  }
+
+  if (sdkEvent.type === 'turn.started') {
+    const nextState = resetTurnUsage(state, sdkEvent.agentId);
+    if (sdkEvent.agentId !== mainAgentId || options.pendingInput === undefined) {
+      return { state: nextState };
+    }
+    return {
+      state: nextState,
+      event: withSessionId(
+        {
+          type: 'TurnBegin',
+          payload: { user_input: options.pendingInput },
+        },
+        sdkEvent.sessionId,
+      ),
+    };
+  }
+
+  if (sdkEvent.type === 'turn.ended') {
+    if (sdkEvent.agentId !== mainAgentId) return { state };
+    return {
+      state,
+      terminal: {
+        key: `${sdkEvent.sessionId}:${sdkEvent.agentId}:${sdkEvent.turnId}`,
+        sessionId: sdkEvent.sessionId,
+        agentId: sdkEvent.agentId,
+        turnId: sdkEvent.turnId,
+        reason: sdkEvent.reason,
+        error: sdkEvent.error,
+      },
+    };
+  }
+
+  if (sdkEvent.type === 'error') {
+    if (sdkEvent.agentId !== mainAgentId) return { state };
+    return {
+      state,
+      event: {
+        type: 'error',
+        code: sdkEvent.code,
+        message: sdkEvent.message,
+        detail: serializeDetails(sdkEvent.details),
+        phase: options.errorPhase ?? 'runtime',
+        _sessionId: sdkEvent.sessionId,
+      },
+    };
+  }
+
+  const mapped = mapLegacyWireEvent(state, sdkEvent, mainAgentId);
+  if (mapped.event === undefined) return { state: mapped.state };
+
+  const routed = routeSubagentEvent(
+    mapped.state,
+    sdkEvent.agentId,
+    mapped.event,
+    mainAgentId,
+  );
+  if (routed === undefined) return { state: mapped.state };
+
+  return {
+    state: mapped.state,
+    event: withSessionId(routed, sdkEvent.sessionId),
+  };
+}
+
+export function toLegacyToolName(name: string): string {
+  switch (name) {
+    case 'Bash':
+      return 'Shell';
+    case 'Read':
+      return 'ReadFile';
+    case 'Write':
+      return 'WriteFile';
+    case 'Edit':
+      return 'StrReplaceFile';
+    case 'TodoList':
+      return 'SetTodoList';
+    default:
+      return name;
+  }
+}
+
+interface MappedLegacyWireEvent {
+  readonly state: EventAdapterState;
+  readonly event?: LegacyWireEvent;
+}
+
+function mapLegacyWireEvent(
+  state: EventAdapterState,
+  sdkEvent: Event,
+  mainAgentId: string,
+): MappedLegacyWireEvent {
+  switch (sdkEvent.type) {
+    case 'turn.step.started':
+      return {
+        state,
+        event: { type: 'StepBegin', payload: { n: sdkEvent.step } },
+      };
+    case 'turn.step.retrying':
+      return {
+        state,
+        event: {
+          type: 'StatusUpdate',
+          payload: {
+            retrying: {
+              next_attempt: sdkEvent.nextAttempt,
+              max_attempts: sdkEvent.maxAttempts,
+              delay_ms: sdkEvent.delayMs,
+              message: sdkEvent.errorMessage,
+            },
+          },
+        },
+      };
+    case 'turn.step.interrupted':
+      return {
+        state,
+        event: { type: 'StepInterrupted', payload: {} },
+      };
+    case 'assistant.delta':
+      return {
+        state,
+        event: { type: 'ContentPart', payload: { type: 'text', text: sdkEvent.delta } },
+      };
+    case 'hook.result':
+      return {
+        state,
+        event: { type: 'ContentPart', payload: { type: 'text', text: sdkEvent.content } },
+      };
+    case 'thinking.delta':
+      return {
+        state,
+        event: { type: 'ContentPart', payload: { type: 'think', think: sdkEvent.delta } },
+      };
+    case 'tool.call.started': {
+      const toolCallId = scopedToolCallId(
+        sdkEvent.agentId,
+        sdkEvent.toolCallId,
+        mainAgentId,
+      );
+      const display = sdkEvent.display === undefined ? undefined : toLegacyDisplay(sdkEvent.display);
+      return {
+        state: display === undefined
+          ? state
+          : {
+              ...state,
+              toolDisplays: { ...state.toolDisplays, [toolCallId]: display },
+            },
+        event: {
+          type: 'ToolCall',
+          payload: {
+            type: 'function',
+            id: toolCallId,
+            function: {
+              name: toLegacyToolName(sdkEvent.name),
+              arguments: serializeArguments(sdkEvent.args),
+            },
+          },
+        },
+      };
+    }
+    case 'tool.call.delta': {
+      const event: AdaptedToolCallPartEvent = {
+        type: 'ToolCallPart',
+        payload: {
+          tool_call_id: scopedToolCallId(
+            sdkEvent.agentId,
+            sdkEvent.toolCallId,
+            mainAgentId,
+          ),
+          arguments_part: sdkEvent.argumentsPart,
+        },
+      };
+      return { state, event: event as LegacyWireEvent };
+    }
+    case 'tool.result': {
+      const toolCallId = scopedToolCallId(
+        sdkEvent.agentId,
+        sdkEvent.toolCallId,
+        mainAgentId,
+      );
+      const display = state.toolDisplays[toolCallId] ?? [];
+      const toolDisplays = { ...state.toolDisplays };
+      delete toolDisplays[toolCallId];
+      const output = serializeToolOutput(sdkEvent.output);
+      return {
+        state: { ...state, toolDisplays },
+        event: {
+          type: 'ToolResult',
+          payload: {
+            tool_call_id: toolCallId,
+            return_value: {
+              is_error: sdkEvent.isError === true,
+              output,
+              message: '',
+              display: [...display],
+            },
+          },
+        },
+      };
+    }
+    case 'agent.status.updated':
+      return mapStatusUpdate(state, sdkEvent);
+    case 'compaction.started':
+      return {
+        state,
+        event: { type: 'CompactionBegin', payload: {} },
+      };
+    case 'compaction.blocked':
+    case 'compaction.cancelled':
+    case 'compaction.completed':
+      return {
+        state,
+        event: { type: 'CompactionEnd', payload: {} },
+      };
+    default:
+      return { state };
+  }
+}
+
+function mapStatusUpdate(
+  state: EventAdapterState,
+  sdkEvent: Extract<Event, { type: 'agent.status.updated' }>,
+): MappedLegacyWireEvent {
+  const payload: StatusUpdate = {};
+  if (sdkEvent.contextUsage !== undefined) payload.context_usage = sdkEvent.contextUsage;
+  if (sdkEvent.planMode !== undefined) payload.plan_mode = sdkEvent.planMode;
+  if (sdkEvent.model !== undefined) payload.model = sdkEvent.model;
+  if (sdkEvent.thinkingEffort !== undefined) payload.thinking_effort = sdkEvent.thinkingEffort;
+
+  const currentTurn = sdkEvent.usage?.currentTurn;
+  if (currentTurn === undefined) {
+    return Object.keys(payload).length === 0
+      ? { state }
+      : { state, event: { type: 'StatusUpdate', payload } };
+  }
+
+  const previous = state.turnUsageByAgent[sdkEvent.agentId];
+  payload.token_usage = usageDelta(currentTurn, previous);
+  return {
+    state: {
+      ...state,
+      turnUsageByAgent: {
+        ...state.turnUsageByAgent,
+        [sdkEvent.agentId]: currentTurn,
+      },
+    },
+    event: { type: 'StatusUpdate', payload },
+  };
+}
+
+function usageDelta(current: AdapterTokenUsage, previous: AdapterTokenUsage | undefined): TokenUsage {
+  return {
+    input_other: delta(current.inputOther, previous?.inputOther),
+    output: delta(current.output, previous?.output),
+    input_cache_read: delta(current.inputCacheRead, previous?.inputCacheRead),
+    input_cache_creation: delta(
+      current.inputCacheCreation,
+      previous?.inputCacheCreation,
+    ),
+  };
+}
+
+function delta(current: number, previous: number | undefined): number {
+  if (previous === undefined || current < previous) return current;
+  return current - previous;
+}
+
+function resetTurnUsage(state: EventAdapterState, agentId: string): EventAdapterState {
+  if (state.turnUsageByAgent[agentId] === undefined) return state;
+  const nextUsage = { ...state.turnUsageByAgent };
+  delete nextUsage[agentId];
+  return { ...state, turnUsageByAgent: nextUsage };
+}
+
+function routeSubagentEvent(
+  state: EventAdapterState,
+  agentId: string,
+  event: LegacyWireEvent,
+  mainAgentId: string,
+): LegacyWireEvent | undefined {
+  if (agentId === mainAgentId) return event;
+
+  let currentAgentId = agentId;
+  let routed = event;
+  const visited = new Set<string>();
+
+  while (currentAgentId !== mainAgentId) {
+    if (visited.has(currentAgentId)) return undefined;
+    visited.add(currentAgentId);
+
+    const parent = state.subagentParents[currentAgentId];
+    if (parent === undefined) return undefined;
+    routed = {
+      type: 'SubagentEvent',
+      payload: {
+        parent_tool_call_id: parent.parentToolCallId,
+        event: routed,
+      },
+    };
+    currentAgentId = parent.parentAgentId;
+  }
+
+  return routed;
+}
+
+function scopedToolCallId(agentId: string, toolCallId: string, mainAgentId: string): string {
+  return agentId === mainAgentId ? toolCallId : `${agentId}:${toolCallId}`;
+}
+
+function withSessionId(event: LegacyWireEvent, sessionId: string): AdaptedUIStreamEvent {
+  return { ...event, _sessionId: sessionId } as AdaptedUIStreamEvent;
+}
+
+function serializeArguments(args: unknown): string {
+  try {
+    return JSON.stringify(args) ?? '{}';
+  } catch {
+    return '{}';
+  }
+}
+
+function serializeToolOutput(output: unknown): string {
+  if (typeof output === 'string') return output;
+  try {
+    return JSON.stringify(output, null, 2) ?? '';
+  } catch {
+    return String(output);
+  }
+}
+
+function serializeDetails(details: Record<string, unknown> | undefined): string | undefined {
+  if (details === undefined) return undefined;
+  try {
+    return JSON.stringify(details, null, 2);
+  } catch {
+    return "[Unable to serialize error details]";
+  }
+}
diff --git a/apps/vscode/src/runtime/kimi-runtime.ts b/apps/vscode/src/runtime/kimi-runtime.ts
new file mode 100644
index 000000000..9da8e9754
--- /dev/null
+++ b/apps/vscode/src/runtime/kimi-runtime.ts
@@ -0,0 +1,285 @@
+import {
+  createKimiHarness,
+  type KimiHarness,
+  type Session,
+  type SessionSummary,
+  type ThinkingEffort,
+} from "@moonshot-ai/kimi-code-sdk";
+
+import type { RuntimeBroadcast } from "./session-runtime";
+import {
+  corePermissionForLegacyApproval,
+  legacyApprovalMetadata,
+  readLegacyApprovalFlags,
+  readMigratedLegacyApprovalFlags,
+  withGlobalYoloMode,
+  type LegacyApprovalFlags,
+} from "./legacy-approval";
+import { SessionRuntime } from "./session-runtime";
+import { areSameFsPath } from "../utils/fs-path";
+
+export interface KimiRuntimeOptions {
+  readonly version: string;
+  readonly broadcast: RuntimeBroadcast;
+  readonly captureBaseline: (
+    session: Pick<SessionSummary, "id" | "workDir" | "metadata">,
+    filePath: string,
+    webviewIds: readonly string[],
+  ) => void;
+  readonly log: (message: string, error?: unknown) => void;
+  readonly homeDir?: string;
+  readonly harness?: KimiHarness;
+}
+
+export interface OpenSessionOptions {
+  readonly webviewId: string;
+  readonly workDir: string;
+  readonly sessionId?: string;
+  readonly model: string;
+  readonly effort: string;
+  readonly yoloMode: boolean;
+}
+
+/** Extension-host owner for one in-process Node SDK harness. */
+export class KimiRuntime {
+  readonly harness: KimiHarness;
+
+  private readonly broadcast: RuntimeBroadcast;
+  private readonly captureBaseline: KimiRuntimeOptions["captureBaseline"];
+  private readonly log: KimiRuntimeOptions["log"];
+  private readonly sessions = new Map<string, SessionRuntime>();
+  private readonly sessionByView = new Map<string, string>();
+  private closed = false;
+
+  constructor(options: KimiRuntimeOptions) {
+    this.broadcast = options.broadcast;
+    this.captureBaseline = options.captureBaseline;
+    this.log = options.log;
+    this.harness =
+      options.harness ??
+      createKimiHarness({
+        ...(options.homeDir === undefined ? {} : { homeDir: options.homeDir }),
+        identity: {
+          userAgentProduct: "kimi-code-vscode",
+          version: options.version,
+        },
+        uiMode: "vscode",
+      });
+  }
+
+  getSessionForView(webviewId: string): SessionRuntime | undefined {
+    const id = this.sessionByView.get(webviewId);
+    return id === undefined ? undefined : this.sessions.get(id);
+  }
+
+  getSession(id: string): SessionRuntime | undefined {
+    return this.sessions.get(id);
+  }
+
+  async openSession(options: OpenSessionOptions): Promise<SessionRuntime> {
+    this.ensureOpen();
+    const current = this.getSessionForView(options.webviewId);
+    const requestedId = options.sessionId ?? current?.id;
+
+    if (
+      current !== undefined &&
+      requestedId === current.id &&
+      areSameFsPath(current.session.workDir, options.workDir)
+    ) {
+      await applySessionSettings(current.session, options, current.legacyApprovalFlags);
+      await current.announceStatus(options.webviewId);
+      return current;
+    }
+
+    let runtime = requestedId === undefined ? undefined : this.sessions.get(requestedId);
+    if (runtime !== undefined) {
+      assertSessionWorkDir(runtime.session, options.workDir);
+      await applySessionSettings(runtime.session, options, runtime.legacyApprovalFlags);
+      await this.detachView(options.webviewId);
+    } else {
+      const defaultApproval: LegacyApprovalFlags = { yolo: options.yoloMode, afk: false };
+      const session =
+        requestedId === undefined
+          ? await this.harness.createSession({
+              workDir: options.workDir,
+              model: options.model || undefined,
+              thinking: normalizeEffort(options.effort),
+              permission: corePermissionForLegacyApproval(defaultApproval),
+              metadata: legacyApprovalMetadata(defaultApproval),
+            })
+          : await this.harness.resumeSession({ id: requestedId, includeSubagents: true });
+      try {
+        assertSessionWorkDir(session, options.workDir);
+        const storedApproval = readLegacyApprovalFlags(session.summary?.metadata);
+        const restoredApproval =
+          storedApproval ?? (await this.readMigratedLegacyApproval(session)) ?? defaultApproval;
+        const approval = withGlobalYoloMode(restoredApproval, options.yoloMode);
+        if (storedApproval === undefined || flagsDiffer(storedApproval, approval)) {
+          await session.updateMetadata(legacyApprovalMetadata(approval));
+        }
+        await applySessionSettings(session, options, approval);
+        await this.detachView(options.webviewId);
+        runtime = this.wrapSession(session, approval);
+      } catch (error) {
+        await session.close().catch((closeError: unknown) => {
+          this.log("Failed to close a rejected session", closeError);
+        });
+        throw error;
+      }
+    }
+
+    runtime.subscribe(options.webviewId);
+    this.sessionByView.set(options.webviewId, runtime.id);
+    await runtime.announceStatus(options.webviewId);
+    return runtime;
+  }
+
+  async attachResumedSession(
+    webviewId: string,
+    session: Session,
+    defaultYoloMode = false,
+  ): Promise<SessionRuntime> {
+    const existing = this.sessions.get(session.id);
+    if (existing !== undefined && this.sessionByView.get(webviewId) === session.id) {
+      existing.subscribe(webviewId);
+      await existing.announceStatus(webviewId);
+      return existing;
+    }
+    await this.detachView(webviewId);
+    let runtime = existing ?? this.sessions.get(session.id);
+    if (runtime === undefined) {
+      try {
+        const storedApproval = readLegacyApprovalFlags(session.summary?.metadata);
+        const restoredApproval =
+          storedApproval ??
+          (await this.readMigratedLegacyApproval(session)) ??
+          { yolo: defaultYoloMode, afk: false };
+        const approval = withGlobalYoloMode(restoredApproval, defaultYoloMode);
+        if (storedApproval === undefined || flagsDiffer(storedApproval, approval)) {
+          await session.updateMetadata(legacyApprovalMetadata(approval));
+        }
+        const status = await session.getStatus();
+        const permission = corePermissionForLegacyApproval(approval);
+        if (status.permission !== permission) await session.setPermission(permission);
+        runtime = this.wrapSession(session, approval);
+      } catch (error) {
+        await session.close().catch((closeError: unknown) => {
+          this.log("Failed to close a rejected session", closeError);
+        });
+        throw error;
+      }
+    }
+    runtime.subscribe(webviewId);
+    this.sessionByView.set(webviewId, runtime.id);
+    await runtime.announceStatus(webviewId);
+    return runtime;
+  }
+
+  async detachView(webviewId: string): Promise<void> {
+    const id = this.sessionByView.get(webviewId);
+    if (id === undefined) return;
+    this.sessionByView.delete(webviewId);
+    const runtime = this.sessions.get(id);
+    if (runtime === undefined) return;
+    runtime.unsubscribeView(webviewId);
+    if (runtime.subscribers.length === 0) {
+      this.sessions.delete(id);
+      await runtime.close();
+    }
+  }
+
+  async closeSession(id: string): Promise<void> {
+    const runtime = this.sessions.get(id);
+    if (runtime === undefined) {
+      await this.harness.closeSession(id);
+      return;
+    }
+    this.sessions.delete(id);
+    for (const webviewId of runtime.subscribers) {
+      this.sessionByView.delete(webviewId);
+    }
+    await runtime.close();
+  }
+
+  async deleteSession(id: string): Promise<void> {
+    await this.closeSession(id);
+    await this.harness.deleteSession(id);
+  }
+
+  async setYoloModeForActiveSessions(enabled: boolean): Promise<void> {
+    await Promise.all(
+      [...this.sessions.values()].map((session) => session.setLegacyYoloMode(enabled)),
+    );
+  }
+
+  async dispose(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    await Promise.all([...this.sessions.values()].map((session) => session.close()));
+    this.sessions.clear();
+    this.sessionByView.clear();
+    await this.harness.close();
+  }
+
+  private wrapSession(session: Session, legacyApproval: LegacyApprovalFlags): SessionRuntime {
+    const runtime = new SessionRuntime({
+      session,
+      legacyApproval,
+      broadcast: this.broadcast,
+      captureBaseline: this.captureBaseline,
+      log: this.log,
+    });
+    this.sessions.set(session.id, runtime);
+    return runtime;
+  }
+
+  private async readMigratedLegacyApproval(
+    session: Session,
+  ): Promise<LegacyApprovalFlags | undefined> {
+    const metadata = session.summary?.metadata;
+    try {
+      return await readMigratedLegacyApprovalFlags(metadata);
+    } catch (error) {
+      this.log("Unable to restore legacy session approval settings", error);
+      return undefined;
+    }
+  }
+
+  private ensureOpen(): void {
+    if (this.closed) throw new Error("Kimi runtime is closed.");
+  }
+}
+
+async function applySessionSettings(
+  session: Session,
+  options: OpenSessionOptions,
+  legacyApproval: LegacyApprovalFlags,
+): Promise<void> {
+  const status = await session.getStatus();
+  if (options.model && status.model !== options.model) {
+    await session.setModel(options.model);
+  }
+  // Thinking effort is applied only when the session is created (see
+  // openSession). An existing session keeps its own effort — the global
+  // config value is a default for new sessions, matching CLI/TUI resume
+  // semantics. Effort changes made in the picker reach the active session
+  // through the SaveConfig handler instead.
+  const permission = corePermissionForLegacyApproval(legacyApproval);
+  if (status.permission !== permission) {
+    await session.setPermission(permission);
+  }
+}
+
+function normalizeEffort(effort: string): ThinkingEffort {
+  return (effort.trim() || "off") as ThinkingEffort;
+}
+
+function flagsDiffer(a: LegacyApprovalFlags, b: LegacyApprovalFlags): boolean {
+  return a.yolo !== b.yolo || a.afk !== b.afk;
+}
+
+function assertSessionWorkDir(session: Pick<Session, "workDir">, expectedWorkDir: string): void {
+  if (!areSameFsPath(session.workDir, expectedWorkDir)) {
+    throw new Error("The selected session belongs to a different working directory.");
+  }
+}
diff --git a/apps/vscode/src/runtime/legacy-approval.ts b/apps/vscode/src/runtime/legacy-approval.ts
new file mode 100644
index 000000000..82bf8f178
--- /dev/null
+++ b/apps/vscode/src/runtime/legacy-approval.ts
@@ -0,0 +1,71 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import type { JsonObject, PermissionMode } from "@moonshot-ai/kimi-code-sdk";
+
+export const LEGACY_APPROVAL_METADATA_KEY = "vscode_legacy_approval";
+
+export interface LegacyApprovalFlags {
+  readonly yolo: boolean;
+  readonly afk: boolean;
+}
+
+export function readLegacyApprovalFlags(
+  metadata: Readonly<Record<string, unknown>> | undefined,
+): LegacyApprovalFlags | undefined {
+  const value = metadata?.[LEGACY_APPROVAL_METADATA_KEY];
+  return parseLegacyApprovalFlags(value);
+}
+
+export async function readMigratedLegacyApprovalFlags(
+  metadata: Readonly<Record<string, unknown>> | undefined,
+): Promise<LegacyApprovalFlags | undefined> {
+  const sourcePath = metadata?.["kimi_cli_source_path"];
+  if (typeof sourcePath !== "string" || sourcePath.length === 0) return undefined;
+  let text: string;
+  try {
+    text = await readFile(join(sourcePath, "state.json"), "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+  const state = JSON.parse(text) as { readonly approval?: unknown };
+  return parseLegacyApprovalFlags(state.approval);
+}
+
+function parseLegacyApprovalFlags(value: unknown): LegacyApprovalFlags | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const yolo = Reflect.get(value, "yolo");
+  const afk = Reflect.get(value, "afk");
+  if (typeof yolo !== "boolean" && typeof afk !== "boolean") return undefined;
+  return {
+    yolo: typeof yolo === "boolean" ? yolo : false,
+    afk: typeof afk === "boolean" ? afk : false,
+  };
+}
+
+export function legacyApprovalMetadata(flags: LegacyApprovalFlags): JsonObject {
+  return {
+    [LEGACY_APPROVAL_METADATA_KEY]: {
+      yolo: flags.yolo,
+      afk: flags.afk,
+    },
+  };
+}
+
+export function corePermissionForLegacyApproval(flags: LegacyApprovalFlags): PermissionMode {
+  if (flags.afk) return "auto";
+  return flags.yolo ? "yolo" : "manual";
+}
+
+/**
+ * The global `kimi.yoloMode` setting is authoritative whenever a session
+ * attaches to the runtime; afk stays per-session because it has no global
+ * setting counterpart.
+ */
+export function withGlobalYoloMode(
+  flags: LegacyApprovalFlags,
+  yoloMode: boolean,
+): LegacyApprovalFlags {
+  return flags.yolo === yoloMode ? flags : { yolo: yoloMode, afk: flags.afk };
+}
diff --git a/apps/vscode/src/runtime/replay-adapter.ts b/apps/vscode/src/runtime/replay-adapter.ts
new file mode 100644
index 000000000..facd978ac
--- /dev/null
+++ b/apps/vscode/src/runtime/replay-adapter.ts
@@ -0,0 +1,594 @@
+import type {
+  AgentReplayRecord,
+  ContentPart,
+  PromptOrigin,
+  ResumedAgentState,
+  ResumedSessionState,
+} from "@moonshot-ai/kimi-code-sdk";
+
+import type {
+  ContentPart as LegacyContentPart,
+  DisplayBlock,
+  LegacyWireEvent,
+  RunResult,
+  TokenUsage,
+  ToolCall,
+} from "../../shared/legacy-sdk";
+import type { UIStreamEvent } from "../../shared/types";
+import { toLegacyToolName } from "./event-adapter";
+import { toLegacyDisplay } from "./tool-display";
+
+interface SubagentReplayInvocation {
+  readonly parentAgentId: string;
+  readonly parentToolCallId: string;
+  readonly childAgentId: string;
+  readonly startedAt: number;
+  readonly order: number;
+  records: readonly AgentReplayRecord[];
+}
+
+interface SubagentReplayIndex {
+  readonly byParentCall: ReadonlyMap<string, readonly SubagentReplayInvocation[]>;
+}
+
+/** Projects a complete resumed SDK session, including persisted subagent steps. */
+export function replaySessionToWebviewEvents(
+  state: ResumedSessionState,
+  sessionId: string,
+): UIStreamEvent[] {
+  const main = state.agents["main"];
+  if (main === undefined) throw new Error("Session history is unavailable.");
+  return replayAgentToWebviewEvents(main, sessionId, buildSubagentReplayIndex(state));
+}
+
+/** Projects the public SDK resume replay into the released Webview protocol. */
+export function replayToWebviewEvents(
+  agent: ResumedAgentState,
+  sessionId: string,
+): UIStreamEvent[] {
+  return replayAgentToWebviewEvents(agent, sessionId);
+}
+
+function replayAgentToWebviewEvents(
+  agent: ResumedAgentState,
+  sessionId: string,
+  subagents?: SubagentReplayIndex,
+): UIStreamEvent[] {
+  const events: UIStreamEvent[] = [];
+  let turnOpen = false;
+  let step = 0;
+  const toolDisplays = new Map<string, readonly DisplayBlock[]>();
+
+  events.push(
+    withSession(
+      {
+        type: "StatusUpdate",
+        payload: {
+          ...(agent.config.modelAlias === undefined ? {} : { model: agent.config.modelAlias }),
+          thinking_effort: agent.config.thinkingEffort,
+          plan_mode: agent.plan !== null,
+        },
+      },
+      sessionId,
+    ),
+  );
+
+  const completeTurn = () => {
+    if (!turnOpen) return;
+    const result: RunResult = { status: "finished" };
+    events.push({ type: "stream_complete", result, _sessionId: sessionId });
+    turnOpen = false;
+  };
+
+  const ensureStep = () => {
+    if (!turnOpen) return;
+    if (step === 0) {
+      step = 1;
+      events.push(withSession({ type: "StepBegin", payload: { n: step } }, sessionId));
+    }
+  };
+
+  for (const record of agent.replay) {
+    switch (record.type) {
+      case "message": {
+        const message = record.message;
+        if (message.role === "user") {
+          if (!isVisibleUserMessage(message.origin)) break;
+          const imported = importedContextReplay(message.content);
+          completeTurn();
+          step = 0;
+          turnOpen = true;
+          events.push(
+            withSession(
+              {
+                type: "TurnBegin",
+                payload: {
+                  user_input: imported?.input ?? replayUserInput(message.content, message.origin),
+                },
+              },
+              sessionId,
+            ),
+          );
+          if (imported !== undefined) {
+            ensureStep();
+            events.push(
+              withSession(
+                { type: "ContentPart", payload: { type: "text", text: imported.confirmation } },
+                sessionId,
+              ),
+            );
+          }
+          break;
+        }
+
+        if (message.role === "assistant") {
+          if (!turnOpen) break;
+          ensureStep();
+          for (const part of toLegacyContent(message.content)) {
+            events.push(withSession({ type: "ContentPart", payload: part }, sessionId));
+          }
+          for (const call of message.toolCalls) {
+            const display = message.toolCallDisplays?.[call.id];
+            if (display !== undefined) {
+              toolDisplays.set(call.id, toLegacyDisplay(display));
+            }
+            const toolCall: ToolCall = {
+              type: "function",
+              id: call.id,
+              function: {
+                name: toLegacyToolName(call.name),
+                arguments: call.arguments,
+              },
+            };
+            events.push(withSession({ type: "ToolCall", payload: toolCall }, sessionId));
+            if (subagents !== undefined) {
+              for (const nested of renderSubagentInvocations(
+                subagents,
+                "main",
+                call.id,
+                [],
+                new Set(),
+              )) {
+                events.push(withSession(nested, sessionId));
+              }
+            }
+          }
+          break;
+        }
+
+        if (message.role === "tool" && turnOpen && message.toolCallId !== undefined) {
+          ensureStep();
+          const display = toolDisplays.get(message.toolCallId) ?? [];
+          toolDisplays.delete(message.toolCallId);
+          events.push(
+            withSession(
+              {
+                type: "ToolResult",
+                payload: {
+                  tool_call_id: message.toolCallId,
+                  return_value: {
+                    is_error: message.isError === true,
+                    output: toLegacyContent(message.content),
+                    message: "",
+                    display: [...display],
+                  },
+                },
+              },
+              sessionId,
+            ),
+          );
+        }
+        break;
+      }
+      case "compaction":
+        if (!turnOpen) break;
+        ensureStep();
+        events.push(withSession({ type: "CompactionBegin", payload: {} }, sessionId));
+        if (record.result !== undefined) {
+          events.push(withSession({ type: "CompactionEnd", payload: {} }, sessionId));
+        }
+        break;
+      case "plan_updated":
+        if (turnOpen) {
+          ensureStep();
+          events.push(
+            withSession(
+              { type: "StatusUpdate", payload: { plan_mode: record.enabled } },
+              sessionId,
+            ),
+          );
+        }
+        break;
+      case "config_updated":
+      case "permission_updated":
+      case "approval_result":
+      case "goal_updated":
+        break;
+    }
+  }
+
+  completeTurn();
+  const resumedStatus = resumedStatusPayload(agent);
+  if (Object.keys(resumedStatus).length > 0) {
+    events.push(withSession({ type: "StatusUpdate", payload: resumedStatus }, sessionId));
+  }
+  return events;
+}
+
+function buildSubagentReplayIndex(state: ResumedSessionState): SubagentReplayIndex {
+  const invocations: SubagentReplayInvocation[] = [];
+  let order = 0;
+
+  for (const [parentAgentId, parent] of Object.entries(state.agents)) {
+    const calls = new Map<
+      string,
+      { readonly name: string; readonly startedAt: number; readonly order: number }
+    >();
+    for (const record of parent.replay) {
+      if (record.type !== "message") continue;
+      const { message } = record;
+      if (message.role === "assistant") {
+        for (const call of message.toolCalls) {
+          calls.set(call.id, { name: call.name, startedAt: record.time, order: order++ });
+        }
+        continue;
+      }
+      if (message.role !== "tool" || message.toolCallId === undefined) continue;
+      const call = calls.get(message.toolCallId);
+      if (call === undefined || (call.name !== "Agent" && call.name !== "AgentSwarm")) continue;
+      for (const childAgentId of subagentIdsFromResult(call.name, message.content)) {
+        const metadata = state.sessionMetadata.agents[childAgentId];
+        if (metadata?.parentAgentId !== parentAgentId || state.agents[childAgentId] === undefined) {
+          continue;
+        }
+        invocations.push({
+          parentAgentId,
+          parentToolCallId: message.toolCallId,
+          childAgentId,
+          startedAt: call.startedAt,
+          order: call.order,
+          records: [],
+        });
+      }
+    }
+  }
+
+  const byChild = new Map<string, SubagentReplayInvocation[]>();
+  for (const invocation of invocations) {
+    const entries = byChild.get(invocation.childAgentId) ?? [];
+    entries.push(invocation);
+    byChild.set(invocation.childAgentId, entries);
+  }
+  for (const [childAgentId, entries] of byChild) {
+    entries.sort(compareInvocation);
+    const replay = state.agents[childAgentId]?.replay ?? [];
+    for (const [index, invocation] of entries.entries()) {
+      const next = entries[index + 1];
+      invocation.records = replay.filter(
+        (record) =>
+          record.time >= invocation.startedAt &&
+          (next === undefined || record.time < next.startedAt),
+      );
+    }
+  }
+
+  const byParentCall = new Map<string, SubagentReplayInvocation[]>();
+  for (const invocation of invocations) {
+    const key = parentCallKey(invocation.parentAgentId, invocation.parentToolCallId);
+    const entries = byParentCall.get(key) ?? [];
+    entries.push(invocation);
+    byParentCall.set(key, entries);
+  }
+  for (const entries of byParentCall.values()) entries.sort(compareInvocation);
+  return { byParentCall };
+}
+
+function compareInvocation(a: SubagentReplayInvocation, b: SubagentReplayInvocation): number {
+  return a.startedAt - b.startedAt || a.order - b.order;
+}
+
+function subagentIdsFromResult(
+  toolName: "Agent" | "AgentSwarm",
+  content: readonly ContentPart[],
+): readonly string[] {
+  const text = content
+    .filter((part): part is Extract<ContentPart, { type: "text" }> => part.type === "text")
+    .map((part) => part.text)
+    .join("");
+  if (toolName === "Agent") {
+    const header = text.split("\n\n", 1)[0] ?? text;
+    const match = /(?:^|\n)agent_id:\s*([^\s]+)\s*(?=\n|$)/.exec(header);
+    return match === null ? [] : [match[1]!];
+  }
+  const pattern = /<subagent\b[^>]*\bagent_id="([^"]+)"[^>]*\boutcome="[^"]+">/g;
+  return [...text.matchAll(pattern)].map((match) => match[1]!).filter(uniqueString);
+}
+
+function uniqueString(value: string, index: number, values: readonly string[]): boolean {
+  return values.indexOf(value) === index;
+}
+
+function renderSubagentInvocations(
+  index: SubagentReplayIndex,
+  parentAgentId: string,
+  parentToolCallId: string,
+  parentChain: readonly SubagentReplayInvocation[],
+  visited: ReadonlySet<string>,
+): LegacyWireEvent[] {
+  const result: LegacyWireEvent[] = [];
+  const invocations = index.byParentCall.get(parentCallKey(parentAgentId, parentToolCallId)) ?? [];
+  for (const invocation of invocations) {
+    const invocationKey = `${invocation.parentAgentId}\u0000${invocation.parentToolCallId}\u0000${invocation.childAgentId}\u0000${String(invocation.startedAt)}`;
+    if (visited.has(invocationKey)) continue;
+    const nextVisited = new Set([...visited, invocationKey]);
+    result.push(
+      ...renderSubagentInvocation(index, invocation, [invocation, ...parentChain], nextVisited),
+    );
+  }
+  return result;
+}
+
+function renderSubagentInvocation(
+  index: SubagentReplayIndex,
+  invocation: SubagentReplayInvocation,
+  chain: readonly SubagentReplayInvocation[],
+  visited: ReadonlySet<string>,
+): LegacyWireEvent[] {
+  const events: LegacyWireEvent[] = [];
+  const toolDisplays = new Map<string, readonly DisplayBlock[]>();
+  let step = 0;
+
+  const emit = (event: LegacyWireEvent) => {
+    events.push(wrapSubagentEvent(event, chain));
+  };
+
+  for (const record of invocation.records) {
+    switch (record.type) {
+      case "message": {
+        const { message } = record;
+        if (message.role === "user") {
+          step = 0;
+          break;
+        }
+        if (message.role === "assistant") {
+          step += 1;
+          emit({ type: "StepBegin", payload: { n: step } });
+          for (const part of toLegacyContent(message.content)) {
+            emit({ type: "ContentPart", payload: part });
+          }
+          for (const call of message.toolCalls) {
+            const toolCallId = scopedReplayToolCallId(invocation.childAgentId, call.id);
+            const display = message.toolCallDisplays?.[call.id];
+            if (display !== undefined) toolDisplays.set(toolCallId, toLegacyDisplay(display));
+            emit({
+              type: "ToolCall",
+              payload: {
+                type: "function",
+                id: toolCallId,
+                function: {
+                  name: toLegacyToolName(call.name),
+                  arguments: call.arguments,
+                },
+              },
+            });
+            events.push(
+              ...renderSubagentInvocations(
+                index,
+                invocation.childAgentId,
+                call.id,
+                chain,
+                visited,
+              ),
+            );
+          }
+          break;
+        }
+        if (message.role === "tool" && message.toolCallId !== undefined) {
+          const toolCallId = scopedReplayToolCallId(
+            invocation.childAgentId,
+            message.toolCallId,
+          );
+          const display = toolDisplays.get(toolCallId) ?? [];
+          toolDisplays.delete(toolCallId);
+          emit({
+            type: "ToolResult",
+            payload: {
+              tool_call_id: toolCallId,
+              return_value: {
+                is_error: message.isError === true,
+                output: toLegacyContent(message.content),
+                message: "",
+                display: [...display],
+              },
+            },
+          });
+        }
+        break;
+      }
+      case "compaction":
+        emit({ type: "CompactionBegin", payload: {} });
+        if (record.result !== undefined) emit({ type: "CompactionEnd", payload: {} });
+        break;
+      case "plan_updated":
+        emit({ type: "StatusUpdate", payload: { plan_mode: record.enabled } });
+        break;
+      case "config_updated":
+      case "permission_updated":
+      case "approval_result":
+      case "goal_updated":
+        break;
+    }
+  }
+  return events;
+}
+
+function wrapSubagentEvent(
+  event: LegacyWireEvent,
+  chain: readonly SubagentReplayInvocation[],
+): LegacyWireEvent {
+  let routed = event;
+  for (const invocation of chain) {
+    routed = {
+      type: "SubagentEvent",
+      payload: {
+        parent_tool_call_id: scopedReplayToolCallId(
+          invocation.parentAgentId,
+          invocation.parentToolCallId,
+        ),
+        event: routed,
+      },
+    };
+  }
+  return routed;
+}
+
+function scopedReplayToolCallId(agentId: string, toolCallId: string): string {
+  return agentId === "main" ? toolCallId : `${agentId}:${toolCallId}`;
+}
+
+function parentCallKey(agentId: string, toolCallId: string): string {
+  return `${agentId}\u0000${toolCallId}`;
+}
+
+function resumedStatusPayload(agent: ResumedAgentState): {
+  context_usage?: number;
+  token_usage?: TokenUsage;
+} {
+  const maxContextTokens = agent.config.modelCapabilities.max_context_tokens;
+  const totalUsage = agent.usage.total ?? sumUsage(agent.usage.byModel) ?? agent.usage.currentTurn;
+  return {
+    ...(maxContextTokens > 0
+      ? { context_usage: agent.context.tokenCount / maxContextTokens }
+      : {}),
+    ...(totalUsage === undefined
+      ? {}
+      : {
+          token_usage: {
+            input_other: totalUsage.inputOther,
+            output: totalUsage.output,
+            input_cache_read: totalUsage.inputCacheRead,
+            input_cache_creation: totalUsage.inputCacheCreation,
+          },
+        }),
+  };
+}
+
+function sumUsage(
+  byModel: ResumedAgentState["usage"]["byModel"],
+): ResumedAgentState["usage"]["total"] {
+  if (byModel === undefined || Object.keys(byModel).length === 0) return undefined;
+  return Object.values(byModel).reduce(
+    (total, usage) => ({
+      inputOther: total.inputOther + usage.inputOther,
+      output: total.output + usage.output,
+      inputCacheRead: total.inputCacheRead + usage.inputCacheRead,
+      inputCacheCreation: total.inputCacheCreation + usage.inputCacheCreation,
+    }),
+    { inputOther: 0, output: 0, inputCacheRead: 0, inputCacheCreation: 0 },
+  );
+}
+
+function toLegacyContent(content: readonly ContentPart[]): LegacyContentPart[] {
+  const result: LegacyContentPart[] = [];
+  for (const part of content) {
+    switch (part.type) {
+      case "text":
+        result.push({ type: "text", text: part.text });
+        break;
+      case "think":
+        result.push({
+          type: "think",
+          think: part.think,
+          ...(part.encrypted === undefined ? {} : { encrypted: part.encrypted }),
+        });
+        break;
+      case "image_url":
+        result.push({ type: "image_url", image_url: { ...part.imageUrl } });
+        break;
+      case "audio_url":
+        result.push({ type: "audio_url", audio_url: { ...part.audioUrl } });
+        break;
+      case "video_url":
+        result.push({ type: "video_url", video_url: { ...part.videoUrl } });
+        break;
+    }
+  }
+  return result;
+}
+
+function isVisibleUserMessage(origin: PromptOrigin | undefined): boolean {
+  if (origin === undefined || origin.kind === "user") return true;
+  if (origin.kind === "skill_activation" || origin.kind === "plugin_command") {
+    return origin.trigger === "user-slash";
+  }
+  return origin.kind === "shell_command" && origin.phase === "input";
+}
+
+function replayUserInput(
+  content: readonly ContentPart[],
+  origin: PromptOrigin | undefined,
+): LegacyContentPart[] {
+  if (origin?.kind === "skill_activation" && origin.trigger === "user-slash") {
+    const args = origin.skillArgs?.trim();
+    return [{
+      type: "text",
+      text: `/skill:${origin.skillName}${args ? ` ${args}` : ""}`,
+    }];
+  }
+  if (origin?.kind === "plugin_command") {
+    const args = origin.commandArgs?.trim();
+    return [{
+      type: "text",
+      text: `/${origin.pluginId}:${origin.commandName}${args ? ` ${args}` : ""}`,
+    }];
+  }
+  return toLegacyContent(content);
+}
+
+function importedContextReplay(
+  content: readonly ContentPart[],
+): { input: LegacyContentPart[]; confirmation: string } | undefined {
+  const importedPart = content.find(
+    (part): part is Extract<ContentPart, { type: "text" }> =>
+      part.type === "text" && part.text.startsWith("<imported_context "),
+  );
+  if (importedPart === undefined) return undefined;
+  const match = /^<imported_context source="([^"]*)">\n([\s\S]*)\n<\/imported_context>$/.exec(
+    importedPart.text,
+  );
+  if (match === null) return undefined;
+  const source = decodeXml(match[1]!);
+  const importedText = match[2]!;
+  const target = importTarget(source);
+  return {
+    input: [{ type: "text", text: `/import ${target}` }],
+    confirmation: `Imported context from ${source} (${String(importedText.length)} chars).`,
+  };
+}
+
+function importTarget(source: string): string {
+  const quoted = /^(?:file|session) '([\s\S]*)'$/.exec(source);
+  return quoted?.[1] ?? source;
+}
+
+function decodeXml(value: string): string {
+  return value
+    .replaceAll("&quot;", '"')
+    .replaceAll("&apos;", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&");
+}
+
+function withSession<T extends LegacyWireEvent>(event: T, sessionId: string): T & { _sessionId: string } {
+  return { ...event, _sessionId: sessionId };
+}
+
+export function replayRecordTurnCount(records: readonly AgentReplayRecord[]): number {
+  return records.filter(
+    (record) =>
+      record.type === "message" &&
+      record.message.role === "user" &&
+      isVisibleUserMessage(record.message.origin),
+  ).length;
+}
diff --git a/apps/vscode/src/runtime/reverse-rpc.ts b/apps/vscode/src/runtime/reverse-rpc.ts
new file mode 100644
index 000000000..13a66f049
--- /dev/null
+++ b/apps/vscode/src/runtime/reverse-rpc.ts
@@ -0,0 +1,97 @@
+import { randomUUID } from "node:crypto";
+
+import type {
+  ApprovalRequest,
+  ApprovalResponse as CoreApprovalResponse,
+  QuestionRequest,
+  QuestionResult,
+} from "@moonshot-ai/kimi-code-sdk";
+
+import type { ApprovalResponse, QuestionRequest as LegacyQuestionRequest } from "../../shared/legacy-sdk";
+import { describeToolDisplay, toLegacyDisplay } from "./tool-display";
+
+export type ReverseRpcEvent =
+  | { type: "ApprovalRequest"; payload: ReturnType<typeof approvalPayload> }
+  | { type: "QuestionRequest"; payload: LegacyQuestionRequest };
+
+export class ReverseRpcController {
+  private readonly approvals = new Map<string, (response: CoreApprovalResponse) => void>();
+  private readonly questions = new Map<string, (result: QuestionResult) => void>();
+
+  constructor(private readonly emit: (event: ReverseRpcEvent) => void) {}
+
+  requestApproval(request: ApprovalRequest): Promise<CoreApprovalResponse> {
+    const id = randomUUID();
+    return new Promise((resolve) => {
+      this.approvals.set(id, resolve);
+      this.emit({ type: "ApprovalRequest", payload: approvalPayload(id, request) });
+    });
+  }
+
+  requestQuestion(request: QuestionRequest): Promise<QuestionResult> {
+    const id = randomUUID();
+    return new Promise((resolve) => {
+      this.questions.set(id, resolve);
+      this.emit({
+        type: "QuestionRequest",
+        payload: {
+          id,
+          tool_call_id: request.toolCallId ?? "",
+          questions: request.questions.map((question) => ({
+            question: question.question,
+            header: question.header,
+            options: question.options.map((option) => ({
+              label: option.label,
+              description: option.description,
+            })),
+            multi_select: question.multiSelect,
+          })),
+        },
+      });
+    });
+  }
+
+  respondApproval(id: string, response: ApprovalResponse): boolean {
+    const resolve = this.approvals.get(id);
+    if (!resolve) return false;
+    this.approvals.delete(id);
+    if (response === "approve_for_session") {
+      resolve({ decision: "approved", scope: "session" });
+    } else if (response === "approve") {
+      resolve({ decision: "approved" });
+    } else {
+      resolve({ decision: "rejected" });
+    }
+    return true;
+  }
+
+  respondQuestion(id: string, answers: Record<string, string>): boolean {
+    const resolve = this.questions.get(id);
+    if (!resolve) return false;
+    this.questions.delete(id);
+    resolve({ answers });
+    return true;
+  }
+
+  cancelAll(reason: string): void {
+    for (const resolve of this.approvals.values()) {
+      resolve({ decision: "cancelled", feedback: reason });
+    }
+    for (const resolve of this.questions.values()) {
+      resolve(null);
+    }
+    this.approvals.clear();
+    this.questions.clear();
+  }
+}
+
+function approvalPayload(id: string, request: ApprovalRequest) {
+  return {
+    id,
+    tool_call_id: request.toolCallId,
+    sender: request.toolName,
+    action: request.action,
+    description: describeToolDisplay(request.display),
+    display: toLegacyDisplay(request.display),
+  };
+}
diff --git a/apps/vscode/src/runtime/session-runtime.ts b/apps/vscode/src/runtime/session-runtime.ts
new file mode 100644
index 000000000..c1009930f
--- /dev/null
+++ b/apps/vscode/src/runtime/session-runtime.ts
@@ -0,0 +1,628 @@
+import {
+  isKimiError,
+  type ContentPart as SdkContentPart,
+  type Event,
+  type PromptInput,
+  type Session,
+  type SessionSummary,
+} from "@moonshot-ai/kimi-code-sdk";
+
+import type { ContentPart as LegacyContentPart, ApprovalResponse } from "../../shared/legacy-sdk";
+import { Events } from "../../shared/bridge";
+import { getUserMessage } from "../../shared/errors";
+import type { ErrorPhase, UIStreamEvent } from "../../shared/types";
+import {
+  adaptSdkEvent,
+  createEventAdapterState,
+  type EventAdapterState,
+  type TurnTerminalMetadata,
+} from "./event-adapter";
+import {
+  corePermissionForLegacyApproval,
+  legacyApprovalMetadata,
+  type LegacyApprovalFlags,
+} from "./legacy-approval";
+import { ReverseRpcController } from "./reverse-rpc";
+
+export type RuntimeBroadcast = (event: string, data: unknown, webviewId?: string) => void;
+
+export interface SessionRuntimeOptions {
+  readonly session: Session;
+  readonly legacyApproval: LegacyApprovalFlags;
+  readonly broadcast: RuntimeBroadcast;
+  readonly captureBaseline: (
+    session: Pick<SessionSummary, "id" | "workDir" | "metadata">,
+    filePath: string,
+    webviewIds: readonly string[],
+  ) => void;
+  readonly log: (message: string, error?: unknown) => void;
+}
+
+interface ActivePrompt {
+  readonly input: LegacyContentPart[] | string;
+  started: boolean;
+  settled: boolean;
+  resolve: (result: PromptResult) => void;
+}
+
+export interface PromptResult {
+  readonly status: "finished" | "cancelled" | "failed";
+}
+
+interface SuppressedError {
+  readonly code: string;
+  readonly message: string;
+}
+
+interface PendingHostCompaction {
+  readonly actionId: number;
+  readonly resolve: (result: "completed" | "cancelled") => void;
+  readonly reject: (error: unknown) => void;
+}
+
+/**
+ * Owns the one SDK event subscription and reverse-RPC handlers for a session.
+ * Any number of Webviews may subscribe without replacing each other's approval
+ * handler or duplicating streamed events.
+ */
+export class SessionRuntime {
+  readonly session: Session;
+
+  private readonly broadcast: RuntimeBroadcast;
+  private readonly captureBaseline: SessionRuntimeOptions["captureBaseline"];
+  private readonly log: SessionRuntimeOptions["log"];
+  private readonly webviewIds = new Set<string>();
+  private readonly reverseRpc: ReverseRpcController;
+  private readonly unsubscribe: () => void;
+  private adapterState: EventAdapterState = createEventAdapterState();
+  private activePrompt: ActivePrompt | undefined;
+  private hostActionActive = false;
+  private hostActionSequence = 0;
+  private activeHostActionId: number | undefined;
+  private readonly cancelledHostActions = new Set<number>();
+  private pendingHostCompaction: PendingHostCompaction | undefined;
+  private readonly activeWorkSettledWaiters = new Set<() => void>();
+  private exclusiveActionActive = false;
+  private readonly terminalKeys = new Set<string>();
+  private suppressedError: SuppressedError | undefined;
+  private legacyApproval: LegacyApprovalFlags;
+  private closed = false;
+
+  constructor(options: SessionRuntimeOptions) {
+    this.session = options.session;
+    this.broadcast = options.broadcast;
+    this.captureBaseline = options.captureBaseline;
+    this.log = options.log;
+    this.legacyApproval = options.legacyApproval;
+    this.reverseRpc = new ReverseRpcController((event) => this.emitStreamEvent(event));
+
+    this.session.setApprovalHandler((request) =>
+      this.legacyApproval.yolo || this.legacyApproval.afk
+        ? Promise.resolve({ decision: "approved" })
+        : this.reverseRpc.requestApproval(request),
+    );
+    this.session.setQuestionHandler((request) => this.reverseRpc.requestQuestion(request));
+    this.unsubscribe = this.session.onEvent((event) => this.onSdkEvent(event));
+  }
+
+  get id(): string {
+    return this.session.id;
+  }
+
+  get summary(): SessionSummary | undefined {
+    return this.session.summary;
+  }
+
+  get subscribers(): readonly string[] {
+    return [...this.webviewIds];
+  }
+
+  get isBusy(): boolean {
+    return this.hasActiveWork || this.exclusiveActionActive;
+  }
+
+  get legacyApprovalFlags(): LegacyApprovalFlags {
+    return this.legacyApproval;
+  }
+
+  async toggleLegacyApproval(kind: keyof LegacyApprovalFlags): Promise<LegacyApprovalFlags> {
+    const next = { ...this.legacyApproval, [kind]: !this.legacyApproval[kind] };
+    await this.applyLegacyApproval(next);
+    return next;
+  }
+
+  async setLegacyYoloMode(enabled: boolean): Promise<void> {
+    if (this.legacyApproval.yolo === enabled) return;
+    await this.applyLegacyApproval({ ...this.legacyApproval, yolo: enabled });
+  }
+
+  subscribe(webviewId: string): void {
+    this.ensureOpen();
+    this.webviewIds.add(webviewId);
+  }
+
+  /**
+   * Push the session's current status to a view. Called whenever a view
+   * opens or re-enters a session so the display (model, thinking effort,
+   * plan mode) matches engine truth instead of the global defaults.
+   */
+  async announceStatus(webviewId: string): Promise<void> {
+    this.ensureOpen();
+    const status = await this.session.getStatus();
+    if (this.closed || !this.webviewIds.has(webviewId)) return;
+    this.broadcast(
+      Events.StreamEvent,
+      {
+        type: "StatusUpdate",
+        payload: {
+          model: status.model,
+          thinking_effort: status.thinkingEffort,
+          plan_mode: status.planMode,
+        },
+        _sessionId: this.id,
+      },
+      webviewId,
+    );
+  }
+
+  unsubscribeView(webviewId: string): void {
+    this.webviewIds.delete(webviewId);
+  }
+
+  async prompt(input: string | LegacyContentPart[]): Promise<PromptResult> {
+    return this.runTurnAction(input, () => this.session.prompt(toSdkPromptInput(input)));
+  }
+
+  async runTurnAction(
+    input: string | LegacyContentPart[],
+    action: () => Promise<void>,
+  ): Promise<PromptResult> {
+    this.ensureOpen();
+    if (this.isBusy) {
+      throw new Error("A response is already being generated for this session.");
+    }
+
+    let resolveCompletion!: (result: PromptResult) => void;
+    const completion = new Promise<PromptResult>((resolve) => {
+      resolveCompletion = resolve;
+    });
+    this.activePrompt = {
+      input,
+      started: false,
+      settled: false,
+      resolve: resolveCompletion,
+    };
+
+    try {
+      await action();
+    } catch (error) {
+      if (this.activePrompt !== undefined && !this.activePrompt.started) {
+        this.emitError(error, "preflight");
+        this.settlePrompt({ status: "failed" });
+      } else {
+        this.emitError(error, "runtime");
+        this.settlePrompt({ status: "failed" });
+      }
+    }
+
+    return completion;
+  }
+
+  beginHostAction(input: string | LegacyContentPart[], forkable = false): number {
+    this.ensureOpen();
+    if (this.isBusy) {
+      throw new Error("A response is already being generated for this session.");
+    }
+    const actionId = ++this.hostActionSequence;
+    this.hostActionActive = true;
+    this.activeHostActionId = actionId;
+    this.emitStreamEvent({
+      type: "TurnBegin",
+      payload: { user_input: input, forkable },
+      _sessionId: this.id,
+    });
+    this.emitStreamEvent({
+      type: "StepBegin",
+      payload: { n: 1 },
+      _sessionId: this.id,
+    });
+    return actionId;
+  }
+
+  emitHostText(text: string, actionId = this.activeHostActionId): void {
+    if (!this.hostActionActive || actionId !== this.activeHostActionId || text.length === 0) return;
+    this.emitStreamEvent({
+      type: "ContentPart",
+      payload: { type: "text", text },
+      _sessionId: this.id,
+    });
+  }
+
+  announceSessionStart(model?: string): void {
+    this.emitStreamEvent({
+      type: "session_start",
+      sessionId: this.id,
+      ...(model === undefined ? {} : { model }),
+      _sessionId: this.id,
+    });
+  }
+
+  completeHostAction(
+    status: "finished" | "cancelled" = "finished",
+    actionId = this.activeHostActionId,
+  ): void {
+    if (!this.hostActionActive || actionId !== this.activeHostActionId) return;
+    this.hostActionActive = false;
+    this.activeHostActionId = undefined;
+    this.emitStreamEvent({
+      type: "stream_complete",
+      result: { status },
+      _sessionId: this.id,
+    });
+    this.notifyActiveWorkSettled();
+  }
+
+  failHostAction(actionId: number): void {
+    if (!this.hostActionActive || actionId !== this.activeHostActionId) return;
+    this.hostActionActive = false;
+    this.activeHostActionId = undefined;
+    this.notifyActiveWorkSettled();
+  }
+
+  wasHostActionCancelled(actionId: number): boolean {
+    return this.cancelledHostActions.has(actionId);
+  }
+
+  releaseHostAction(actionId: number): void {
+    this.cancelledHostActions.delete(actionId);
+  }
+
+  async compactHostAction(actionId: number, instruction?: string): Promise<void> {
+    if (!this.hostActionActive || actionId !== this.activeHostActionId) {
+      throw new Error("The host action is no longer active.");
+    }
+    if (this.pendingHostCompaction !== undefined) {
+      throw new Error("A context compaction is already running.");
+    }
+
+    let resolveCompletion!: (result: "completed" | "cancelled") => void;
+    let rejectCompletion!: (error: unknown) => void;
+    const completion = new Promise<"completed" | "cancelled">((resolve, reject) => {
+      resolveCompletion = resolve;
+      rejectCompletion = reject;
+    });
+    this.pendingHostCompaction = {
+      actionId,
+      resolve: resolveCompletion,
+      reject: rejectCompletion,
+    };
+
+    try {
+      await this.session.compact(instruction === undefined ? {} : { instruction });
+    } catch (error) {
+      if (this.pendingHostCompaction?.actionId === actionId) {
+        this.pendingHostCompaction = undefined;
+        rejectCompletion(error);
+      }
+    }
+
+    const result = await completion;
+    if (result === "cancelled") {
+      throw new Error("Context compaction was cancelled.");
+    }
+  }
+
+  async cancel(): Promise<void> {
+    if (this.closed || !this.hasActiveWork) return;
+    this.reverseRpc.cancelAll("Turn cancelled");
+    const cancellingHostAction = this.hostActionActive;
+    const hostActionId = this.activeHostActionId;
+    if (cancellingHostAction && hostActionId !== undefined) {
+      this.cancelledHostActions.add(hostActionId);
+      this.completeHostAction("cancelled", hostActionId);
+    }
+    // A manual compaction is not a model turn, so Session.cancel() alone does
+    // not stop it. Calling both public cancellation surfaces is harmless when
+    // the other operation is idle and keeps the Stop button correct for both
+    // normal turns and host-side slash commands such as /compact and /init.
+    const results = await Promise.allSettled([
+      this.session.cancel(),
+      ...(cancellingHostAction ? [this.session.cancelCompaction()] : []),
+    ]);
+    const failure = results.find((result): result is PromiseRejectedResult => result.status === "rejected");
+    if (failure !== undefined) throw failure.reason;
+  }
+
+  /**
+   * Stop any in-flight work, wait for its terminal event, and keep new turns
+   * out until the supplied operation finishes. Forking uses this so it reads a
+   * fully settled session instead of racing the asynchronous cancel event.
+   */
+  async runExclusiveAfterCancelling<T>(action: () => Promise<T>): Promise<T> {
+    this.ensureOpen();
+    if (this.exclusiveActionActive) {
+      throw new Error("Another session operation is already in progress.");
+    }
+
+    this.exclusiveActionActive = true;
+    try {
+      const settled = this.waitForActiveWorkToSettle();
+      await this.cancel();
+      await settled;
+      this.ensureOpen();
+      return await action();
+    } finally {
+      this.exclusiveActionActive = false;
+    }
+  }
+
+  async steer(input: string | LegacyContentPart[]): Promise<void> {
+    this.ensureOpen();
+    await this.session.steer(toSdkPromptInput(input));
+    this.emitStreamEvent({
+      type: "SteerInput",
+      payload: { user_input: input },
+      _sessionId: this.id,
+    });
+  }
+
+  respondApproval(id: string, response: ApprovalResponse): boolean {
+    return this.reverseRpc.respondApproval(id, response);
+  }
+
+  respondQuestion(id: string, answers: Record<string, string>): boolean {
+    return this.reverseRpc.respondQuestion(id, answers);
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    this.pendingHostCompaction?.reject(new Error("Session closed during context compaction."));
+    this.pendingHostCompaction = undefined;
+    this.reverseRpc.cancelAll("Session closed");
+    this.unsubscribe();
+    this.session.setApprovalHandler(undefined);
+    this.session.setQuestionHandler(undefined);
+    if (this.activePrompt !== undefined || this.hostActionActive) {
+      try {
+        await this.session.cancel();
+      } catch (error) {
+        this.log("Failed to cancel the active turn while closing a session", error);
+      }
+      if (this.activePrompt !== undefined) this.settlePrompt({ status: "cancelled" });
+      this.hostActionActive = false;
+      this.activeHostActionId = undefined;
+      this.notifyActiveWorkSettled();
+    }
+    this.cancelledHostActions.clear();
+    await this.session.close();
+    this.webviewIds.clear();
+  }
+
+  private async applyLegacyApproval(flags: LegacyApprovalFlags): Promise<void> {
+    this.ensureOpen();
+    const permission = corePermissionForLegacyApproval(flags);
+    const status = await this.session.getStatus();
+    const permissionChanged = status.permission !== permission;
+    if (permissionChanged) await this.session.setPermission(permission);
+    try {
+      await this.session.updateMetadata(legacyApprovalMetadata(flags));
+    } catch (error) {
+      if (permissionChanged) {
+        await this.session.setPermission(status.permission).catch((rollbackError: unknown) => {
+          this.log("Failed to restore session permission after a metadata error", rollbackError);
+        });
+      }
+      throw error;
+    }
+    this.legacyApproval = flags;
+  }
+
+  private onSdkEvent(event: Event): void {
+    if (this.closed) return;
+
+    if (event.type === "compaction.completed" || event.type === "compaction.cancelled") {
+      const pending = this.pendingHostCompaction;
+      if (pending !== undefined) {
+        this.pendingHostCompaction = undefined;
+        pending.resolve(event.type === "compaction.completed" ? "completed" : "cancelled");
+      }
+    }
+
+    if (event.type === "turn.started" && event.agentId === "main" && this.activePrompt !== undefined) {
+      this.activePrompt.started = true;
+    }
+
+    if (event.type === "tool.call.started") {
+      this.captureFileBaseline(event);
+    }
+
+    if (event.type === "turn.step.retrying") {
+      this.log(
+        `Provider retry ${event.nextAttempt}/${event.maxAttempts} in ${event.delayMs}ms`,
+        new Error(event.errorMessage),
+      );
+    }
+
+    if (event.type === "error" && this.consumeSuppressedError(event.code, event.message)) {
+      return;
+    }
+
+    const pendingInput = this.activePrompt?.input;
+    const adapted = adaptSdkEvent(this.adapterState, event, {
+      pendingInput,
+      errorPhase: this.activePrompt?.started === false ? "preflight" : "runtime",
+    });
+    this.adapterState = adapted.state;
+
+    if (adapted.terminal !== undefined) {
+      this.emitTerminal(adapted.terminal);
+      return;
+    }
+
+    if (adapted.event !== undefined) {
+      this.emitStreamEvent(adapted.event);
+      if (adapted.event.type === "error" && this.activePrompt !== undefined && !this.activePrompt.started) {
+        this.settlePrompt({ status: "failed" });
+      }
+    }
+  }
+
+  private captureFileBaseline(event: Extract<Event, { type: "tool.call.started" }>): void {
+    if (event.name !== "Write" && event.name !== "Edit") return;
+    if (!isRecord(event.args)) return;
+    const filePath = event.args["path"];
+    if (typeof filePath !== "string" || filePath.length === 0) return;
+
+    const summary = this.session.summary;
+    this.captureBaseline(
+      {
+        id: this.session.id,
+        workDir: this.session.workDir,
+        metadata: summary?.metadata,
+      },
+      filePath,
+      this.subscribers,
+    );
+  }
+
+  private emitTerminal(terminal: TurnTerminalMetadata): void {
+    if (this.terminalKeys.has(terminal.key)) return;
+    this.terminalKeys.add(terminal.key);
+
+    if (terminal.reason === "completed") {
+      this.emitStreamEvent({
+        type: "stream_complete",
+        result: { status: "finished" },
+        _sessionId: terminal.sessionId,
+      });
+      this.settlePrompt({ status: "finished" });
+      return;
+    }
+
+    if (terminal.reason === "cancelled") {
+      this.reverseRpc.cancelAll("Turn cancelled");
+      this.emitStreamEvent({
+        type: "stream_complete",
+        result: { status: "cancelled" },
+        _sessionId: terminal.sessionId,
+      });
+      this.settlePrompt({ status: "cancelled" });
+      return;
+    }
+
+    const code = terminal.error?.code ?? `turn.${terminal.reason}`;
+    this.reverseRpc.cancelAll("Turn ended");
+    const detail = terminal.error?.message ?? `Turn ended with reason: ${terminal.reason}`;
+    const message = getUserMessage(code, detail);
+    this.log("Session turn failed", new Error(`${code}: ${detail}`));
+    this.emitStreamEvent({
+      type: "error",
+      code,
+      message,
+      detail,
+      phase: "runtime",
+      _sessionId: terminal.sessionId,
+    });
+    if (terminal.error !== undefined) {
+      this.suppressedError = { code: terminal.error.code, message: terminal.error.message };
+    }
+    this.settlePrompt({ status: "failed" });
+  }
+
+  private consumeSuppressedError(code: string, message: string): boolean {
+    const suppressed = this.suppressedError;
+    if (suppressed === undefined) return false;
+    this.suppressedError = undefined;
+    return suppressed.code === code && suppressed.message === message;
+  }
+
+  private emitError(error: unknown, phase: ErrorPhase): void {
+    const code = isKimiError(error) ? error.code : "internal";
+    const detail = error instanceof Error ? error.message : String(error);
+    this.log(`Session ${phase} error`, error);
+    this.emitStreamEvent({
+      type: "error",
+      code,
+      message: getUserMessage(code, detail),
+      detail,
+      phase,
+      _sessionId: this.session.id,
+    });
+  }
+
+  private emitStreamEvent(event: UIStreamEvent | { type: string; payload: unknown }): void {
+    for (const webviewId of this.webviewIds) {
+      this.broadcast(Events.StreamEvent, event, webviewId);
+    }
+  }
+
+  private settlePrompt(result: PromptResult): void {
+    const active = this.activePrompt;
+    if (active === undefined || active.settled) return;
+    active.settled = true;
+    this.activePrompt = undefined;
+    active.resolve(result);
+    this.notifyActiveWorkSettled();
+  }
+
+  private get hasActiveWork(): boolean {
+    return this.activePrompt !== undefined || this.hostActionActive;
+  }
+
+  private waitForActiveWorkToSettle(): Promise<void> {
+    if (!this.hasActiveWork) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.activeWorkSettledWaiters.add(resolve);
+    });
+  }
+
+  private notifyActiveWorkSettled(): void {
+    if (this.hasActiveWork) return;
+    for (const resolve of this.activeWorkSettledWaiters) resolve();
+    this.activeWorkSettledWaiters.clear();
+  }
+
+  private ensureOpen(): void {
+    if (this.closed) throw new Error("Session is closed.");
+  }
+}
+
+export function toSdkPromptInput(input: string | LegacyContentPart[]): string | PromptInput {
+  if (typeof input === "string") return input;
+  const parts: SdkContentPart[] = [];
+  for (const part of input) {
+    switch (part.type) {
+      case "text":
+        parts.push({ type: "text", text: part.text });
+        break;
+      case "image_url":
+        parts.push({
+          type: "image_url",
+          imageUrl: {
+            url: part.image_url.url,
+            ...(part.image_url.id === null || part.image_url.id === undefined ? {} : { id: part.image_url.id }),
+          },
+        });
+        break;
+      case "video_url":
+        parts.push({
+          type: "video_url",
+          videoUrl: {
+            url: part.video_url.url,
+            ...(part.video_url.id === null || part.video_url.id === undefined ? {} : { id: part.video_url.id }),
+          },
+        });
+        break;
+      case "audio_url":
+      case "think":
+        // PromptInput intentionally accepts user text/images/videos only.
+        break;
+    }
+  }
+  return parts as PromptInput;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
diff --git a/apps/vscode/src/runtime/tool-display.ts b/apps/vscode/src/runtime/tool-display.ts
new file mode 100644
index 000000000..fe7750977
--- /dev/null
+++ b/apps/vscode/src/runtime/tool-display.ts
@@ -0,0 +1,75 @@
+import type { ToolInputDisplay } from "@moonshot-ai/kimi-code-sdk";
+
+import type { DisplayBlock } from "../../shared/legacy-sdk";
+
+export function describeToolDisplay(display: ToolInputDisplay): string {
+  switch (display.kind) {
+    case "command":
+      return display.command;
+    case "file_io":
+      return `${display.operation} ${display.path}`;
+    case "diff":
+      return `Edit ${display.path}`;
+    case "search":
+      return `Search for ${display.query}`;
+    case "url_fetch":
+      return display.url;
+    case "agent_call":
+      return display.prompt;
+    case "skill_call":
+      return display.args ? `${display.skill_name} ${display.args}` : display.skill_name;
+    case "todo_list":
+      return "Update the task list";
+    case "task":
+      return display.description;
+    case "task_stop":
+      return display.task_description;
+    case "plan_review":
+      return display.plan;
+    case "goal_start":
+      return display.objective;
+    case "generic":
+      return display.summary;
+  }
+}
+
+export function toLegacyDisplay(display: ToolInputDisplay): DisplayBlock[] {
+  switch (display.kind) {
+    case "command":
+      return [{ type: "shell", language: display.language ?? "bash", command: display.command }];
+    case "diff":
+      return [{ type: "diff", path: display.path, old_text: display.before, new_text: display.after }];
+    case "file_io":
+      if (
+        display.before !== undefined ||
+        display.after !== undefined ||
+        display.content !== undefined
+      ) {
+        return [{
+          type: "diff",
+          path: display.path,
+          old_text: display.before ?? "",
+          new_text: display.after ?? display.content ?? "",
+        }];
+      }
+      return [{ type: "brief", text: describeToolDisplay(display) }];
+    case "todo_list":
+      return [{
+        type: "todo",
+        items: display.items.map((item) => ({
+          title: item.title,
+          status: item.status === "done" || item.status === "in_progress" ? item.status : "pending",
+        })),
+      }];
+    case "search":
+    case "url_fetch":
+    case "agent_call":
+    case "skill_call":
+    case "task":
+    case "task_stop":
+    case "plan_review":
+    case "goal_start":
+    case "generic":
+      return [{ type: "brief", text: describeToolDisplay(display) }];
+  }
+}
diff --git a/apps/vscode/src/utils/context.ts b/apps/vscode/src/utils/context.ts
new file mode 100644
index 000000000..6f1058707
--- /dev/null
+++ b/apps/vscode/src/utils/context.ts
@@ -0,0 +1,9 @@
+import * as vscode from "vscode";
+import type { KimiHarness } from "@moonshot-ai/kimi-code-sdk";
+
+export async function updateLoginContext(harness: KimiHarness): Promise<boolean> {
+  const status = await harness.auth.status();
+  const loggedIn = status.providers.some((provider) => provider.hasToken);
+  await vscode.commands.executeCommand("setContext", "kimi.isLoggedIn", loggedIn);
+  return loggedIn;
+}
diff --git a/apps/vscode/src/utils/fs-path.ts b/apps/vscode/src/utils/fs-path.ts
new file mode 100644
index 000000000..d82a2dbb8
--- /dev/null
+++ b/apps/vscode/src/utils/fs-path.ts
@@ -0,0 +1,28 @@
+import * as path from "node:path";
+
+/** Return a forward-slash relative path when `candidate` is inside `root`. */
+export function relativeFsPath(root: string, candidate: string): string | undefined {
+  const paths = isWindowsPath(root) || isWindowsPath(candidate) ? path.win32 : path;
+  const relativePath = paths.relative(paths.resolve(root), paths.resolve(candidate));
+  if (
+    relativePath === "" ||
+    (!relativePath.startsWith(`..${paths.sep}`) && relativePath !== ".." && !paths.isAbsolute(relativePath))
+  ) {
+    return relativePath.split(paths.sep).join("/");
+  }
+  return undefined;
+}
+
+/** Whether two native filesystem paths identify the same location. */
+export function areSameFsPath(left: string, right: string): boolean {
+  return relativeFsPath(left, right) === "";
+}
+
+/** Whether `candidate` is `root` or a descendant using native path rules. */
+export function isFsPathInsideOrEqual(root: string, candidate: string): boolean {
+  return relativeFsPath(root, candidate) !== undefined;
+}
+
+function isWindowsPath(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || /^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(value);
+}
diff --git a/apps/vscode/src/utils/session-context.ts b/apps/vscode/src/utils/session-context.ts
new file mode 100644
index 000000000..e4ff4ce5b
--- /dev/null
+++ b/apps/vscode/src/utils/session-context.ts
@@ -0,0 +1,232 @@
+import type {
+  ContentPart,
+  ContextMessage,
+  PromptOrigin,
+  ToolCall,
+} from "@moonshot-ai/kimi-code-sdk";
+
+const INTERNAL_ORIGINS = new Set<PromptOrigin["kind"]>([
+  "injection",
+  "system_trigger",
+  "compaction_summary",
+  "hook_result",
+  "cron_job",
+  "cron_missed",
+]);
+
+const TOOL_HINT_KEYS = ["path", "file_path", "command", "query", "url", "name", "pattern"];
+
+export function buildExportMarkdown(input: {
+  readonly sessionId: string;
+  readonly workDir: string;
+  readonly history: readonly ContextMessage[];
+  readonly tokenCount: number;
+  readonly now: Date;
+}): string {
+  const turns = groupIntoTurns(input.history);
+  const firstUser = input.history.find(
+    (message) => message.role === "user" && !isInternalMessage(message),
+  );
+  const topic = firstUser === undefined ? "" : shorten(stringifyParts(firstUser.content), 80);
+  const toolCalls = input.history.reduce((count, message) => count + message.toolCalls.length, 0);
+  const lines = [
+    "---",
+    `session_id: ${input.sessionId}`,
+    `exported_at: ${input.now.toISOString()}`,
+    `work_dir: ${input.workDir}`,
+    `message_count: ${String(input.history.length)}`,
+    `token_count: ${String(input.tokenCount)}`,
+    "---",
+    "",
+    "# Kimi Session Export",
+    "",
+    "## Overview",
+    "",
+    topic ? `- **Topic**: ${topic}` : "- **Topic**: (empty)",
+    `- **Conversation**: ${String(turns.length)} turns | ${String(toolCalls)} tool calls`,
+    "",
+    "---",
+    "",
+  ];
+
+  for (let index = 0; index < turns.length; index += 1) {
+    lines.push(formatTurn(turns[index]!, index + 1));
+  }
+  return lines.join("\n");
+}
+
+export function stringifyContextHistory(history: readonly ContextMessage[]): string {
+  const messages: string[] = [];
+  for (const message of history) {
+    if (isInternalMessage(message)) continue;
+    const sections: string[] = [];
+    const content = stringifyParts(message.content);
+    if (content.trim()) sections.push(content);
+    if (message.toolCalls.length > 0) {
+      sections.push(message.toolCalls.map(stringifyToolCall).join("\n"));
+    }
+    if (sections.length === 0) continue;
+    const callId = message.role === "tool" && message.toolCallId
+      ? ` (call_id: ${message.toolCallId})`
+      : "";
+    messages.push(`[${message.role.toUpperCase()}]${callId}\n${sections.join("\n")}`);
+  }
+  return messages.join("\n\n");
+}
+
+export function isImportableTextFile(fileName: string): boolean {
+  const dot = fileName.lastIndexOf(".");
+  if (dot <= 0) return true;
+  return IMPORTABLE_EXTENSIONS.has(fileName.slice(dot).toLowerCase());
+}
+
+export function isSensitiveFile(fileName: string): boolean {
+  const normalized = fileName.toLowerCase();
+  return [".env", "credentials", "secrets", ".pem", ".key", ".p12", ".pfx", ".keystore"]
+    .some((pattern) => normalized.includes(pattern));
+}
+
+function isInternalMessage(message: ContextMessage): boolean {
+  return message.origin !== undefined && INTERNAL_ORIGINS.has(message.origin.kind);
+}
+
+function groupIntoTurns(history: readonly ContextMessage[]): ContextMessage[][] {
+  const turns: ContextMessage[][] = [];
+  let current: ContextMessage[] = [];
+  for (const message of history) {
+    if (isInternalMessage(message)) continue;
+    if (message.role === "user" && current.length > 0) {
+      turns.push(current);
+      current = [];
+    }
+    current.push(message);
+  }
+  if (current.length > 0) turns.push(current);
+  return turns;
+}
+
+function formatTurn(messages: readonly ContextMessage[], turnNumber: number): string {
+  const lines = [`## Turn ${String(turnNumber)}`, ""];
+  const toolInfo = new Map<string, { name: string; hint: string }>();
+  let assistantHeading = false;
+  for (const message of messages) {
+    if (message.role === "user") {
+      lines.push("### User", "", stringifyParts(message.content), "");
+      continue;
+    }
+    if (message.role === "assistant") {
+      if (!assistantHeading) {
+        lines.push("### Assistant", "");
+        assistantHeading = true;
+      }
+      const content = formatPartsMarkdown(message.content);
+      if (content) lines.push(content, "");
+      for (const call of message.toolCalls) {
+        const hint = toolCallHint(call);
+        toolInfo.set(call.id, { name: call.name, hint });
+        lines.push(formatToolCallMarkdown(call, hint), "");
+      }
+      continue;
+    }
+    if (message.role === "tool") {
+      const info = toolInfo.get(message.toolCallId ?? "") ?? { name: "unknown", hint: "" };
+      const hint = info.hint ? ` (\`${info.hint}\`)` : "";
+      lines.push(
+        `<details><summary>Tool Result: ${info.name}${hint}</summary>`,
+        "",
+        `<!-- call_id: ${message.toolCallId ?? "unknown"} -->`,
+        formatPartsMarkdown(message.content),
+        "",
+        "</details>",
+        "",
+      );
+      continue;
+    }
+    lines.push(`### ${capitalize(message.role)}`, "", formatPartsMarkdown(message.content), "");
+  }
+  return lines.join("\n");
+}
+
+function formatToolCallMarkdown(call: ToolCall, hint: string): string {
+  let args = call.arguments ?? "{}";
+  try {
+    args = JSON.stringify(JSON.parse(args), null, 2);
+  } catch {
+    // Preserve malformed arguments exactly as recorded.
+  }
+  const suffix = hint ? ` (\`${hint}\`)` : "";
+  return `#### Tool Call: ${call.name}${suffix}\n<!-- call_id: ${call.id} -->\n\`\`\`json\n${args}\n\`\`\``;
+}
+
+function toolCallHint(call: ToolCall): string {
+  let args: unknown;
+  try {
+    args = JSON.parse(call.arguments ?? "{}");
+  } catch {
+    return "";
+  }
+  if (!isRecord(args)) return "";
+  for (const key of TOOL_HINT_KEYS) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) return shorten(value, 60);
+  }
+  return "";
+}
+
+function stringifyToolCall(call: ToolCall): string {
+  let args = call.arguments ?? "{}";
+  try {
+    args = JSON.stringify(JSON.parse(args));
+  } catch {
+    // Preserve malformed arguments exactly as recorded.
+  }
+  return `Tool Call: ${call.name}(${args})`;
+}
+
+function formatPartsMarkdown(parts: readonly ContentPart[]): string {
+  return parts.map(formatPartMarkdown).filter(Boolean).join("\n");
+}
+
+function formatPartMarkdown(part: ContentPart): string {
+  switch (part.type) {
+    case "text": return part.text;
+    case "think": return part.think.trim()
+      ? `<details><summary>Thinking</summary>\n\n${part.think}\n\n</details>`
+      : "";
+    case "image_url": return "[image]";
+    case "audio_url": return "[audio]";
+    case "video_url": return "[video]";
+  }
+}
+
+function stringifyParts(parts: readonly ContentPart[]): string {
+  return parts.map((part) => {
+    if (part.type === "text") return part.text;
+    if (part.type === "think") return part.think.trim() ? `<thinking>\n${part.think}\n</thinking>` : "";
+    if (part.type === "image_url") return "[image]";
+    if (part.type === "audio_url") return "[audio]";
+    return "[video]";
+  }).filter(Boolean).join("\n");
+}
+
+function capitalize(value: string): string {
+  return value.length === 0 ? value : value[0]!.toUpperCase() + value.slice(1);
+}
+
+function shorten(value: string, width: number): string {
+  return value.length <= width ? value : `${value.slice(0, width)}…`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const IMPORTABLE_EXTENSIONS = new Set([
+  ".md", ".markdown", ".txt", ".text", ".rst", ".json", ".jsonl", ".yaml", ".yml",
+  ".toml", ".ini", ".cfg", ".conf", ".csv", ".tsv", ".xml", ".env", ".properties",
+  ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".kt", ".go", ".rs", ".c", ".cpp",
+  ".h", ".hpp", ".cs", ".rb", ".php", ".swift", ".scala", ".sh", ".bash", ".zsh",
+  ".fish", ".ps1", ".bat", ".cmd", ".r", ".lua", ".pl", ".pm", ".ex", ".exs",
+  ".erl", ".hs", ".ml", ".sql", ".graphql", ".proto", ".html", ".htm", ".css",
+  ".scss", ".sass", ".less", ".svg", ".log", ".tex", ".bib", ".org", ".adoc", ".wiki",
+]);
diff --git a/apps/vscode/src/utils/string.ts b/apps/vscode/src/utils/string.ts
new file mode 100644
index 000000000..801d46ede
--- /dev/null
+++ b/apps/vscode/src/utils/string.ts
@@ -0,0 +1,17 @@
+export function buildCaseInsensitiveGlobLiteral(input: string) {
+  let out = "";
+  for (const ch of input) {
+    if ((ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z")) {
+      const l = ch.toLowerCase();
+      const u = ch.toUpperCase();
+      out += `[${l}${u}]`;
+    } else {
+      if ("*?[]{}\\".includes(ch)) {
+        out += "\\" + ch;
+      } else {
+        out += ch;
+      }
+    }
+  }
+  return out;
+}
diff --git a/apps/vscode/src/utils/workspace-path.ts b/apps/vscode/src/utils/workspace-path.ts
new file mode 100644
index 000000000..422ed0add
--- /dev/null
+++ b/apps/vscode/src/utils/workspace-path.ts
@@ -0,0 +1,171 @@
+import { lstatSync, realpathSync } from "node:fs";
+import { lstat, realpath } from "node:fs/promises";
+import * as path from "node:path";
+import * as vscode from "vscode";
+
+import { relativeFsPath } from "./fs-path";
+
+export interface WorkspacePath {
+  readonly uri: vscode.Uri;
+  readonly relativePath: string;
+}
+
+export function workDirUriFromPath(
+  workspaceRootUri: vscode.Uri,
+  workspaceRoot: string,
+  workDir: string,
+): vscode.Uri | undefined {
+  const relativePath = relativeFsPath(workspaceRoot, workDir);
+  if (relativePath === undefined) return undefined;
+  return relativePath === ""
+    ? workspaceRootUri
+    : vscode.Uri.joinPath(workspaceRootUri, ...toPathSegments(relativePath));
+}
+
+export function resolveWorkspacePath(
+  workDirUri: vscode.Uri,
+  input: string,
+  options: { allowRoot?: boolean } = {},
+): WorkspacePath | undefined {
+  const normalized = input.replaceAll("\\", "/");
+  if (
+    path.posix.isAbsolute(normalized) ||
+    path.win32.isAbsolute(input) ||
+    /^[A-Za-z]:/.test(input)
+  ) return undefined;
+
+  const segments = normalized.split("/").filter((segment) => segment !== "" && segment !== ".");
+  if (segments.includes("..")) return undefined;
+  if (segments.length === 0) {
+    return options.allowRoot === true ? { uri: workDirUri, relativePath: "" } : undefined;
+  }
+
+  return {
+    uri: vscode.Uri.joinPath(workDirUri, ...segments),
+    relativePath: segments.join("/"),
+  };
+}
+
+export function relativeWorkspacePath(rootUri: vscode.Uri, candidateUri: vscode.Uri): string | undefined {
+  if (rootUri.scheme !== candidateUri.scheme) return undefined;
+
+  // VS Code exposes native Windows file paths through `fsPath`, while URI
+  // paths always use `/`. Comparing the URI strings makes the same drive or
+  // UNC path look different when only separator or drive/share casing differs.
+  // Native filesystem semantics are the right contract for `file:` URIs.
+  if (rootUri.scheme === "file") {
+    const relativePath = relativeFsPath(rootUri.fsPath, candidateUri.fsPath);
+    return relativePath === "" ? undefined : relativePath;
+  }
+
+  if (rootUri.authority !== candidateUri.authority) return undefined;
+
+  const relativePath = path.posix.relative(normalizeUriPath(rootUri.path), normalizeUriPath(candidateUri.path));
+  if (
+    relativePath === "" ||
+    relativePath === ".." ||
+    relativePath.startsWith("../") ||
+    path.posix.isAbsolute(relativePath)
+  ) {
+    return undefined;
+  }
+  return relativePath;
+}
+
+export async function isWorkspacePathContained(
+  rootUri: vscode.Uri,
+  candidateUri: vscode.Uri,
+  options: { allowMissing?: boolean } = {},
+): Promise<boolean> {
+  if (rootUri.toString() !== candidateUri.toString() && relativeWorkspacePath(rootUri, candidateUri) === undefined) {
+    return false;
+  }
+  if (rootUri.scheme !== "file" || candidateUri.scheme !== "file") return true;
+
+  try {
+    const [realRoot, realCandidate] = await Promise.all([
+      realpath(rootUri.fsPath),
+      options.allowMissing === true ? realExistingPath(candidateUri.fsPath) : realpath(candidateUri.fsPath),
+    ]);
+    return relativeFsPath(realRoot, realCandidate) !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+export function isWorkspacePathContainedSync(
+  rootUri: vscode.Uri,
+  candidateUri: vscode.Uri,
+  options: { allowMissing?: boolean } = {},
+): boolean {
+  if (rootUri.toString() !== candidateUri.toString() && relativeWorkspacePath(rootUri, candidateUri) === undefined) {
+    return false;
+  }
+  if (rootUri.scheme !== "file" || candidateUri.scheme !== "file") return true;
+
+  try {
+    const realRoot = realpathSync(rootUri.fsPath);
+    const realCandidate =
+      options.allowMissing === true
+        ? realExistingPathSync(candidateUri.fsPath)
+        : realpathSync(candidateUri.fsPath);
+    return relativeFsPath(realRoot, realCandidate) !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+async function realExistingPath(candidate: string): Promise<string> {
+  let current = candidate;
+  while (true) {
+    try {
+      return await realpath(current);
+    } catch (error) {
+      if (!isMissingPathError(error)) throw error;
+      let isDanglingSymlink = false;
+      try {
+        isDanglingSymlink = (await lstat(current)).isSymbolicLink();
+      } catch (lstatError) {
+        if (!isMissingPathError(lstatError)) throw lstatError;
+      }
+      if (isDanglingSymlink) throw error;
+      const parent = path.dirname(current);
+      if (parent === current) throw error;
+      current = parent;
+    }
+  }
+}
+
+function realExistingPathSync(candidate: string): string {
+  let current = candidate;
+  while (true) {
+    try {
+      return realpathSync(current);
+    } catch (error) {
+      if (!isMissingPathError(error)) throw error;
+      let isDanglingSymlink = false;
+      try {
+        isDanglingSymlink = lstatSync(current).isSymbolicLink();
+      } catch (lstatError) {
+        if (!isMissingPathError(lstatError)) throw lstatError;
+      }
+      if (isDanglingSymlink) throw error;
+      const parent = path.dirname(current);
+      if (parent === current) throw error;
+      current = parent;
+    }
+  }
+}
+
+function isMissingPathError(error: unknown): boolean {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+function toPathSegments(value: string): string[] {
+  return value.replaceAll("\\", "/").split("/").filter(Boolean);
+}
+
+function normalizeUriPath(value: string): string {
+  const normalized = path.posix.normalize(value);
+  return normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
+}
diff --git a/apps/vscode/test/baseline.manager.test.ts b/apps/vscode/test/baseline.manager.test.ts
new file mode 100644
index 000000000..2554f288c
--- /dev/null
+++ b/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,
+  };
+}
diff --git a/apps/vscode/test/bridge-handler.test.ts b/apps/vscode/test/bridge-handler.test.ts
new file mode 100644
index 000000000..a877efc60
--- /dev/null
+++ b/apps/vscode/test/bridge-handler.test.ts
@@ -0,0 +1,465 @@
+/**
+ * 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 { 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(),
+    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,
+    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.harness };
+});
+
+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.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();
+  await rm(root, { recursive: true, force: true });
+});
+
+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.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("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 } });
+  });
+});
+
+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,
+  };
+}
diff --git a/apps/vscode/test/event-adapter.test.ts b/apps/vscode/test/event-adapter.test.ts
new file mode 100644
index 000000000..e910edfa3
--- /dev/null
+++ b/apps/vscode/test/event-adapter.test.ts
@@ -0,0 +1,526 @@
+/**
+ * Scenario: public Node SDK events are projected into the released VS Code Webview protocol.
+ * Responsibilities: verify legacy shapes, routing state, and terminal metadata one event at a time.
+ * Wiring: the pure adapter and real protocol types are used directly; there are no stubs.
+ * Run: pnpm exec vitest run --config apps/vscode/vitest.config.ts apps/vscode/test/event-adapter.test.ts
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { isPreflightError } from '../shared/errors';
+import {
+  adaptSdkEvent,
+  createEventAdapterState,
+} from '../src/runtime/event-adapter';
+
+describe('event adapter (projects SDK events into the legacy Webview contract)', () => {
+  it('emits the pending input when a main-agent turn starts', () => {
+    const result = adaptSdkEvent(
+      createEventAdapterState(),
+      {
+        type: 'turn.started',
+        sessionId: 'session-1',
+        agentId: 'main',
+        turnId: 7,
+        origin: { kind: 'user' },
+      },
+      { pendingInput: 'Fix the failing test' },
+    );
+
+    expect(result.event).toEqual({
+      type: 'TurnBegin',
+      payload: { user_input: 'Fix the failing test' },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('emits text content when the assistant streams a delta', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'assistant.delta',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      delta: 'Done',
+    });
+
+    expect(result.event).toEqual({
+      type: 'ContentPart',
+      payload: { type: 'text', text: 'Done' },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('emits thinking content when the model streams a thinking delta', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'thinking.delta',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      delta: 'Checking the types',
+    });
+
+    expect(result.event).toEqual({
+      type: 'ContentPart',
+      payload: { type: 'think', think: 'Checking the types' },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('emits a numbered legacy step when an SDK step starts', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'turn.step.started',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      step: 2,
+      stepId: 'step-2',
+    });
+
+    expect(result.event).toEqual({
+      type: 'StepBegin',
+      payload: { n: 2 },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it.each([
+    ['Bash', 'Shell'],
+    ['Read', 'ReadFile'],
+    ['Write', 'WriteFile'],
+    ['Edit', 'StrReplaceFile'],
+    ['TodoList', 'SetTodoList'],
+    ['Glob', 'Glob'],
+  ] as const)('maps the %s tool name to %s when a tool starts', (sdkName, legacyName) => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'tool.call.started',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'tool-1',
+      name: sdkName,
+      args: { path: 'src/index.ts' },
+    });
+
+    expect(result.event).toEqual({
+      type: 'ToolCall',
+      payload: {
+        type: 'function',
+        id: 'tool-1',
+        function: {
+          name: legacyName,
+          arguments: '{"path":"src/index.ts"}',
+        },
+      },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('preserves each tool-call ID when argument deltas are interleaved', () => {
+    const state = createEventAdapterState();
+    const first = adaptSdkEvent(state, {
+      type: 'tool.call.delta',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'tool-a',
+      name: 'Read',
+      argumentsPart: '{"path":"a',
+    });
+    const second = adaptSdkEvent(first.state, {
+      type: 'tool.call.delta',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'tool-b',
+      name: 'Read',
+      argumentsPart: '{"path":"b',
+    });
+
+    expect([first.event, second.event]).toEqual([
+      {
+        type: 'ToolCallPart',
+        payload: { tool_call_id: 'tool-a', arguments_part: '{"path":"a' },
+        _sessionId: 'session-1',
+      },
+      {
+        type: 'ToolCallPart',
+        payload: { tool_call_id: 'tool-b', arguments_part: '{"path":"b' },
+        _sessionId: 'session-1',
+      },
+    ]);
+  });
+
+  it('emits a legacy result when an SDK tool call finishes', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'tool.result',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'tool-1',
+      output: { exitCode: 0 },
+      isError: false,
+    });
+
+    expect(result.event).toEqual({
+      type: 'ToolResult',
+      payload: {
+        tool_call_id: 'tool-1',
+        return_value: {
+          is_error: false,
+          output: '{\n  "exitCode": 0\n}',
+          message: '',
+          display: [],
+        },
+      },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('carries a file diff display from tool start into its matching result', () => {
+    const started = adaptSdkEvent(createEventAdapterState(), {
+      type: 'tool.call.started',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'tool-1',
+      name: 'Edit',
+      args: { path: 'src/index.ts' },
+      display: {
+        kind: 'diff',
+        path: 'src/index.ts',
+        before: 'old',
+        after: 'new',
+      },
+    });
+    const finished = adaptSdkEvent(started.state, {
+      type: 'tool.result',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'tool-1',
+      output: 'updated',
+    });
+
+    expect(finished.event).toMatchObject({
+      type: 'ToolResult',
+      payload: {
+        return_value: {
+          display: [{
+            type: 'diff',
+            path: 'src/index.ts',
+            old_text: 'old',
+            new_text: 'new',
+          }],
+        },
+      },
+    });
+  });
+
+  it('carries a todo display only to the result with the same tool-call ID', () => {
+    const started = adaptSdkEvent(createEventAdapterState(), {
+      type: 'tool.call.started',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'todo-1',
+      name: 'TodoList',
+      args: {},
+      display: {
+        kind: 'todo_list',
+        items: [{ title: 'Ship it', status: 'done' }],
+      },
+    });
+    const unrelated = adaptSdkEvent(started.state, {
+      type: 'tool.result',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'other',
+      output: 'other result',
+    });
+
+    expect(unrelated.event).toMatchObject({
+      payload: { return_value: { display: [] } },
+    });
+    expect(unrelated.state.toolDisplays['todo-1']).toEqual([
+      { type: 'todo', items: [{ title: 'Ship it', status: 'done' }] },
+    ]);
+    const matching = adaptSdkEvent(unrelated.state, {
+      type: 'tool.result',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      toolCallId: 'todo-1',
+      output: 'updated',
+    });
+    expect(matching.event).toMatchObject({
+      payload: {
+        return_value: {
+          display: [{ type: 'todo', items: [{ title: 'Ship it', status: 'done' }] }],
+        },
+      },
+    });
+  });
+
+  it('emits snake-case status fields when agent status changes', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'agent.status.updated',
+      sessionId: 'session-1',
+      agentId: 'main',
+      contextUsage: 0.25,
+      planMode: true,
+      usage: {
+        currentTurn: {
+          inputOther: 10,
+          output: 4,
+          inputCacheRead: 3,
+          inputCacheCreation: 2,
+        },
+      },
+    });
+
+    expect(result.event).toEqual({
+      type: 'StatusUpdate',
+      payload: {
+        context_usage: 0.25,
+        plan_mode: true,
+        token_usage: {
+          input_other: 10,
+          output: 4,
+          input_cache_read: 3,
+          input_cache_creation: 2,
+        },
+      },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('emits only new token usage when SDK status carries cumulative turn usage', () => {
+    const first = adaptSdkEvent(createEventAdapterState(), {
+      type: 'agent.status.updated',
+      sessionId: 'session-1',
+      agentId: 'main',
+      usage: {
+        currentTurn: {
+          inputOther: 10,
+          output: 4,
+          inputCacheRead: 3,
+          inputCacheCreation: 2,
+        },
+      },
+    });
+    const second = adaptSdkEvent(first.state, {
+      type: 'agent.status.updated',
+      sessionId: 'session-1',
+      agentId: 'main',
+      usage: {
+        currentTurn: {
+          inputOther: 14,
+          output: 7,
+          inputCacheRead: 8,
+          inputCacheCreation: 2,
+        },
+      },
+    });
+
+    expect(second.event).toEqual({
+      type: 'StatusUpdate',
+      payload: {
+        token_usage: {
+          input_other: 4,
+          output: 3,
+          input_cache_read: 5,
+          input_cache_creation: 0,
+        },
+      },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('routes a child-agent event through its parent tool after spawn', () => {
+    const spawned = adaptSdkEvent(createEventAdapterState(), {
+      type: 'subagent.spawned',
+      sessionId: 'session-1',
+      agentId: 'main',
+      subagentId: 'child-1',
+      subagentName: 'coder',
+      parentToolCallId: 'agent-call-1',
+      parentAgentId: 'main',
+      runInBackground: false,
+    });
+    const childEvent = adaptSdkEvent(spawned.state, {
+      type: 'assistant.delta',
+      sessionId: 'session-1',
+      agentId: 'child-1',
+      turnId: 1,
+      delta: 'Child result',
+    });
+
+    expect(childEvent.event).toEqual({
+      type: 'SubagentEvent',
+      payload: {
+        parent_tool_call_id: 'agent-call-1',
+        event: {
+          type: 'ContentPart',
+          payload: { type: 'text', text: 'Child result' },
+        },
+      },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('scopes a child tool-call ID when the child starts a tool', () => {
+    const spawned = adaptSdkEvent(createEventAdapterState(), {
+      type: 'subagent.spawned',
+      sessionId: 'session-1',
+      agentId: 'main',
+      subagentId: 'child-1',
+      subagentName: 'coder',
+      parentToolCallId: 'agent-call-1',
+      parentAgentId: 'main',
+      runInBackground: false,
+    });
+    const childEvent = adaptSdkEvent(spawned.state, {
+      type: 'tool.call.started',
+      sessionId: 'session-1',
+      agentId: 'child-1',
+      turnId: 1,
+      toolCallId: 'tool-1',
+      name: 'Read',
+      args: { path: 'README.md' },
+    });
+
+    expect(childEvent.event).toEqual({
+      type: 'SubagentEvent',
+      payload: {
+        parent_tool_call_id: 'agent-call-1',
+        event: {
+          type: 'ToolCall',
+          payload: {
+            type: 'function',
+            id: 'child-1:tool-1',
+            function: {
+              name: 'ReadFile',
+              arguments: '{"path":"README.md"}',
+            },
+          },
+        },
+      },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('emits compaction begin when SDK compaction starts', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'compaction.started',
+      sessionId: 'session-1',
+      agentId: 'main',
+      trigger: 'manual',
+    });
+
+    expect(result.event).toEqual({
+      type: 'CompactionBegin',
+      payload: {},
+      _sessionId: 'session-1',
+    });
+  });
+
+  it.each([
+    {
+      type: 'compaction.completed' as const,
+      result: { summary: 'Summary', compactedCount: 3, tokensBefore: 100, tokensAfter: 30 },
+    },
+    { type: 'compaction.cancelled' as const },
+    { type: 'compaction.blocked' as const, turnId: 7 },
+  ])('emits compaction end when SDK reports $type', (event) => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      ...event,
+      sessionId: 'session-1',
+      agentId: 'main',
+    });
+
+    expect(result.event).toEqual({
+      type: 'CompactionEnd',
+      payload: {},
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('returns terminal metadata when the main turn completes', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'turn.ended',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      reason: 'completed',
+      durationMs: 50,
+    });
+
+    expect(result.event).toBeUndefined();
+    expect(result.terminal).toEqual({
+      key: 'session-1:main:7',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      reason: 'completed',
+      error: undefined,
+    });
+  });
+
+  it('preserves the SDK error when a main turn fails', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'turn.ended',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      reason: 'failed',
+      error: {
+        code: 'internal',
+        message: 'Provider failed',
+        retryable: false,
+      },
+    });
+
+    expect(result.terminal).toEqual({
+      key: 'session-1:main:7',
+      sessionId: 'session-1',
+      agentId: 'main',
+      turnId: 7,
+      reason: 'failed',
+      error: {
+        code: 'internal',
+        message: 'Provider failed',
+        retryable: false,
+      },
+    });
+  });
+
+  it('emits a bridge error with the caller-selected phase when the SDK reports an error', () => {
+    const result = adaptSdkEvent(
+      createEventAdapterState(),
+      {
+        type: 'error',
+        sessionId: 'session-1',
+        agentId: 'main',
+        code: 'internal',
+        message: 'Configuration failed',
+        details: { path: 'config.toml' },
+        retryable: false,
+      },
+      { errorPhase: 'preflight' },
+    );
+
+    expect(result.event).toEqual({
+      type: 'error',
+      code: 'internal',
+      message: 'Configuration failed',
+      detail: '{\n  "path": "config.toml"\n}',
+      phase: 'preflight',
+      _sessionId: 'session-1',
+    });
+  });
+
+  it('classifies a missing Windows Git Bash runtime as a preflight error', () => {
+    expect(isPreflightError('shell.git_bash_not_found')).toBe(true);
+  });
+});
diff --git a/apps/vscode/test/extension-host-smoke.test.ts b/apps/vscode/test/extension-host-smoke.test.ts
new file mode 100644
index 000000000..446774635
--- /dev/null
+++ b/apps/vscode/test/extension-host-smoke.test.ts
@@ -0,0 +1,105 @@
+/**
+ * Scenario: maintainers run the installed-VSIX smoke from a developer machine or CI.
+ * Responsibilities: stable downloads cannot reuse stale caches, and the Extension
+ * Host cannot discover the developer's real legacy Kimi home.
+ * Wiring: real smoke orchestration and filesystem; @vscode/test-electron is the
+ * external process/download boundary.
+ * Run: pnpm --filter kimi-code exec vitest run --config vitest.config.ts test/extension-host-smoke.test.ts
+ */
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const vscodeTest = vi.hoisted(() => ({
+  runTests: vi.fn(),
+  runVSCodeCommand: vi.fn(),
+}));
+
+vi.mock('@vscode/test-electron', () => vscodeTest);
+
+const { runExtensionHostSmoke } = await import('../scripts/extension-host-smoke.mjs');
+const tempDirs: string[] = [];
+
+beforeEach(() => {
+  vscodeTest.runVSCodeCommand.mockResolvedValue({
+    stdout: 'Extension was successfully installed.\n',
+    stderr: '',
+  });
+  vscodeTest.runTests.mockImplementation(async (options) => {
+    await writeFile(
+      options.extensionTestsEnv.KIMI_VSCODE_SMOKE_REPORT,
+      JSON.stringify({ vscode: options.version === 'stable' ? '1.127.0' : options.version }),
+      'utf8',
+    );
+  });
+});
+
+afterEach(async () => {
+  vi.clearAllMocks();
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe('installed VSIX Extension Host smoke', () => {
+  it('uses a fresh disposable download cache for every stable run', async () => {
+    const fixture = await makeFixture();
+
+    const first = await runExtensionHostSmoke({
+      version: 'stable',
+      vsixPath: fixture.vsixPath,
+      cachePath: fixture.cachePath,
+    });
+    const second = await runExtensionHostSmoke({
+      version: 'stable',
+      vsixPath: fixture.vsixPath,
+      cachePath: fixture.cachePath,
+    });
+
+    expect(first.cachePath).not.toBe(second.cachePath);
+    expect(first.vscodeVersion).toBe('1.127.0');
+    expect(second.vscodeVersion).toBe('1.127.0');
+  });
+
+  it('gives the harness separate Kimi and operating-system homes before activation', async () => {
+    const fixture = await makeFixture();
+
+    await runExtensionHostSmoke({
+      version: '1.100.0',
+      vsixPath: fixture.vsixPath,
+      cachePath: fixture.cachePath,
+    });
+
+    const options = vscodeTest.runTests.mock.calls[0]?.[0];
+    const env = options.extensionTestsEnv;
+    expect(env.KIMI_CODE_HOME).not.toBe(env.KIMI_VSCODE_SMOKE_OS_HOME);
+    expect(env.KIMI_VSCODE_SMOKE_OS_HOME).toContain('os-home');
+  });
+
+  it('rejects a cached host that does not match an exact requested version', async () => {
+    const fixture = await makeFixture();
+    vscodeTest.runTests.mockImplementationOnce(async (options) => {
+      await writeFile(
+        options.extensionTestsEnv.KIMI_VSCODE_SMOKE_REPORT,
+        JSON.stringify({ vscode: '1.99.3' }),
+        'utf8',
+      );
+    });
+
+    await expect(runExtensionHostSmoke({
+      version: '1.100.0',
+      vsixPath: fixture.vsixPath,
+      cachePath: fixture.cachePath,
+    })).rejects.toThrow('Extension Host ran VS Code 1.99.3, expected requested version 1.100.0');
+  });
+});
+
+async function makeFixture(): Promise<{ vsixPath: string; cachePath: string }> {
+  const root = await mkdtemp(join(tmpdir(), 'kimi-extension-host-smoke-'));
+  tempDirs.push(root);
+  const cachePath = join(root, 'cache');
+  const vsixPath = join(root, 'kimi-code-test.vsix');
+  await mkdir(cachePath, { recursive: true });
+  await writeFile(vsixPath, 'fixture', 'utf8');
+  return { vsixPath, cachePath };
+}
diff --git a/apps/vscode/test/extension-host/index.cjs b/apps/vscode/test/extension-host/index.cjs
new file mode 100644
index 000000000..2605cdb1b
--- /dev/null
+++ b/apps/vscode/test/extension-host/index.cjs
@@ -0,0 +1,109 @@
+const assert = require("node:assert/strict");
+const { readFile, writeFile } = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const vscode = require("vscode");
+
+const EXTENSION_ID = "moonshot-ai.kimi-code";
+const EXPECTED_COMMANDS = [
+  "kimi.clearAllState",
+  "kimi.focusInput",
+  "kimi.insertMention",
+  "kimi.logout",
+  "kimi.migrateLegacyData",
+  "kimi.newConversation",
+  "kimi.openInSideBar",
+  "kimi.openInTab",
+  "kimi.resetKimi",
+  "kimi.showLogs",
+];
+
+exports.run = async function run() {
+  const isolatedHome = process.env.KIMI_VSCODE_SMOKE_OS_HOME;
+  assert.ok(isolatedHome, "isolated OS home must be provided");
+  process.env.HOME = isolatedHome;
+  process.env.USERPROFILE = isolatedHome;
+  const root = path.parse(isolatedHome).root;
+  process.env.HOMEDRIVE = process.platform === "win32" ? root.replace(/[\\/]+$/, "") : root;
+  process.env.HOMEPATH = process.platform === "win32"
+    ? `${path.sep}${isolatedHome.slice(root.length)}`
+    : isolatedHome;
+
+  const extension = vscode.extensions.getExtension(EXTENSION_ID);
+  assert.ok(extension, `${EXTENSION_ID} is not installed in the isolated Extension Host`);
+  const sourceManifest = JSON.parse(
+    await readFile(path.join(__dirname, "..", "..", "package.json"), "utf8"),
+  );
+  assert.equal(extension.packageJSON.version, sourceManifest.version);
+  assert.equal(extension.packageJSON.main, "./dist/extension.js");
+  assert.ok(process.env.KIMI_CODE_HOME, "KIMI_CODE_HOME must point at the isolated test home");
+  assert.equal(process.env.HOME, isolatedHome);
+  assert.equal(process.env.USERPROFILE, isolatedHome);
+  assert.equal(os.homedir(), isolatedHome);
+
+  await extension.activate();
+  assert.equal(extension.isActive, true, "extension activation did not complete");
+
+  const commands = new Set(await vscode.commands.getCommands(true));
+  for (const command of EXPECTED_COMMANDS) {
+    assert.ok(commands.has(command), `missing registered command: ${command}`);
+  }
+
+  const config = vscode.workspace.getConfiguration("kimi");
+  assert.equal(config.get("autosave"), true);
+  assert.equal(config.get("executablePath"), undefined, "removed Python CLI setting is still contributed");
+  assert.equal(config.get("environmentVariables"), undefined, "removed global CLI env setting is still contributed");
+
+  await vscode.commands.executeCommand("kimi.openInTab");
+  await waitFor(() => {
+    return vscode.window.tabGroups.all.some((group) =>
+      group.tabs.some((tab) =>
+        tab.input instanceof vscode.TabInputWebview && isKimiPanelViewType(tab.input.viewType)));
+  }, 5_000, () => `Kimi Webview tab did not open; tabs=${describeTabs()}`);
+
+  await vscode.commands.executeCommand("kimi.showLogs");
+  await vscode.commands.executeCommand("kimi.resetKimi");
+  await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
+
+  console.log(
+    JSON.stringify({
+      extension: EXTENSION_ID,
+      version: extension.packageJSON.version,
+      vscode: vscode.version,
+      remoteName: vscode.env.remoteName ?? null,
+      commands: EXPECTED_COMMANDS.length,
+      webview: "opened",
+    }),
+  );
+  assert.ok(process.env.KIMI_VSCODE_SMOKE_REPORT, "Extension Host report path must be provided");
+  await writeFile(
+    process.env.KIMI_VSCODE_SMOKE_REPORT,
+    JSON.stringify({ vscode: vscode.version }),
+    "utf8",
+  );
+};
+
+async function waitFor(predicate, timeoutMs, message) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error(typeof message === "function" ? message() : message);
+}
+
+function describeTabs() {
+  return JSON.stringify(vscode.window.tabGroups.all.map((group) =>
+    group.tabs.map((tab) => ({
+      label: tab.label,
+      input: tab.input?.constructor?.name,
+      viewType: tab.input instanceof vscode.TabInputWebview ? tab.input.viewType : undefined,
+      active: tab.isActive,
+    }))));
+}
+
+function isKimiPanelViewType(viewType) {
+  // VS Code 1.100 exposes the internal `mainThreadWebview-` prefix here;
+  // newer hosts expose the extension's original view type.
+  return viewType === "kimiPanel" || viewType.endsWith("-kimiPanel");
+}
diff --git a/apps/vscode/test/fork-turn-index.test.ts b/apps/vscode/test/fork-turn-index.test.ts
new file mode 100644
index 000000000..7bfa5bb39
--- /dev/null
+++ b/apps/vscode/test/fork-turn-index.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+
+import { getForkTurnIndex } from "../shared/fork-turn-index";
+
+interface TestMessage {
+  readonly id: string;
+  readonly role: "user" | "assistant";
+  readonly content: string;
+  readonly timestamp: number;
+  readonly forkable?: boolean;
+  readonly steps?: readonly {
+    readonly n: number;
+    readonly items: readonly { readonly type: string; readonly content?: string }[];
+  }[];
+}
+
+function message(
+  role: TestMessage["role"],
+  options: Partial<TestMessage> = {},
+): TestMessage {
+  return {
+    id: crypto.randomUUID(),
+    role,
+    content: "",
+    timestamp: 1,
+    ...options,
+  };
+}
+
+describe("fork turn index", () => {
+  it("counts a steer embedded in the current assistant response", () => {
+    const messages = [
+      message("user"),
+      message("assistant", {
+        steps: [{ n: 1, items: [{ type: "steer", content: "also fix tests" }] }],
+      }),
+    ];
+
+    expect(getForkTurnIndex(messages, 1)).toBe(1);
+  });
+
+  it("carries prior steer turns into later assistant responses", () => {
+    const messages = [
+      message("user"),
+      message("assistant", {
+        steps: [{ n: 1, items: [{ type: "steer", content: "also fix tests" }] }],
+      }),
+      message("user"),
+      message("assistant"),
+    ];
+
+    expect(getForkTurnIndex(messages, 3)).toBe(2);
+  });
+
+  it("does not count or offer forks for host-only command output", () => {
+    const messages = [
+      message("user", { content: "/compact", forkable: false }),
+      message("assistant", { content: "The context has been compacted.", forkable: false }),
+      message("user"),
+      message("assistant"),
+    ];
+
+    expect(getForkTurnIndex(messages, 1)).toBeUndefined();
+    expect(getForkTurnIndex(messages, 3)).toBe(0);
+  });
+});
diff --git a/apps/vscode/test/kimi-harness.integration.test.ts b/apps/vscode/test/kimi-harness.integration.test.ts
new file mode 100644
index 000000000..9798fa39b
--- /dev/null
+++ b/apps/vscode/test/kimi-harness.integration.test.ts
@@ -0,0 +1,1282 @@
+/**
+ * Scenario: the VS Code host and another Node SDK client share one in-process Kimi home.
+ * Responsibilities: outbound host identity, config/session interoperability, MCP credential/edit compatibility, and terminal provider failures.
+ * Wiring: KimiRuntime, KimiHarness, core, storage, and HTTP provider adapter are real; only the remote provider is local.
+ * Run: pnpm --filter kimi-code exec vitest run test/kimi-harness.integration.test.ts
+ */
+
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  createKimiHarness,
+  type KimiHarness,
+} from "@moonshot-ai/kimi-code-sdk";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("vscode", () => ({
+  Uri: { file: (path: string) => ({ fsPath: path }) },
+  window: {
+    showInformationMessage: async () => undefined,
+    showWarningMessage: async () => undefined,
+    showTextDocument: async () => undefined,
+  },
+}));
+
+import {
+  createFakeProviderHarness,
+  type FakeProviderHarness,
+} from "../../../packages/kosong/test/e2e/fake-provider-harness";
+import { Events, Methods } from "../shared/bridge";
+import {
+  MCP_SECRET_MASK,
+  type MCPServerConfig,
+  type UpdateMCPServerRequest,
+} from "../shared/legacy-sdk";
+import { configHandlers } from "../src/handlers/config.handler";
+import { mcpHandlers } from "../src/handlers/mcp.handler";
+import { parseHostSlashCommand, runHostSlashCommand } from "../src/handlers/slash-command";
+import type { HandlerContext } from "../src/handlers/types";
+import { KimiRuntime } from "../src/runtime/kimi-runtime";
+import type { SessionRuntime } from "../src/runtime/session-runtime";
+
+const MODEL_ALIAS = "vscode-test";
+const PROVIDER_TOKEN = "sk-vscode-boundary-secret";
+
+interface BroadcastRecord {
+  readonly event: string;
+  readonly data: unknown;
+  readonly webviewId?: string;
+}
+
+interface LogRecord {
+  readonly message: string;
+  readonly error?: unknown;
+}
+
+interface RuntimeRig {
+  readonly homeDir: string;
+  readonly workDir: string;
+  readonly provider: FakeProviderHarness;
+  readonly runtime: KimiRuntime;
+  readonly broadcasts: BroadcastRecord[];
+  readonly logs: LogRecord[];
+  readonly version: string;
+  closeProvider(): Promise<void>;
+}
+
+interface McpHandlerRig {
+  readonly harness: KimiHarness;
+  readonly broadcasts: BroadcastRecord[];
+  readonly logs: LogRecord[];
+}
+
+const cleanups: Array<() => Promise<void>> = [];
+
+afterEach(async () => {
+  while (cleanups.length > 0) {
+    await cleanups.pop()?.();
+  }
+});
+
+async function createRuntimeRig(): Promise<RuntimeRig> {
+  const rootDir = await mkdtemp(join(tmpdir(), "kimi-vscode-harness-"));
+  const homeDir = join(rootDir, "home");
+  const workDir = join(rootDir, "workspace");
+  await Promise.all([mkdir(homeDir), mkdir(workDir)]);
+
+  const provider = await createFakeProviderHarness();
+  let providerOpen = true;
+  const closeProvider = async (): Promise<void> => {
+    if (!providerOpen) return;
+    providerOpen = false;
+    await provider.close();
+  };
+
+  await writeProviderConfig(homeDir, `${provider.baseUrl}/v1`);
+  const version = await readExtensionVersion();
+  const broadcasts: BroadcastRecord[] = [];
+  const logs: LogRecord[] = [];
+  const runtime = new KimiRuntime({
+    version,
+    homeDir,
+    broadcast: (event: string, data: unknown, webviewId?: string) => {
+      broadcasts.push({ event, data, webviewId });
+    },
+    captureBaseline: () => undefined,
+    log: (message, error) => {
+      logs.push({ message, error });
+    },
+  });
+
+  cleanups.push(async () => {
+    try {
+      await runtime.dispose();
+    } finally {
+      try {
+        await closeProvider();
+      } finally {
+        await rm(rootDir, { recursive: true, force: true });
+      }
+    }
+  });
+
+  return {
+    homeDir,
+    workDir,
+    provider,
+    runtime,
+    broadcasts,
+    logs,
+    closeProvider,
+    version,
+  };
+}
+
+async function createPlainHarness(homeDir: string): Promise<KimiHarness> {
+  const harness = createKimiHarness({
+    homeDir,
+    identity: { userAgentProduct: "kimi-code-cli", version: "test" },
+  });
+  cleanups.push(() => harness.close());
+  return harness;
+}
+
+async function createMcpHandlerRig(): Promise<McpHandlerRig> {
+  const homeDir = await mkdtemp(join(tmpdir(), "kimi-vscode-mcp-handler-"));
+  cleanups.push(() => rm(homeDir, { recursive: true, force: true }));
+  const harness = await createPlainHarness(homeDir);
+  const broadcasts: BroadcastRecord[] = [];
+  const logs: LogRecord[] = [];
+  return { harness, broadcasts, logs };
+}
+
+async function updateMcpServer(
+  rig: McpHandlerRig,
+  request: UpdateMCPServerRequest | MCPServerConfig,
+): Promise<MCPServerConfig[]> {
+  return mcpHandlers[Methods.UpdateMCPServer]!(request, mcpHandlerContext(rig)) as Promise<MCPServerConfig[]>;
+}
+
+async function getMcpServers(rig: McpHandlerRig): Promise<MCPServerConfig[]> {
+  return mcpHandlers[Methods.GetMCPServers]!(undefined, mcpHandlerContext(rig)) as Promise<MCPServerConfig[]>;
+}
+
+function mcpHandlerContext(rig: McpHandlerRig): HandlerContext {
+  return {
+    harness: rig.harness,
+    broadcast: (event: string, data: unknown, webviewId?: string) => {
+      rig.broadcasts.push({ event, data, webviewId });
+    },
+    logError: (message: string, error: unknown) => {
+      rig.logs.push({ message, error });
+    },
+  } as unknown as HandlerContext;
+}
+
+async function readExtensionVersion(): Promise<string> {
+  const text = await readFile(new URL("../package.json", import.meta.url), "utf8");
+  const parsed = JSON.parse(text) as { version?: unknown };
+  if (typeof parsed.version !== "string") {
+    throw new TypeError("VS Code package version is missing");
+  }
+  return parsed.version;
+}
+
+async function writeProviderConfig(homeDir: string, baseUrl: string): Promise<void> {
+  await writeFile(
+    join(homeDir, "config.toml"),
+    `default_model = "${MODEL_ALIAS}"
+
+[providers.local]
+type = "kimi"
+base_url = "${baseUrl}"
+api_key = "${PROVIDER_TOKEN}"
+
+[models."${MODEL_ALIAS}"]
+provider = "local"
+model = "mock-model"
+max_context_size = 128000
+
+[loop_control]
+max_retries_per_step = 1
+`,
+    "utf8",
+  );
+}
+
+function routeSuccessfulPrompt(provider: FakeProviderHarness): void {
+  provider.route("POST", "/v1/chat/completions", async (_request, reply) => {
+    await reply.sseJson(200, [
+      completionChunk({ content: "mock response" }),
+      completionChunk({}, "stop"),
+    ]);
+  });
+}
+
+function routeBadRequest(provider: FakeProviderHarness): void {
+  provider.route("POST", "/v1/chat/completions", async (_request, reply) => {
+    await reply.json(400, {
+      error: {
+        message: "mock request rejected",
+        type: "invalid_request_error",
+      },
+    });
+  });
+}
+
+function routeBlockedPrompt(provider: FakeProviderHarness): {
+  readonly started: Promise<void>;
+  readonly release: () => void;
+} {
+  let markStarted!: () => void;
+  let release!: () => void;
+  const started = new Promise<void>((resolve) => {
+    markStarted = resolve;
+  });
+  const blocked = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  provider.route("POST", "/v1/chat/completions", async (_request, reply) => {
+    markStarted();
+    await blocked;
+    await reply.sseJson(200, [completionChunk({ content: "late response" }), completionChunk({}, "stop")]);
+  });
+  return { started, release };
+}
+
+function completionChunk(
+  delta: Record<string, unknown>,
+  finishReason: string | null = null,
+): Record<string, unknown> {
+  return {
+    id: "chatcmpl-vscode-test",
+    object: "chat.completion.chunk",
+    created: 1,
+    model: "mock-model",
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  };
+}
+
+async function openRuntimeSession(rig: RuntimeRig, sessionId?: string, yoloMode = false) {
+  return rig.runtime.openSession({
+    webviewId: "view-1",
+    workDir: rig.workDir,
+    sessionId,
+    model: MODEL_ALIAS,
+    effort: "off",
+    yoloMode,
+  });
+}
+
+function streamEvents(broadcasts: readonly BroadcastRecord[]): unknown[] {
+  return broadcasts
+    .filter((record) => record.event === Events.StreamEvent)
+    .map((record) => record.data);
+}
+
+function diagnosticText(rig: RuntimeRig): string {
+  const logText = rig.logs
+    .map(({ message, error }) => {
+      const detail = error instanceof Error ? error.message : JSON.stringify(error ?? "");
+      return `${message} ${detail}`;
+    })
+    .join("\n");
+  return `${logText}\n${JSON.stringify(streamEvents(rig.broadcasts))}`;
+}
+
+async function runSlash(
+  runtime: SessionRuntime,
+  raw: string,
+  ctx = {} as HandlerContext,
+): Promise<boolean> {
+  const command = parseHostSlashCommand(raw);
+  if (command === undefined) throw new Error(`Expected host slash command: ${raw}`);
+  return runHostSlashCommand(runtime, command, ctx);
+}
+
+describe("VS Code Kimi harness integration (shares one in-process SDK home)", () => {
+  it("only intercepts released slash commands and user-invoked skills", () => {
+    expect(parseHostSlashCommand("/plan on")).toEqual({ name: "plan", args: "on", raw: "/plan on" });
+    expect(parseHostSlashCommand(" /skill:review carefully ")).toEqual({
+      name: "skill:review",
+      args: "carefully",
+      raw: "/skill:review carefully",
+    });
+    expect(parseHostSlashCommand("/not-a-host-command")).toBeUndefined();
+    expect(parseHostSlashCommand([{ type: "text", text: "/clear" }])).toBeUndefined();
+  });
+
+  it("combines the released slash commands with user-activatable workspace skills", async () => {
+    const commands = await configHandlers[Methods.GetSlashCommands]!(undefined, {
+      workDir: "/workspace",
+      harness: {
+        listWorkspaceSkills: async () => [
+          { name: "review", description: "Review changes", path: "/skills/review", source: "user", type: "prompt" },
+          { name: "reference-only", description: "Reference", path: "/skills/ref", source: "user", type: "reference" },
+        ],
+      },
+      logError: () => undefined,
+    } as unknown as HandlerContext);
+
+    expect((commands as Array<{ name: string }>).map((command) => command.name)).toEqual([
+      "init",
+      "compact",
+      "clear",
+      "yolo",
+      "afk",
+      "plan",
+      "add-dir",
+      "export",
+      "import",
+      "skill:review",
+    ]);
+  });
+
+  it("sends the package version in User-Agent when VS Code prompts the provider", async () => {
+    const rig = await createRuntimeRig();
+    routeSuccessfulPrompt(rig.provider);
+    const session = await openRuntimeSession(rig);
+
+    await expect(session.prompt("hello")).resolves.toEqual({ status: "finished" });
+
+    expect(rig.provider.requests[0]?.headers["user-agent"]).toBe(
+      `kimi-code-vscode/${rig.version}`,
+    );
+  });
+
+  it("reloads sequential config writes from either harness sharing one home", async () => {
+    const rig = await createRuntimeRig();
+    const plain = await createPlainHarness(rig.homeDir);
+
+    await plain.setConfig({ thinking: { enabled: true, effort: "high" } });
+    await expect(rig.runtime.harness.getConfig({ reload: true })).resolves.toMatchObject({
+      thinking: { enabled: true, effort: "high" },
+    });
+
+    await rig.runtime.harness.setConfig({ yolo: true });
+    await expect(plain.getConfig({ reload: true })).resolves.toMatchObject({ yolo: true });
+  });
+
+  it("masks credential-valued MCP fields at the Webview list boundary while leaving ordinary values visible", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "remote",
+      transport: "http",
+      url: "https://example.test/mcp",
+      headers: {
+        Authorization: "Bearer header-secret",
+        Cookie: "session=cookie-secret",
+        "X-API-Key": "api-key-secret",
+        "X-Workspace": "workspace-visible",
+      },
+    });
+    await rig.harness.addMcpServer({
+      name: "local",
+      transport: "stdio",
+      command: "example-mcp",
+      env: {
+        SERVICE_TOKEN: "env-secret",
+        DEBUG: "debug-visible",
+      },
+    });
+
+    const servers = await getMcpServers(rig);
+
+    expect(servers).toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://example.test/mcp",
+        headers: {
+          Authorization: MCP_SECRET_MASK,
+          Cookie: MCP_SECRET_MASK,
+          "X-API-Key": MCP_SECRET_MASK,
+          "X-Workspace": "workspace-visible",
+        },
+      },
+      {
+        name: "local",
+        transport: "stdio",
+        command: "example-mcp",
+        env: {
+          SERVICE_TOKEN: MCP_SECRET_MASK,
+          DEBUG: "debug-visible",
+        },
+      },
+    ]);
+    expect(JSON.stringify(servers)).not.toMatch(/header-secret|cookie-secret|api-key-secret|env-secret/);
+  });
+
+  it("logs a failed MCP test without returning credential values to the Webview", async () => {
+    const rig = await createMcpHandlerRig();
+    vi.spyOn(rig.harness, "testMcpServer").mockResolvedValue({
+      success: false,
+      output: [
+        "spawn missing-mcp ENOENT",
+        "Authorization: Bearer header-secret",
+        "TOKEN=env-secret",
+        "Cookie: session=cookie-secret",
+      ].join("\n"),
+    });
+
+    const result = await mcpHandlers[Methods.TestMCP]!(
+      { name: "broken" },
+      mcpHandlerContext(rig),
+    );
+
+    expect(result).toMatchObject({ success: false, output: expect.stringContaining("ENOENT") });
+    expect(JSON.stringify(result)).not.toMatch(/header-secret|env-secret|cookie-secret/);
+    expect(rig.logs).toHaveLength(1);
+    expect(rig.logs[0]?.message).toBe('MCP server test failed for "broken"');
+    expect(rig.logs[0]?.error).toBeInstanceOf(Error);
+    expect((rig.logs[0]?.error as Error).message).toContain("ENOENT");
+    expect((rig.logs[0]?.error as Error).message).not.toMatch(/header-secret|env-secret|cookie-secret/);
+  });
+
+  it("preserves an unchanged masked HTTP credential without exposing it in the response or broadcast", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "remote",
+      transport: "http",
+      url: "https://old.example.test/mcp",
+      headers: {
+        Authorization: "Bearer stored-header-secret",
+        "X-Workspace": "old-workspace",
+      },
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "remote",
+      server: {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: {
+          Authorization: MCP_SECRET_MASK,
+          "X-Workspace": "new-workspace",
+        },
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: {
+          Authorization: MCP_SECRET_MASK,
+          "X-Workspace": "new-workspace",
+        },
+      },
+    ]);
+    expect(rig.broadcasts).toEqual([
+      { event: Events.MCPServersChanged, data: servers, webviewId: undefined },
+    ]);
+    await expect(rig.harness.listMcpServers()).resolves.toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: {
+          Authorization: "Bearer stored-header-secret",
+          "X-Workspace": "new-workspace",
+        },
+      },
+    ]);
+  });
+
+  it("preserves an unchanged masked stdio credential in the host configuration", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "local",
+      transport: "stdio",
+      command: "old-command",
+      env: {
+        SERVICE_TOKEN: "stored-env-secret",
+        DEBUG: "old-debug",
+      },
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "local",
+      server: {
+        name: "local",
+        transport: "stdio",
+        command: "new-command",
+        env: {
+          SERVICE_TOKEN: MCP_SECRET_MASK,
+          DEBUG: "new-debug",
+        },
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "local",
+        transport: "stdio",
+        command: "new-command",
+        env: {
+          SERVICE_TOKEN: MCP_SECRET_MASK,
+          DEBUG: "new-debug",
+        },
+      },
+    ]);
+    await expect(rig.harness.listMcpServers()).resolves.toEqual([
+      {
+        name: "local",
+        transport: "stdio",
+        command: "new-command",
+        env: {
+          SERVICE_TOKEN: "stored-env-secret",
+          DEBUG: "new-debug",
+        },
+      },
+    ]);
+  });
+
+  it("replaces an HTTP credential when the Webview submits a new literal value", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "remote",
+      transport: "http",
+      url: "https://example.test/mcp",
+      headers: { Authorization: "Bearer old-secret" },
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "remote",
+      server: {
+        name: "remote",
+        transport: "http",
+        url: "https://example.test/mcp",
+        headers: { Authorization: "Bearer new-secret" },
+      },
+    });
+
+    expect(servers[0]?.headers).toEqual({ Authorization: MCP_SECRET_MASK });
+    await expect(rig.harness.listMcpServers()).resolves.toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://example.test/mcp",
+        headers: { Authorization: "Bearer new-secret" },
+      },
+    ]);
+  });
+
+  it("replaces a stdio credential when the Webview submits a new literal value", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "local",
+      transport: "stdio",
+      command: "example-mcp",
+      env: { SERVICE_TOKEN: "old-secret" },
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "local",
+      server: {
+        name: "local",
+        transport: "stdio",
+        command: "example-mcp",
+        env: { SERVICE_TOKEN: "new-secret" },
+      },
+    });
+
+    expect(servers[0]?.env).toEqual({ SERVICE_TOKEN: MCP_SECRET_MASK });
+    await expect(rig.harness.listMcpServers()).resolves.toEqual([
+      {
+        name: "local",
+        transport: "stdio",
+        command: "example-mcp",
+        env: { SERVICE_TOKEN: "new-secret" },
+      },
+    ]);
+  });
+
+  it("preserves existing HTTP MCP headers when the released form updates the server", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "remote",
+      transport: "http",
+      url: "https://old.example.test/mcp",
+      headers: { "X-Workspace": "kept" },
+      bearerTokenEnvVar: "REMOTE_MCP_TOKEN",
+    });
+
+    await updateMcpServer(rig, {
+      name: "remote",
+      transport: "http",
+      url: "https://new.example.test/mcp",
+      auth: "oauth",
+    });
+
+    await expect(rig.harness.listMcpServers()).resolves.toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: { "X-Workspace": "kept" },
+        bearerTokenEnvVar: "REMOTE_MCP_TOKEN",
+        auth: "oauth",
+      },
+    ]);
+  });
+
+  it("removes stored stdio arguments when the structured edit omits them", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "local",
+      transport: "stdio",
+      command: "old-command",
+      args: ["--old"],
+      env: { KEEP: "yes" },
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "local",
+      server: {
+        name: "local",
+        transport: "stdio",
+        command: "new-command",
+        env: { KEEP: "yes" },
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "local",
+        transport: "stdio",
+        command: "new-command",
+        env: { KEEP: "yes" },
+      },
+    ]);
+  });
+
+  it("removes stored stdio environment variables when the structured edit omits them", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "local",
+      transport: "stdio",
+      command: "old-command",
+      args: ["--keep"],
+      env: { REMOVE_TOKEN: "stored-secret" },
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "local",
+      server: {
+        name: "local",
+        transport: "stdio",
+        command: "new-command",
+        args: ["--keep"],
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "local",
+        transport: "stdio",
+        command: "new-command",
+        args: ["--keep"],
+      },
+    ]);
+  });
+
+  it("removes stored HTTP headers when the structured edit omits them", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "remote",
+      transport: "http",
+      url: "https://old.example.test/mcp",
+      headers: { Authorization: "Bearer stored-secret" },
+      bearerTokenEnvVar: "KEEP_TOKEN",
+      auth: "oauth",
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "remote",
+      server: {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        bearerTokenEnvVar: "KEEP_TOKEN",
+        auth: "oauth",
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        bearerTokenEnvVar: "KEEP_TOKEN",
+        auth: "oauth",
+      },
+    ]);
+  });
+
+  it("removes the stored bearer token reference when the structured edit omits it", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "remote",
+      transport: "http",
+      url: "https://old.example.test/mcp",
+      headers: { "X-Keep": "yes" },
+      bearerTokenEnvVar: "REMOVE_TOKEN",
+      auth: "oauth",
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "remote",
+      server: {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: { "X-Keep": "yes" },
+        auth: "oauth",
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: { "X-Keep": "yes" },
+        auth: "oauth",
+      },
+    ]);
+  });
+
+  it("switches an OAuth HTTP server back to ordinary HTTP when auth is omitted", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "remote",
+      transport: "http",
+      url: "https://old.example.test/mcp",
+      headers: { "X-Keep": "yes" },
+      bearerTokenEnvVar: "KEEP_TOKEN",
+      auth: "oauth",
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "remote",
+      server: {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: { "X-Keep": "yes" },
+        bearerTokenEnvVar: "KEEP_TOKEN",
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "remote",
+        transport: "http",
+        url: "https://new.example.test/mcp",
+        headers: { "X-Keep": "yes" },
+        bearerTokenEnvVar: "KEEP_TOKEN",
+      },
+    ]);
+  });
+
+  it("moves an edited server from its original name to the new name", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "old-name",
+      transport: "stdio",
+      command: "old-command",
+      env: { API_TOKEN: "stored-secret" },
+      enabled: false,
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "old-name",
+      server: {
+        name: "new-name",
+        transport: "stdio",
+        command: "new-command",
+        env: { API_TOKEN: MCP_SECRET_MASK },
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "new-name",
+        transport: "stdio",
+        command: "new-command",
+        env: { API_TOKEN: MCP_SECRET_MASK },
+        enabled: false,
+      },
+    ]);
+    await expect(rig.harness.listMcpServers()).resolves.toEqual([
+      {
+        name: "new-name",
+        transport: "stdio",
+        command: "new-command",
+        env: { API_TOKEN: "stored-secret" },
+        enabled: false,
+      },
+    ]);
+  });
+
+  it("preserves a Windows executable path containing spaces through a structured edit", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "windows",
+      transport: "stdio",
+      command: "old-command",
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "windows",
+      server: {
+        name: "windows",
+        transport: "stdio",
+        command: "C:\\Program Files\\Example MCP\\server.exe",
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "windows",
+        transport: "stdio",
+        command: "C:\\Program Files\\Example MCP\\server.exe",
+      },
+    ]);
+  });
+
+  it("preserves Windows arguments containing spaces through a structured edit", async () => {
+    const rig = await createMcpHandlerRig();
+    await rig.harness.addMcpServer({
+      name: "windows",
+      transport: "stdio",
+      command: "node.exe",
+    });
+
+    const servers = await updateMcpServer(rig, {
+      originalName: "windows",
+      server: {
+        name: "windows",
+        transport: "stdio",
+        command: "node.exe",
+        args: ["--config", "C:\\Users\\Example User\\mcp config.json", "literal value"],
+      },
+    });
+
+    expect(servers).toEqual([
+      {
+        name: "windows",
+        transport: "stdio",
+        command: "node.exe",
+        args: ["--config", "C:\\Users\\Example User\\mcp config.json", "literal value"],
+      },
+    ]);
+  });
+
+  it("lists a closed VS Code session from a plain harness", async () => {
+    const rig = await createRuntimeRig();
+    const vscodeSession = await openRuntimeSession(rig);
+    await rig.runtime.detachView("view-1");
+    const plain = await createPlainHarness(rig.homeDir);
+
+    const listed = await plain.listSessions({ workDir: rig.workDir });
+
+    expect(listed).toContainEqual(expect.objectContaining({ id: vscodeSession.id }));
+  });
+
+  it("resumes a closed VS Code session from a plain harness", async () => {
+    const rig = await createRuntimeRig();
+    const vscodeSession = await openRuntimeSession(rig);
+    await rig.runtime.detachView("view-1");
+    const plain = await createPlainHarness(rig.homeDir);
+
+    const resumed = await plain.resumeSession({ id: vscodeSession.id });
+
+    expect(resumed.id).toBe(vscodeSession.id);
+  });
+
+  it("lists a closed plain-harness session from VS Code", async () => {
+    const rig = await createRuntimeRig();
+    const plain = await createPlainHarness(rig.homeDir);
+    const plainSession = await plain.createSession({
+      id: "ses_plain_to_vscode",
+      workDir: rig.workDir,
+      model: MODEL_ALIAS,
+    });
+    await plainSession.close();
+
+    const listed = await rig.runtime.harness.listSessions({ workDir: rig.workDir });
+
+    expect(listed).toContainEqual(expect.objectContaining({ id: plainSession.id }));
+  });
+
+  it("resumes a closed plain-harness session from VS Code", async () => {
+    const rig = await createRuntimeRig();
+    const plain = await createPlainHarness(rig.homeDir);
+    const plainSession = await plain.createSession({
+      id: "ses_plain_to_vscode",
+      workDir: rig.workDir,
+      model: MODEL_ALIAS,
+    });
+    await plainSession.close();
+
+    const resumed = await openRuntimeSession(rig, plainSession.id);
+
+    expect(resumed.id).toBe(plainSession.id);
+  });
+
+  it("backfills approval flags for a session migrated before the metadata field existed", async () => {
+    const rig = await createRuntimeRig();
+    const legacySessionDir = join(rig.workDir, "legacy-session");
+    await mkdir(legacySessionDir);
+    await writeFile(
+      join(legacySessionDir, "state.json"),
+      JSON.stringify({ approval: { yolo: false, afk: true } }),
+      "utf8",
+    );
+    const plain = await createPlainHarness(rig.homeDir);
+    const migrated = await plain.createSession({
+      id: "ses_preexisting_migration",
+      workDir: rig.workDir,
+      metadata: { kimi_cli_source_path: legacySessionDir },
+    });
+    await migrated.close();
+
+    const resumed = await openRuntimeSession(rig, migrated.id);
+
+    expect(resumed.legacyApprovalFlags).toEqual({ yolo: false, afk: true });
+    expect(resumed.summary?.metadata?.["vscode_legacy_approval"]).toEqual({
+      yolo: false,
+      afk: true,
+    });
+  });
+
+  it("reports corrupt legacy approval state and still opens the migrated session", async () => {
+    const rig = await createRuntimeRig();
+    const legacySessionDir = join(rig.workDir, "corrupt-legacy-session");
+    await mkdir(legacySessionDir);
+    await writeFile(join(legacySessionDir, "state.json"), "{not-json", "utf8");
+    const plain = await createPlainHarness(rig.homeDir);
+    const migrated = await plain.createSession({
+      id: "ses_corrupt_preexisting_migration",
+      workDir: rig.workDir,
+      metadata: { kimi_cli_source_path: legacySessionDir },
+    });
+    await migrated.close();
+
+    const resumed = await openRuntimeSession(rig, migrated.id);
+
+    expect(resumed.legacyApprovalFlags).toEqual({ yolo: false, afk: false });
+    expect(rig.logs).toContainEqual({
+      message: "Unable to restore legacy session approval settings",
+      error: expect.any(SyntaxError),
+    });
+  });
+
+  it("imports a UTF-8 text file into the same session without calling the model", async () => {
+    const rig = await createRuntimeRig();
+    await writeFile(join(rig.workDir, "notes.md"), "Keep the public API stable.", "utf8");
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, "/import notes.md")).resolves.toBe(true);
+
+    await expect(runtime.session.getContext()).resolves.toMatchObject({
+      history: [
+        {
+          role: "user",
+          content: expect.arrayContaining([
+            expect.objectContaining({
+              type: "text",
+              text: expect.stringContaining("Keep the public API stable."),
+            }),
+          ]),
+        },
+      ],
+    });
+    expect(rig.provider.requests).toHaveLength(0);
+    expect(streamEvents(rig.broadcasts)).toContainEqual({
+      type: "TurnBegin",
+      payload: { user_input: "/import notes.md", forkable: true },
+      _sessionId: runtime.id,
+    });
+  });
+
+  it("clears imported context without replacing the current session", async () => {
+    const rig = await createRuntimeRig();
+    const runtime = await openRuntimeSession(rig);
+    await runtime.session.importContext("Prior context.", "file 'prior.md'");
+    const sessionId = runtime.id;
+
+    await expect(runSlash(runtime, "/clear")).resolves.toBe(true);
+
+    expect(runtime.id).toBe(sessionId);
+    await expect(runtime.session.getContext()).resolves.toEqual({ history: [], tokenCount: 0 });
+  });
+
+  it("toggles plan mode through the public session without calling the model", async () => {
+    const rig = await createRuntimeRig();
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, "/plan on")).resolves.toBe(true);
+    await expect(runtime.session.getStatus()).resolves.toMatchObject({ planMode: true });
+    await expect(runSlash(runtime, "/plan off")).resolves.toBe(true);
+    await expect(runtime.session.getStatus()).resolves.toMatchObject({ planMode: false });
+    expect(rig.provider.requests).toHaveLength(0);
+  });
+
+  it("keeps a slash-added directory after VS Code closes and resumes the session", async () => {
+    const rig = await createRuntimeRig();
+    const additionalDir = join(rig.workDir, "directory with spaces");
+    await mkdir(additionalDir);
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, `/add-dir "${additionalDir}"`)).resolves.toBe(true);
+    const sessionId = runtime.id;
+    await rig.runtime.detachView("view-1");
+    const resumed = await openRuntimeSession(rig, sessionId);
+
+    expect(resumed.session.summary?.additionalDirs).toContain(additionalDir);
+  });
+
+  it("rejects an invalid plan subcommand without leaving the runtime busy", async () => {
+    const rig = await createRuntimeRig();
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, "/plan sideways")).rejects.toThrow(
+      "Unknown plan subcommand: sideways",
+    );
+
+    expect(runtime.isBusy).toBe(false);
+  });
+
+  it("stops a running init command without surfacing its late result", async () => {
+    const rig = await createRuntimeRig();
+    const blocked = routeBlockedPrompt(rig.provider);
+    const runtime = await openRuntimeSession(rig);
+    const command = runSlash(runtime, "/init");
+    await blocked.started;
+
+    await runtime.cancel();
+    blocked.release();
+
+    await expect(command).resolves.toBe(false);
+    expect(runtime.isBusy).toBe(false);
+    expect(JSON.stringify(streamEvents(rig.broadcasts))).not.toContain("late response");
+  });
+
+  it("stops a running manual compaction through the compaction cancellation API", async () => {
+    const rig = await createRuntimeRig();
+    const blocked = routeBlockedPrompt(rig.provider);
+    const runtime = await openRuntimeSession(rig);
+    await runtime.session.importContext("Enough prior context to compact.", "file 'prior.md'");
+    const command = runSlash(runtime, "/compact keep decisions");
+    await blocked.started;
+
+    await runtime.cancel();
+    blocked.release();
+
+    await expect(command).resolves.toBe(false);
+    expect(runtime.isBusy).toBe(false);
+  });
+
+  it("keeps the host action busy until manual compaction completes", async () => {
+    const rig = await createRuntimeRig();
+    routeSuccessfulPrompt(rig.provider);
+    const runtime = await openRuntimeSession(rig);
+    await runtime.session.importContext("Enough prior context to compact.", "file 'prior.md'");
+
+    const command = runSlash(runtime, "/compact keep decisions");
+    expect(runtime.isBusy).toBe(true);
+
+    await expect(command).resolves.toBe(true);
+    expect(runtime.isBusy).toBe(false);
+    expect(streamEvents(rig.broadcasts)).toContainEqual({
+      type: "CompactionEnd",
+      payload: {},
+      _sessionId: runtime.id,
+    });
+  });
+
+  it("keeps /yolo and /afk independent when they are combined", async () => {
+    const rig = await createRuntimeRig();
+    const runtime = await openRuntimeSession(rig);
+
+    await runSlash(runtime, "/yolo");
+    expect(runtime.legacyApprovalFlags).toEqual({ yolo: true, afk: false });
+    await expect(runtime.session.getStatus()).resolves.toMatchObject({ permission: "yolo" });
+
+    await runSlash(runtime, "/afk");
+    expect(runtime.legacyApprovalFlags).toEqual({ yolo: true, afk: true });
+    await expect(runtime.session.getStatus()).resolves.toMatchObject({ permission: "auto" });
+
+    await runSlash(runtime, "/afk");
+    expect(runtime.legacyApprovalFlags).toEqual({ yolo: true, afk: false });
+    await expect(runtime.session.getStatus()).resolves.toMatchObject({ permission: "yolo" });
+  });
+
+  it("applies the global yolo setting when a closed VS Code session reopens", async () => {
+    const rig = await createRuntimeRig();
+    const first = await openRuntimeSession(rig);
+    await runSlash(first, "/yolo");
+    await rig.runtime.detachView("view-1");
+
+    const reopened = await openRuntimeSession(rig, first.id);
+    expect(reopened.legacyApprovalFlags).toEqual({ yolo: false, afk: false });
+    await expect(reopened.session.getStatus()).resolves.toMatchObject({ permission: "manual" });
+    await rig.runtime.detachView("view-1");
+
+    const yoloReopened = await openRuntimeSession(rig, first.id, true);
+    expect(yoloReopened.legacyApprovalFlags).toEqual({ yolo: true, afk: false });
+    await expect(yoloReopened.session.getStatus()).resolves.toMatchObject({ permission: "yolo" });
+  });
+
+  it("exports current context as Markdown under the workspace", async () => {
+    const rig = await createRuntimeRig();
+    const runtime = await openRuntimeSession(rig);
+    await runtime.session.importContext("Prior context.", "file 'prior.md'");
+
+    await expect(runSlash(runtime, "/export exported.md")).resolves.toBe(true);
+
+    const markdown = await readFile(join(rig.workDir, "exported.md"), "utf8");
+    expect(markdown).toContain("# Kimi Session Export");
+    expect(markdown).toContain("Prior context.");
+  });
+
+  it("releases the host action after an invalid import so another command can run", async () => {
+    const rig = await createRuntimeRig();
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, "/import missing.md", {
+      harness: rig.runtime.harness,
+      runtime: rig.runtime,
+    } as HandlerContext)).rejects.toThrow(
+      "is not a valid file path or session ID",
+    );
+
+    expect(runtime.isBusy).toBe(false);
+    await expect(runSlash(runtime, "/clear")).resolves.toBe(true);
+  });
+
+  it("rejects a non-text import without changing the session context", async () => {
+    const rig = await createRuntimeRig();
+    await writeFile(join(rig.workDir, "archive.zip"), "not really a zip", "utf8");
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, "/import archive.zip")).rejects.toThrow(
+      "/import only supports text-based files",
+    );
+    await expect(runtime.session.getContext()).resolves.toEqual({ history: [], tokenCount: 0 });
+  });
+
+  it("rejects invalid UTF-8 import bytes with a readable error", async () => {
+    const rig = await createRuntimeRig();
+    await writeFile(join(rig.workDir, "broken.txt"), Buffer.from([0xc3, 0x28]));
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, "/import broken.txt")).rejects.toThrow(
+      "the file is not valid UTF-8 text",
+    );
+  });
+
+  it("rejects an import larger than the public 10 MB limit", async () => {
+    const rig = await createRuntimeRig();
+    await writeFile(join(rig.workDir, "large.txt"), Buffer.alloc(10 * 1024 * 1024 + 1, 0x61));
+    const runtime = await openRuntimeSession(rig);
+
+    await expect(runSlash(runtime, "/import large.txt")).rejects.toThrow(
+      "Maximum import size is 10 MB",
+    );
+  });
+
+  it("reports an unwritable export path and leaves the runtime usable", async () => {
+    const rig = await createRuntimeRig();
+    await writeFile(join(rig.workDir, "not-a-directory"), "blocking file", "utf8");
+    const runtime = await openRuntimeSession(rig);
+    await runtime.session.importContext("Prior context.", "file 'prior.md'");
+
+    await expect(runSlash(runtime, "/export not-a-directory/export.md")).rejects.toThrow();
+
+    expect(runtime.isBusy).toBe(false);
+    await expect(runSlash(runtime, "/clear")).resolves.toBe(true);
+  });
+
+  it("settles the prompt as failed when the provider returns 400", async () => {
+    const rig = await createRuntimeRig();
+    routeBadRequest(rig.provider);
+    const session = await openRuntimeSession(rig);
+
+    await expect(session.prompt("reject this request")).resolves.toEqual({ status: "failed" });
+
+    expect(session.isBusy).toBe(false);
+    expect(streamEvents(rig.broadcasts)).toContainEqual(
+      expect.objectContaining({ type: "error", phase: "runtime" }),
+    );
+  });
+
+  it("accepts a new prompt after a provider 400 ends the previous turn", async () => {
+    const rig = await createRuntimeRig();
+    let calls = 0;
+    rig.provider.route("POST", "/v1/chat/completions", async (_request, reply) => {
+      calls += 1;
+      if (calls === 1) {
+        await reply.json(400, {
+          error: { message: "mock request rejected", type: "invalid_request_error" },
+        });
+        return;
+      }
+      await reply.sseJson(200, [
+        completionChunk({ content: "recovered" }),
+        completionChunk({}, "stop"),
+      ]);
+    });
+    const session = await openRuntimeSession(rig);
+    await session.prompt("first request");
+
+    await expect(session.prompt("second request")).resolves.toEqual({ status: "finished" });
+  });
+
+  it("does not expose the provider token when reporting a provider 400", async () => {
+    const rig = await createRuntimeRig();
+    routeBadRequest(rig.provider);
+    const session = await openRuntimeSession(rig);
+
+    await session.prompt("reject this request");
+
+    expect(diagnosticText(rig)).not.toContain(PROVIDER_TOKEN);
+  });
+
+  it("keeps the provider's 400 detail in the extension-host log", async () => {
+    const rig = await createRuntimeRig();
+    routeBadRequest(rig.provider);
+    const session = await openRuntimeSession(rig);
+
+    await session.prompt("reject this request");
+
+    expect(rig.logs).toContainEqual(expect.objectContaining({
+      message: "Session turn failed",
+      error: expect.objectContaining({ message: expect.stringContaining("mock request rejected") }),
+    }));
+  });
+
+  it("settles the prompt as failed when the provider connection is unavailable", async () => {
+    const rig = await createRuntimeRig();
+    const session = await openRuntimeSession(rig);
+    await rig.closeProvider();
+
+    await expect(session.prompt("connection test")).resolves.toEqual({ status: "failed" });
+
+    expect(session.isBusy).toBe(false);
+    expect(streamEvents(rig.broadcasts)).toContainEqual(
+      expect.objectContaining({
+        type: "error",
+        code: "provider.connection_error",
+        phase: "runtime",
+      }),
+    );
+  });
+});
diff --git a/apps/vscode/test/kimi-runtime.test.ts b/apps/vscode/test/kimi-runtime.test.ts
new file mode 100644
index 000000000..6ea904467
--- /dev/null
+++ b/apps/vscode/test/kimi-runtime.test.ts
@@ -0,0 +1,554 @@
+/**
+ * Scenario: the VS Code host owns one Kimi harness and routes Webviews to shared SDK sessions.
+ * Responsibilities: create/resume/switch, per-session settings, multi-view ownership, detach, and disposal.
+ * Wiring: KimiRuntime and SessionRuntime are real; in-memory Session/KimiHarness fakes form the public SDK boundary.
+ * Run: pnpm exec vitest run --config apps/vscode/vitest.config.ts test/kimi-runtime.test.ts
+ */
+
+import type {
+  ApprovalHandler,
+  CreateSessionOptions,
+  Event,
+  JsonObject,
+  KimiHarness,
+  PermissionMode,
+  PromptInput,
+  QuestionHandler,
+  ResumeSessionInput,
+  Session,
+  SessionStatus,
+  SessionSummary,
+  ThinkingEffort,
+} from "@moonshot-ai/kimi-code-sdk";
+import { describe, expect, it } from "vitest";
+
+import { Events } from "../shared/bridge";
+import { KimiRuntime, type OpenSessionOptions } from "../src/runtime/kimi-runtime";
+
+interface FakeSessionBoundary {
+  readonly session: Session;
+  readonly setModels: string[];
+  readonly setThinkingEfforts: ThinkingEffort[];
+  readonly setPermissions: PermissionMode[];
+  readonly metadataUpdates: JsonObject[];
+  readonly handlerInstallations: { approval: number; question: number };
+  readonly subscriptionCount: () => number;
+  readonly closeCount: () => number;
+}
+
+function createFakeSession(
+  id: string,
+  workDir: string,
+  initial: Partial<SessionStatus> = {},
+  metadata?: JsonObject,
+): FakeSessionBoundary {
+  const listeners = new Set<(event: Event) => void>();
+  const setModels: string[] = [];
+  const setThinkingEfforts: ThinkingEffort[] = [];
+  const setPermissions: PermissionMode[] = [];
+  const metadataUpdates: JsonObject[] = [];
+  const handlerInstallations = { approval: 0, question: 0 };
+  let subscriptions = 0;
+  let closes = 0;
+  let status: SessionStatus = {
+    model: initial.model ?? "kimi-test",
+    thinkingEffort: initial.thinkingEffort ?? "off",
+    permission: initial.permission ?? "manual",
+    planMode: initial.planMode ?? false,
+    contextTokens: 0,
+    maxContextTokens: 128_000,
+    contextUsage: 0,
+  };
+  let summary: SessionSummary = {
+    id,
+    workDir,
+    sessionDir: `/home/sessions/${id}`,
+    createdAt: 1,
+    updatedAt: 2,
+    metadata,
+  };
+
+  const session = {
+    id,
+    workDir,
+    get summary() {
+      return summary;
+    },
+    set summary(value: SessionSummary | undefined) {
+      if (value !== undefined) summary = value;
+    },
+    setApprovalHandler(handler: ApprovalHandler | undefined) {
+      if (handler !== undefined) handlerInstallations.approval += 1;
+    },
+    setQuestionHandler(handler: QuestionHandler | undefined) {
+      if (handler !== undefined) handlerInstallations.question += 1;
+    },
+    onEvent(listener: (event: Event) => void) {
+      subscriptions += 1;
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async prompt(_input: string | PromptInput) {},
+    async steer(_input: string | PromptInput) {},
+    async cancel() {},
+    async getStatus() {
+      return status;
+    },
+    async setModel(model: string) {
+      setModels.push(model);
+      status = { ...status, model };
+    },
+    async setThinking(effort: ThinkingEffort) {
+      setThinkingEfforts.push(effort);
+      status = { ...status, thinkingEffort: effort };
+    },
+    async setPermission(permission: PermissionMode) {
+      setPermissions.push(permission);
+      status = { ...status, permission };
+    },
+    async updateMetadata(patch: JsonObject) {
+      metadataUpdates.push(patch);
+      summary = { ...summary, metadata: { ...summary.metadata, ...patch } };
+    },
+    async close() {
+      closes += 1;
+    },
+  } as unknown as Session;
+
+  return {
+    session,
+    setModels,
+    setThinkingEfforts,
+    setPermissions,
+    metadataUpdates,
+    handlerInstallations,
+    subscriptionCount: () => subscriptions,
+    closeCount: () => closes,
+  };
+}
+
+interface FakeHarnessBoundary {
+  readonly harness: KimiHarness;
+  readonly createInputs: CreateSessionOptions[];
+  readonly resumeInputs: ResumeSessionInput[];
+  readonly closeSessionIds: string[];
+  readonly deleteSessionIds: string[];
+  readonly closeCount: () => number;
+  readonly sessions: Map<string, FakeSessionBoundary>;
+  addSession(
+    id: string,
+    workDir: string,
+    initial?: Partial<SessionStatus>,
+    metadata?: JsonObject,
+  ): FakeSessionBoundary;
+}
+
+function createFakeHarness(
+  normalizeCreatedWorkDir: (workDir: string) => string = (workDir) => workDir,
+): FakeHarnessBoundary {
+  const sessions = new Map<string, FakeSessionBoundary>();
+  const createInputs: CreateSessionOptions[] = [];
+  const resumeInputs: ResumeSessionInput[] = [];
+  const closeSessionIds: string[] = [];
+  const deleteSessionIds: string[] = [];
+  let creates = 0;
+  let closes = 0;
+
+  const addSession = (
+    id: string,
+    workDir: string,
+    initial?: Partial<SessionStatus>,
+    metadata?: JsonObject,
+  ) => {
+    const boundary = createFakeSession(id, workDir, initial, metadata);
+    sessions.set(id, boundary);
+    return boundary;
+  };
+
+  const harness = {
+    async createSession(options: CreateSessionOptions) {
+      createInputs.push(options);
+      creates += 1;
+      return addSession(
+        `created-${creates}`,
+        normalizeCreatedWorkDir(options.workDir),
+        {
+          model: options.model,
+          thinkingEffort: options.thinking,
+          permission: options.permission,
+        },
+        options.metadata,
+      ).session;
+    },
+    async resumeSession(input: ResumeSessionInput) {
+      resumeInputs.push(input);
+      const boundary = sessions.get(input.id);
+      if (boundary === undefined) throw new Error(`Unknown session: ${input.id}`);
+      return boundary.session;
+    },
+    async closeSession(id: string) {
+      closeSessionIds.push(id);
+    },
+    async deleteSession(id: string) {
+      deleteSessionIds.push(id);
+    },
+    async close() {
+      closes += 1;
+    },
+  } as unknown as KimiHarness;
+
+  return {
+    harness,
+    createInputs,
+    resumeInputs,
+    closeSessionIds,
+    deleteSessionIds,
+    closeCount: () => closes,
+    sessions,
+    addSession,
+  };
+}
+
+function openOptions(overrides: Partial<OpenSessionOptions> = {}): OpenSessionOptions {
+  return {
+    webviewId: "view-1",
+    workDir: "/workspace",
+    model: "kimi-test",
+    effort: "off",
+    yoloMode: false,
+    ...overrides,
+  };
+}
+
+function createRuntime(
+  normalizeCreatedWorkDir?: (workDir: string) => string,
+) {
+  const sdk = createFakeHarness(normalizeCreatedWorkDir);
+  const runtime = new KimiRuntime({
+    version: "0.6.0",
+    harness: sdk.harness,
+    broadcast: () => undefined,
+    captureBaseline: () => undefined,
+    log: () => undefined,
+  });
+  return { runtime, sdk };
+}
+
+describe("Kimi runtime (owns shared SDK sessions for Webviews)", () => {
+  it("forwards the requested settings when creating an SDK session", async () => {
+    const { runtime, sdk } = createRuntime();
+
+    const opened = await runtime.openSession(
+      openOptions({ model: "kimi-k2", effort: "high", yoloMode: true }),
+    );
+
+    expect(sdk.createInputs).toEqual([
+      {
+        workDir: "/workspace",
+        model: "kimi-k2",
+        thinking: "high",
+        permission: "yolo",
+        metadata: { vscode_legacy_approval: { yolo: true, afk: false } },
+      },
+    ]);
+    expect(opened.subscribers).toEqual(["view-1"]);
+  });
+
+  it("accepts the normalized SDK workDir when a Windows session is created", async () => {
+    const { runtime } = createRuntime((workDir) => workDir.replaceAll("\\", "/"));
+
+    const opened = await runtime.openSession(openOptions({
+      workDir: "C:\\Users\\Example User\\项目",
+    }));
+
+    expect(opened.session.workDir).toBe("C:/Users/Example User/项目");
+  });
+
+  it("resumes a Windows session when only separators and casing differ", async () => {
+    const { runtime, sdk } = createRuntime();
+    sdk.addSession("saved-win", "C:/Users/Example User/项目");
+
+    const opened = await runtime.openSession(openOptions({
+      sessionId: "saved-win",
+      workDir: "c:\\users\\example user\\项目",
+    }));
+
+    expect(opened.id).toBe("saved-win");
+  });
+
+  it("uses off thinking when a new session receives an empty effort", async () => {
+    const { runtime, sdk } = createRuntime();
+
+    await runtime.openSession(openOptions({ effort: "   " }));
+
+    expect(sdk.createInputs[0]?.thinking).toBe("off");
+  });
+
+  it("resumes the requested SDK session instead of creating a replacement", async () => {
+    const { runtime, sdk } = createRuntime();
+    sdk.addSession("saved-1", "/workspace");
+
+    const opened = await runtime.openSession(openOptions({ sessionId: "saved-1" }));
+
+    expect(opened.id).toBe("saved-1");
+    expect(sdk.resumeInputs).toEqual([{ id: "saved-1", includeSubagents: true }]);
+    expect(sdk.createInputs).toEqual([]);
+  });
+
+  it("switches a Webview to the requested session", async () => {
+    const { runtime, sdk } = createRuntime();
+    await runtime.openSession(openOptions());
+    sdk.addSession("saved-2", "/workspace");
+
+    const selected = await runtime.openSession(openOptions({ sessionId: "saved-2" }));
+
+    expect(runtime.getSessionForView("view-1")?.id).toBe("saved-2");
+    expect(selected.id).toBe("saved-2");
+  });
+
+  it("closes an unshared old session when its Webview switches away", async () => {
+    const { runtime, sdk } = createRuntime();
+    const old = await runtime.openSession(openOptions());
+    const oldBoundary = sdk.sessions.get(old.id)!;
+    sdk.addSession("saved-2", "/workspace");
+
+    await runtime.openSession(openOptions({ sessionId: "saved-2" }));
+
+    expect(oldBoundary.closeCount()).toBe(1);
+  });
+
+  it("shares one SDK subscription when two Webviews attach to the same session", async () => {
+    const { runtime, sdk } = createRuntime();
+    const first = await runtime.openSession(openOptions({ webviewId: "view-1" }));
+    const boundary = sdk.sessions.get(first.id)!;
+
+    const second = await runtime.openSession(
+      openOptions({ webviewId: "view-2", sessionId: first.id }),
+    );
+
+    expect(second).toBe(first);
+    expect(first.subscribers).toEqual(["view-1", "view-2"]);
+    expect(boundary.subscriptionCount()).toBe(1);
+    expect(boundary.handlerInstallations).toEqual({ approval: 1, question: 1 });
+  });
+
+  it("updates the SDK model when the resumed session has a different model", async () => {
+    const { runtime, sdk } = createRuntime();
+    const session = sdk.addSession("saved-1", "/workspace", { model: "old-model" });
+
+    await runtime.openSession(openOptions({ sessionId: "saved-1", model: "new-model" }));
+
+    expect(session.setModels).toEqual(["new-model"]);
+  });
+
+  it("preserves the resumed session's thinking effort instead of reapplying the configured default", async () => {
+    const { runtime, sdk } = createRuntime();
+    const session = sdk.addSession("saved-1", "/workspace", { thinkingEffort: "max" });
+
+    const opened = await runtime.openSession(openOptions({ sessionId: "saved-1", effort: "medium" }));
+
+    expect(session.setThinkingEfforts).toEqual([]);
+    await expect(opened.session.getStatus()).resolves.toMatchObject({ thinkingEffort: "max" });
+  });
+
+  it("announces the session's actual status to the attaching view so the display matches it", async () => {
+    const sdk = createFakeHarness();
+    const broadcasts: { event: string; data: unknown; webviewId?: string }[] = [];
+    const runtime = new KimiRuntime({
+      version: "0.6.0",
+      harness: sdk.harness,
+      broadcast: (event, data, webviewId) => {
+        broadcasts.push({ event, data, webviewId });
+      },
+      captureBaseline: () => undefined,
+      log: () => undefined,
+    });
+    sdk.addSession("saved-1", "/workspace", {
+      model: "kimi-test",
+      thinkingEffort: "max",
+      planMode: true,
+    });
+
+    await runtime.openSession(openOptions({ sessionId: "saved-1", effort: "medium" }));
+
+    expect(broadcasts).toContainEqual({
+      event: Events.StreamEvent,
+      data: {
+        type: "StatusUpdate",
+        payload: { model: "kimi-test", thinking_effort: "max", plan_mode: true },
+        _sessionId: "saved-1",
+      },
+      webviewId: "view-1",
+    });
+  });
+
+  it("uses the yolo setting as the initial value for an unmarked resumed session", async () => {
+    const { runtime, sdk } = createRuntime();
+    const session = sdk.addSession("saved-1", "/workspace", { permission: "manual" });
+
+    await runtime.openSession(openOptions({ sessionId: "saved-1", yoloMode: true }));
+
+    expect(session.metadataUpdates).toEqual([
+      { vscode_legacy_approval: { yolo: true, afk: false } },
+    ]);
+  });
+
+  it("lets the global yolo setting override a persisted off flag on resume", async () => {
+    const { runtime, sdk } = createRuntime();
+    const session = sdk.addSession(
+      "saved-1",
+      "/workspace",
+      { permission: "manual" },
+      { vscode_legacy_approval: { yolo: false, afk: false } },
+    );
+
+    const opened = await runtime.openSession(openOptions({ sessionId: "saved-1", yoloMode: true }));
+
+    expect(session.setPermissions).toEqual(["yolo"]);
+    expect(session.metadataUpdates).toEqual([
+      { vscode_legacy_approval: { yolo: true, afk: false } },
+    ]);
+    expect(opened.legacyApprovalFlags).toEqual({ yolo: true, afk: false });
+  });
+
+  it("lets the global yolo setting disable a persisted session yolo flag on resume", async () => {
+    const { runtime, sdk } = createRuntime();
+    const session = sdk.addSession(
+      "saved-1",
+      "/workspace",
+      { permission: "yolo" },
+      { vscode_legacy_approval: { yolo: true, afk: false } },
+    );
+
+    const opened = await runtime.openSession(openOptions({ sessionId: "saved-1", yoloMode: false }));
+
+    expect(session.setPermissions).toEqual(["manual"]);
+    expect(session.metadataUpdates).toEqual([
+      { vscode_legacy_approval: { yolo: false, afk: false } },
+    ]);
+    expect(opened.legacyApprovalFlags).toEqual({ yolo: false, afk: false });
+  });
+
+  it("keeps the persisted afk flag while applying the global yolo setting on resume", async () => {
+    const { runtime, sdk } = createRuntime();
+    const session = sdk.addSession(
+      "saved-1",
+      "/workspace",
+      { permission: "manual" },
+      { vscode_legacy_approval: { yolo: false, afk: true } },
+    );
+
+    const opened = await runtime.openSession(openOptions({ sessionId: "saved-1", yoloMode: true }));
+
+    expect(session.setPermissions).toEqual(["auto"]);
+    expect(opened.legacyApprovalFlags).toEqual({ yolo: true, afk: true });
+  });
+
+  it("restores persisted afk with core auto permission", async () => {
+    const { runtime, sdk } = createRuntime();
+    const session = sdk.addSession(
+      "saved-1",
+      "/workspace",
+      { permission: "manual" },
+      { vscode_legacy_approval: { yolo: false, afk: true } },
+    );
+
+    await runtime.openSession(openOptions({ sessionId: "saved-1", yoloMode: false }));
+
+    expect(session.setPermissions).toEqual(["auto"]);
+  });
+
+  it("changes the setting-backed yolo flag without clearing session afk", async () => {
+    const { runtime } = createRuntime();
+    const opened = await runtime.openSession(openOptions());
+    await opened.toggleLegacyApproval("afk");
+
+    await runtime.setYoloModeForActiveSessions(true);
+
+    expect(opened.legacyApprovalFlags).toEqual({ yolo: true, afk: true });
+    await expect(opened.session.getStatus()).resolves.toMatchObject({ permission: "auto" });
+  });
+
+  it("keeps a shared session open when one of its Webviews detaches", async () => {
+    const { runtime, sdk } = createRuntime();
+    const opened = await runtime.openSession(openOptions({ webviewId: "view-1" }));
+    await runtime.openSession(openOptions({ webviewId: "view-2", sessionId: opened.id }));
+    const boundary = sdk.sessions.get(opened.id)!;
+
+    await runtime.detachView("view-1");
+
+    expect(boundary.closeCount()).toBe(0);
+    expect(runtime.getSessionForView("view-2")?.id).toBe(opened.id);
+  });
+
+  it("closes an SDK session when its last Webview detaches", async () => {
+    const { runtime, sdk } = createRuntime();
+    const opened = await runtime.openSession(openOptions());
+    const boundary = sdk.sessions.get(opened.id)!;
+
+    await runtime.detachView("view-1");
+
+    expect(boundary.closeCount()).toBe(1);
+    expect(runtime.getSession(opened.id)).toBeUndefined();
+  });
+
+  it("reattaches the same resumed session without replacing its handlers", async () => {
+    const { runtime, sdk } = createRuntime();
+    const boundary = sdk.addSession("saved-1", "/workspace");
+    const first = await runtime.attachResumedSession("view-1", boundary.session);
+
+    const second = await runtime.attachResumedSession("view-1", boundary.session);
+
+    expect(second).toBe(first);
+    expect(boundary.subscriptionCount()).toBe(1);
+    expect(boundary.handlerInstallations).toEqual({ approval: 1, question: 1 });
+    expect(boundary.closeCount()).toBe(0);
+  });
+
+  it("removes every Webview mapping when a shared session is closed", async () => {
+    const { runtime } = createRuntime();
+    const opened = await runtime.openSession(openOptions({ webviewId: "view-1" }));
+    await runtime.openSession(openOptions({ webviewId: "view-2", sessionId: opened.id }));
+
+    await runtime.closeSession(opened.id);
+
+    expect(runtime.getSessionForView("view-1")).toBeUndefined();
+    expect(runtime.getSessionForView("view-2")).toBeUndefined();
+  });
+
+  it("delegates deletion after the active session has been closed", async () => {
+    const { runtime, sdk } = createRuntime();
+    const opened = await runtime.openSession(openOptions());
+    const boundary = sdk.sessions.get(opened.id)!;
+
+    await runtime.deleteSession(opened.id);
+
+    expect(boundary.closeCount()).toBe(1);
+    expect(sdk.deleteSessionIds).toEqual([opened.id]);
+  });
+
+  it("closes every active SDK session when the host runtime is disposed", async () => {
+    const { runtime, sdk } = createRuntime();
+    const first = await runtime.openSession(openOptions({ webviewId: "view-1" }));
+    const secondBoundary = sdk.addSession("saved-2", "/workspace");
+    await runtime.openSession(openOptions({ webviewId: "view-2", sessionId: "saved-2" }));
+
+    await runtime.dispose();
+
+    expect(sdk.sessions.get(first.id)?.closeCount()).toBe(1);
+    expect(secondBoundary.closeCount()).toBe(1);
+    expect(sdk.closeCount()).toBe(1);
+  });
+
+  it("does not retain a resumed session when it belongs to a different working directory", async () => {
+    const { runtime, sdk } = createRuntime();
+    const foreign = sdk.addSession("foreign-1", "/other-workspace");
+
+    await expect(
+      runtime.openSession(openOptions({ sessionId: "foreign-1" })),
+    ).rejects.toThrow("The selected session belongs to a different working directory.");
+
+    expect(runtime.getSession("foreign-1")).toBeUndefined();
+    expect(foreign.closeCount()).toBe(1);
+  });
+});
diff --git a/apps/vscode/test/legacy-migration.manager.test.ts b/apps/vscode/test/legacy-migration.manager.test.ts
new file mode 100644
index 000000000..d246759c6
--- /dev/null
+++ b/apps/vscode/test/legacy-migration.manager.test.ts
@@ -0,0 +1,489 @@
+/**
+ * Scenario: VS Code discovers and runs legacy kimi-cli migration without touching a real home.
+ * Responsibilities: source selection, shared-marker suppression, real migration, retry, and clear reports.
+ * Wiring: real temporary files and the public migration package; no stubbed collaborators.
+ * Run: pnpm --filter kimi-code test -- legacy-migration.manager.test.ts
+ */
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { LegacyMigrationManager } from "../src/migration";
+
+const temporaryRoots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })),
+  );
+});
+
+describe("legacy migration manager (discovery and migration coordination)", () => {
+  it("returns an actionable prompt when the default legacy home contains data", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt).toMatchObject({
+      kind: "legacy-migration",
+      actions: [
+        { id: "now", label: "Migrate Now" },
+        { id: "later", label: "Later" },
+      ],
+      sources: [
+        {
+          sourceHome: rig.sourceHome,
+          origin: "default",
+          hasConfig: true,
+        },
+      ],
+    });
+  });
+
+  it("suppresses the prompt when the shared marker names the same target", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    await writeSharedMarker(rig.sourceHome, rig.targetHome);
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt).toBeNull();
+    expect(discovery.suppressedSources).toEqual([
+      expect.objectContaining({ sourceHome: rig.sourceHome, hasConfig: true }),
+    ]);
+  });
+
+  it("returns the prompt when the shared marker names a different target", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    await writeSharedMarker(rig.sourceHome, join(rig.root, "another-target"));
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt?.sources).toEqual([
+      expect.objectContaining({ sourceHome: rig.sourceHome }),
+    ]);
+  });
+
+  it("does not duplicate data when the TUI already migrated the same source", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    const existingSession = join(rig.targetHome, "sessions", "existing", "state.json");
+    await mkdir(join(existingSession, ".."), { recursive: true });
+    await writeFile(existingSession, '{"custom":{"imported_from_kimi_cli":true}}');
+    await writeSharedMarker(rig.sourceHome, rig.targetHome);
+
+    const result = await rig.manager.migrateNow();
+
+    expect(result.status).toBe("nothing-to-migrate");
+    await expect(readFile(existingSession, "utf-8")).resolves.toContain(
+      "imported_from_kimi_cli",
+    );
+    await expect(readFile(join(rig.targetHome, "config.toml"), "utf-8")).rejects.toThrow();
+  });
+
+  it("conservatively suppresses the prompt when the shared marker is corrupt", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    await writeFile(join(rig.sourceHome, ".migrated-to-kimi-code"), "not-json");
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt).toBeNull();
+    expect(discovery.suppressedSources).toHaveLength(1);
+  });
+
+  it("discovers a relative legacy KIMI_SHARE_DIR from the workspace and warns about its resolution", async () => {
+    const rig = await createRig({
+      legacyEnvironmentVariables: { KIMI_SHARE_DIR: "legacy-kimi" },
+    });
+    const shareHome = join(rig.workspaceRoot, "legacy-kimi");
+    await writeLegacyConfig(shareHome);
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt?.sources).toEqual([
+      expect.objectContaining({
+        sourceHome: resolve(shareHome),
+        origin: "legacy-vscode-setting",
+      }),
+    ]);
+    expect(discovery.warnings).toEqual([
+      expect.objectContaining({ code: "relative-share-dir", sourceHome: resolve(shareHome) }),
+    ]);
+  });
+
+  it("migrates both the default home and the extra legacy KIMI_SHARE_DIR source", async () => {
+    const rig = await createRig({
+      legacyEnvironmentVariables: { KIMI_SHARE_DIR: "legacy-kimi" },
+    });
+    await writeLegacyConfig(rig.sourceHome);
+    const shareHome = join(rig.workspaceRoot, "legacy-kimi");
+    await mkdir(join(shareHome, "skills", "example-skill"), { recursive: true });
+    await writeFile(
+      join(shareHome, "skills", "example-skill", "SKILL.md"),
+      "---\nname: example-skill\ndescription: test fixture\n---\n",
+    );
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("completed");
+    expect(result.sources).toHaveLength(2);
+    expect(result.totals).toMatchObject({ configFiles: 1, skills: 1 });
+    await expect(
+      readFile(join(rig.targetHome, "skills", "example-skill", "SKILL.md"), "utf-8"),
+    ).resolves.toContain("example-skill");
+  });
+
+  it("ignores legacy environment variables other than KIMI_SHARE_DIR", async () => {
+    const rig = await createRig({
+      legacyEnvironmentVariables: {
+        KIMI_CODE_HOME: join(tmpdir(), "must-not-be-read"),
+        PATH: join(tmpdir(), "must-not-be-used"),
+      },
+    });
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery).toMatchObject({ prompt: null, warnings: [] });
+  });
+
+  it("ignores a non-string legacy KIMI_SHARE_DIR with a clear warning", async () => {
+    const rig = await createRig({
+      legacyEnvironmentVariables: { KIMI_SHARE_DIR: 42, HTTPS_PROXY: "https://example.test" },
+    });
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt).toBeNull();
+    expect(discovery.warnings).toEqual([
+      expect.objectContaining({
+        code: "invalid-share-dir",
+        message: expect.stringContaining("non-empty string"),
+      }),
+    ]);
+  });
+
+  it("ignores a relative legacy KIMI_SHARE_DIR when no workspace can resolve it", async () => {
+    const rig = await createRig({
+      workspaceRoot: null,
+      legacyEnvironmentVariables: { KIMI_SHARE_DIR: "legacy-kimi" },
+    });
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt).toBeNull();
+    expect(discovery.warnings).toEqual([
+      expect.objectContaining({
+        code: "invalid-share-dir",
+        message: expect.stringContaining("no workspace is open"),
+      }),
+    ]);
+  });
+
+  it("bypasses a completed marker on explicit retry and runs the real migration", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    await writeSharedMarker(rig.sourceHome, rig.targetHome);
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("completed");
+    expect(result.totals.configFiles).toBe(1);
+    await expect(readFile(join(rig.targetHome, "config.toml"), "utf-8")).resolves.toContain(
+      "merge_all_available_skills",
+    );
+  });
+
+  it("keeps the migrated target unchanged when an explicit retry is repeated", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    await rig.manager.retry();
+    const firstTarget = await readFile(join(rig.targetHome, "config.toml"), "utf-8");
+
+    const secondResult = await rig.manager.retry();
+
+    expect(secondResult.status).toBe("completed");
+    await expect(readFile(join(rig.targetHome, "config.toml"), "utf-8")).resolves.toBe(
+      firstTarget,
+    );
+  });
+
+  it("reports a corrupt session as a partial migration without rolling back valid data", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    await writeCorruptLegacySession(rig.sourceHome, rig.workspaceRoot);
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("partial");
+    expect(result.sources[0]?.failures).toEqual([
+      expect.objectContaining({
+        code: "session-failed",
+        message: expect.stringMatching(/corrupt|parseable/i),
+      }),
+    ]);
+    await expect(readFile(join(rig.targetHome, "config.toml"), "utf-8")).resolves.toContain(
+      "merge_all_available_skills",
+    );
+  });
+
+  it("discovers an unknown workdir bucket as actionable legacy data", async () => {
+    const rig = await createRig();
+    const bucket = await writeUnknownWorkdirBucket(rig.sourceHome);
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt?.sources).toEqual([
+      expect.objectContaining({
+        sourceHome: rig.sourceHome,
+        totalSessions: 0,
+        sessionIssues: 1,
+      }),
+    ]);
+    expect(discovery.warnings).toEqual([
+      expect.objectContaining({
+        code: "legacy-session-unreadable",
+        message: expect.stringContaining(bucket),
+      }),
+    ]);
+  });
+
+  it("returns a partial result with a manual action for an unknown workdir bucket", async () => {
+    const rig = await createRig();
+    const bucket = await writeUnknownWorkdirBucket(rig.sourceHome);
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("partial");
+    expect(result.sources[0]?.failures).toEqual([
+      expect.objectContaining({ code: "session-failed", item: bucket }),
+    ]);
+    expect(result.manualActions).toEqual([expect.stringContaining(bucket)]);
+    expect(result.warnings).toEqual([
+      expect.objectContaining({ code: "legacy-session-unreadable" }),
+    ]);
+  });
+
+  it("returns a partial result with a warning when a registered bucket is unreadable", async () => {
+    const rig = await createRig();
+    const workDir = rig.workspaceRoot;
+    await mkdir(rig.sourceHome, { recursive: true });
+    await writeFile(
+      join(rig.sourceHome, "kimi.json"),
+      JSON.stringify({ work_dirs: [{ path: workDir, kaos: "local" }] }),
+    );
+    const bucket = join(
+      rig.sourceHome,
+      "sessions",
+      createHash("md5").update(workDir).digest("hex"),
+    );
+    await mkdir(join(rig.sourceHome, "sessions"), { recursive: true });
+    await writeFile(bucket, "not a directory");
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("partial");
+    expect(result.sources[0]?.failures).toEqual([
+      expect.objectContaining({ code: "session-failed", item: bucket }),
+    ]);
+    expect(result.warnings).toEqual([
+      expect.objectContaining({
+        code: "legacy-session-unreadable",
+        message: expect.stringContaining(bucket),
+      }),
+    ]);
+  });
+
+  it("keeps an unresolved session source discoverable after a partial run", async () => {
+    const rig = await createRig();
+    await writeUnknownWorkdirBucket(rig.sourceHome);
+    await rig.manager.retry();
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt?.sources).toEqual([
+      expect.objectContaining({ sourceHome: rig.sourceHome, sessionIssues: 1 }),
+    ]);
+  });
+
+  it("reports an unresolved session warning when a shared marker suppresses the prompt", async () => {
+    const rig = await createRig();
+    const bucket = await writeUnknownWorkdirBucket(rig.sourceHome);
+    await writeSharedMarker(rig.sourceHome, rig.targetHome);
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt).toBeNull();
+    expect(discovery.suppressedSources).toEqual([
+      expect.objectContaining({ sourceHome: rig.sourceHome, sessionIssues: 1 }),
+    ]);
+    expect(discovery.warnings).toEqual([
+      expect.objectContaining({
+        code: "legacy-session-unreadable",
+        message: expect.stringContaining(bucket),
+      }),
+    ]);
+  });
+
+  it("reports an unparseable legacy config with a manual review action", async () => {
+    const rig = await createRig();
+    await mkdir(rig.sourceHome, { recursive: true });
+    await writeFile(join(rig.sourceHome, "config.toml"), 'broken = "unterminated');
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("partial");
+    expect(result.sources[0]?.failures).toEqual([
+      expect.objectContaining({ code: "legacy-config-unreadable", item: "config.toml" }),
+    ]);
+    expect(result.manualActions).toEqual([
+      expect.stringContaining("review it manually"),
+    ]);
+  });
+
+  it("reports an unparseable legacy MCP file with a manual review action", async () => {
+    const rig = await createRig();
+    await mkdir(rig.sourceHome, { recursive: true });
+    await writeFile(join(rig.sourceHome, "mcp.json"), "{broken");
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("partial");
+    expect(result.sources[0]?.failures).toEqual([
+      expect.objectContaining({ code: "legacy-mcp-unreadable", item: "mcp.json" }),
+    ]);
+  });
+
+  it("returns a failed result with the original filesystem reason when the target is blocked", async () => {
+    const rig = await createRig();
+    await writeLegacyConfig(rig.sourceHome);
+    await writeFile(rig.targetHome, "this file blocks the target directory");
+
+    const result = await rig.manager.retry();
+
+    expect(result.status).toBe("failed");
+    expect(result.sources[0]?.failures).toEqual([
+      expect.objectContaining({
+        code: "run-failed",
+        message: expect.stringMatching(/file|directory|exist|not a directory/i),
+      }),
+    ]);
+    expect(result.manualActions).toEqual([
+      expect.stringContaining("Migrate Legacy Data"),
+    ]);
+  });
+
+  it("reports legacy OAuth login as requiring a new login without treating it as migratable data", async () => {
+    const rig = await createRig();
+    await mkdir(join(rig.sourceHome, "credentials"), { recursive: true });
+    await writeFile(join(rig.sourceHome, "credentials", "kimi-code.json"), "{}");
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.prompt).toBeNull();
+    expect(discovery.notices.oauthLoginsRequiringRelogin).toEqual([
+      { sourceHome: rig.sourceHome, name: "kimi-code.json" },
+    ]);
+  });
+
+  it("reports legacy MCP OAuth state as requiring reauthorization", async () => {
+    const rig = await createRig();
+    await mkdir(join(rig.sourceHome, "mcp-oauth"), { recursive: true });
+    await writeFile(join(rig.sourceHome, "mcp-oauth", "example-server"), "{}");
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.notices.mcpOauthServersRequiringReauth).toEqual([
+      { sourceHome: rig.sourceHome, name: "example-server" },
+    ]);
+  });
+
+  it("reports a configured migration source that is not a directory", async () => {
+    const rig = await createRig();
+    await writeFile(rig.sourceHome, "not a directory");
+
+    const discovery = await rig.manager.discover();
+
+    expect(discovery.warnings).toEqual([
+      expect.objectContaining({
+        code: "source-not-directory",
+        sourceHome: rig.sourceHome,
+      }),
+    ]);
+  });
+});
+
+interface RigOptions {
+  readonly workspaceRoot?: string | null;
+  readonly legacyEnvironmentVariables?: unknown;
+}
+
+async function createRig(options: RigOptions = {}): Promise<{
+  readonly root: string;
+  readonly sourceHome: string;
+  readonly targetHome: string;
+  readonly workspaceRoot: string;
+  readonly manager: LegacyMigrationManager;
+}> {
+  const root = await mkdtemp(join(tmpdir(), "vscode-legacy-migration-"));
+  temporaryRoots.push(root);
+  const sourceHome = join(root, ".kimi");
+  const targetHome = join(root, ".kimi-code");
+  const workspaceRoot = join(root, "workspace");
+  await mkdir(options.workspaceRoot === null ? root : workspaceRoot, { recursive: true });
+  const manager = new LegacyMigrationManager({
+    targetHome,
+    defaultSourceHome: sourceHome,
+    workspaceRoot: options.workspaceRoot === undefined ? workspaceRoot : options.workspaceRoot,
+    legacyEnvironmentVariables: options.legacyEnvironmentVariables,
+  });
+  return { root, sourceHome, targetHome, workspaceRoot, manager };
+}
+
+async function writeLegacyConfig(sourceHome: string): Promise<void> {
+  await mkdir(sourceHome, { recursive: true });
+  await writeFile(join(sourceHome, "config.toml"), "merge_all_available_skills = true\n");
+}
+
+async function writeSharedMarker(sourceHome: string, targetHome: string): Promise<void> {
+  await mkdir(sourceHome, { recursive: true });
+  await writeFile(
+    join(sourceHome, ".migrated-to-kimi-code"),
+    JSON.stringify({ version: 1, target_path: targetHome, runs: [] }),
+  );
+}
+
+async function writeCorruptLegacySession(
+  sourceHome: string,
+  workDir: string,
+): Promise<void> {
+  await mkdir(sourceHome, { recursive: true });
+  await writeFile(
+    join(sourceHome, "kimi.json"),
+    JSON.stringify({ work_dirs: [{ path: workDir, kaos: "local" }] }),
+  );
+  const bucket = createHash("md5").update(workDir).digest("hex");
+  const sessionDir = join(sourceHome, "sessions", bucket, "corrupt-session");
+  await mkdir(sessionDir, { recursive: true });
+  await writeFile(join(sessionDir, "context.jsonl"), "not-json\n{broken\n}}}\n");
+  await writeFile(join(sessionDir, "state.json"), "{}");
+}
+
+async function writeUnknownWorkdirBucket(sourceHome: string): Promise<string> {
+  const bucket = join(
+    sourceHome,
+    "sessions",
+    createHash("md5").update("/workspace/not-registered").digest("hex"),
+  );
+  await mkdir(join(bucket, "legacy-session"), { recursive: true });
+  await writeFile(
+    join(bucket, "legacy-session", "context.jsonl"),
+    '{"role":"user","content":"hello"}\n',
+  );
+  return bucket;
+}
diff --git a/apps/vscode/test/replay-adapter.test.ts b/apps/vscode/test/replay-adapter.test.ts
new file mode 100644
index 000000000..34ea632b8
--- /dev/null
+++ b/apps/vscode/test/replay-adapter.test.ts
@@ -0,0 +1,569 @@
+/**
+ * Scenario: a resumed Node SDK transcript is rendered through the released VS Code Webview protocol.
+ * Responsibilities: visible turns, media, assistant/tool output, subagent routing, compaction, plan state, and hidden injections.
+ * Wiring: the pure replay adapter and public SDK replay types are used directly; there are no stubs.
+ * Run: pnpm exec vitest run --config apps/vscode/vitest.config.ts test/replay-adapter.test.ts
+ */
+
+import type {
+  AgentReplayRecord,
+  ContentPart,
+  ResumedAgentState,
+  ResumedSessionState,
+  ToolCall,
+} from "@moonshot-ai/kimi-code-sdk";
+import { describe, expect, it } from "vitest";
+
+import {
+  replayRecordTurnCount,
+  replaySessionToWebviewEvents,
+  replayToWebviewEvents,
+} from "../src/runtime/replay-adapter";
+
+type ReplayMessage = Extract<AgentReplayRecord, { type: "message" }>["message"];
+
+function message(
+  role: ReplayMessage["role"],
+  content: ContentPart[],
+  options: {
+    readonly toolCalls?: ToolCall[];
+    readonly toolCallId?: string;
+    readonly isError?: boolean;
+    readonly origin?: ReplayMessage["origin"];
+  } = {},
+): ReplayMessage {
+  return {
+    role,
+    content,
+    toolCalls: options.toolCalls ?? [],
+    toolCallId: options.toolCallId,
+    isError: options.isError,
+    origin: options.origin,
+  };
+}
+
+function record(messageValue: ReplayMessage, time: number = 1): AgentReplayRecord {
+  return { type: "message", message: messageValue, time };
+}
+
+function resumedAgent(
+  replay: readonly AgentReplayRecord[],
+  options: {
+    readonly modelAlias?: string;
+    readonly thinkingEffort?: string;
+    readonly plan?: ResumedAgentState["plan"];
+    readonly contextTokenCount?: number;
+    readonly usage?: ResumedAgentState["usage"];
+    readonly type?: ResumedAgentState["type"];
+  } = {},
+): ResumedAgentState {
+  return {
+    type: options.type ?? "main",
+    config: {
+      cwd: "/workspace",
+      modelAlias: options.modelAlias ?? "kimi-test",
+      modelCapabilities: {
+        image_in: true,
+        video_in: true,
+        audio_in: false,
+        thinking: true,
+        tool_use: true,
+        max_context_tokens: 128_000,
+      },
+      thinkingEffort: options.thinkingEffort ?? "off",
+      systemPrompt: "",
+    },
+    context: { history: [], tokenCount: options.contextTokenCount ?? 0 },
+    replay,
+    permission: { mode: "manual", rules: [] },
+    plan: options.plan ?? null,
+    usage: options.usage ?? {},
+    tools: [],
+    background: [],
+  };
+}
+
+function replay(records: readonly AgentReplayRecord[]) {
+  return replayToWebviewEvents(resumedAgent(records), "session-1");
+}
+
+describe("replay adapter (renders the public SDK resume state for the Webview)", () => {
+  it("restores the selected model before transcript events", () => {
+    const agent = resumedAgent([]);
+
+    expect(replayToWebviewEvents(agent, "session-1")[0]).toMatchObject({
+      type: "StatusUpdate",
+      payload: { model: "kimi-test" },
+    });
+  });
+
+  it("restores thinking effort before transcript events", () => {
+    const agent = resumedAgent([], { thinkingEffort: "high" });
+
+    expect(replayToWebviewEvents(agent, "session-1")[0]).toMatchObject({
+      type: "StatusUpdate",
+      payload: { thinking_effort: "high" },
+    });
+  });
+
+  it("restores active plan mode before transcript events", () => {
+    const agent = resumedAgent([], {
+      plan: { id: "plan-1", content: "Plan", path: "/workspace/plan.md" },
+    });
+
+    expect(replayToWebviewEvents(agent, "session-1")[0]).toMatchObject({
+      type: "StatusUpdate",
+      payload: { plan_mode: true },
+    });
+  });
+
+  it("restores context usage after all transcript turns", () => {
+    const agent = resumedAgent([], { contextTokenCount: 32_000 });
+
+    expect(replayToWebviewEvents(agent, "session-1").at(-1)).toMatchObject({
+      type: "StatusUpdate",
+      payload: { context_usage: 0.25 },
+    });
+  });
+
+  it("restores cumulative token usage exactly once after all transcript turns", () => {
+    const agent = resumedAgent([], {
+      usage: {
+        total: {
+          inputOther: 10,
+          output: 4,
+          inputCacheRead: 3,
+          inputCacheCreation: 2,
+        },
+      },
+    });
+
+    const statusEvents = replayToWebviewEvents(agent, "session-1").filter(
+      (event) =>
+        event.type === "StatusUpdate" &&
+        typeof event.payload === "object" &&
+        event.payload !== null &&
+        "token_usage" in event.payload,
+    );
+    expect(statusEvents).toEqual([
+      {
+        type: "StatusUpdate",
+        payload: {
+          context_usage: 0,
+          token_usage: {
+            input_other: 10,
+            output: 4,
+            input_cache_read: 3,
+            input_cache_creation: 2,
+          },
+        },
+        _sessionId: "session-1",
+      },
+    ]);
+  });
+
+  it("opens one visible turn when replay contains a user prompt", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Fix the test" }], { origin: { kind: "user" } })),
+    ]);
+
+    expect(events.filter((event) => event.type !== "StatusUpdate")).toEqual([
+      {
+        type: "TurnBegin",
+        payload: { user_input: [{ type: "text", text: "Fix the test" }] },
+        _sessionId: "session-1",
+      },
+      {
+        type: "stream_complete",
+        result: { status: "finished" },
+        _sessionId: "session-1",
+      },
+    ]);
+  });
+
+  it("converts SDK media keys when replay renders a user prompt", () => {
+    const events = replay([
+      record(
+        message(
+          "user",
+          [
+            { type: "image_url", imageUrl: { url: "file:///workspace/a.png", id: "image-1" } },
+            { type: "audio_url", audioUrl: { url: "file:///workspace/a.mp3", id: "audio-1" } },
+            { type: "video_url", videoUrl: { url: "file:///workspace/a.mp4", id: "video-1" } },
+          ],
+          { origin: { kind: "user" } },
+        ),
+      ),
+    ]);
+
+    expect(events.find((event) => event.type === "TurnBegin")).toEqual({
+      type: "TurnBegin",
+      payload: {
+        user_input: [
+          { type: "image_url", image_url: { url: "file:///workspace/a.png", id: "image-1" } },
+          { type: "audio_url", audio_url: { url: "file:///workspace/a.mp3", id: "audio-1" } },
+          { type: "video_url", video_url: { url: "file:///workspace/a.mp4", id: "video-1" } },
+        ],
+      },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("renders assistant text inside the open turn", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Explain" }], { origin: { kind: "user" } })),
+      record(message("assistant", [{ type: "text", text: "Here is the answer" }]), 2),
+    ]);
+
+    expect(events.filter((event) => event.type === "ContentPart")).toEqual([
+      {
+        type: "ContentPart",
+        payload: { type: "text", text: "Here is the answer" },
+        _sessionId: "session-1",
+      },
+    ]);
+  });
+
+  it("renders signed thinking inside the open turn", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Explain" }], { origin: { kind: "user" } })),
+      record(
+        message("assistant", [{ type: "think", think: "Reviewing", encrypted: "signature" }]),
+        2,
+      ),
+    ]);
+
+    expect(events.filter((event) => event.type === "ContentPart")).toEqual([
+      {
+        type: "ContentPart",
+        payload: { type: "think", think: "Reviewing", encrypted: "signature" },
+        _sessionId: "session-1",
+      },
+    ]);
+  });
+
+  it("renders assistant media when a resumed answer contains media parts", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Show it" }], { origin: { kind: "user" } })),
+      record(
+        message("assistant", [
+          { type: "image_url", imageUrl: { url: "https://example.test/result.png" } },
+          { type: "video_url", videoUrl: { url: "https://example.test/result.mp4" } },
+        ]),
+        2,
+      ),
+    ]);
+
+    expect(events.filter((event) => event.type === "ContentPart")).toEqual([
+      {
+        type: "ContentPart",
+        payload: { type: "image_url", image_url: { url: "https://example.test/result.png" } },
+        _sessionId: "session-1",
+      },
+      {
+        type: "ContentPart",
+        payload: { type: "video_url", video_url: { url: "https://example.test/result.mp4" } },
+        _sessionId: "session-1",
+      },
+    ]);
+  });
+
+  it("maps an assistant tool call to the released tool name", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Read it" }], { origin: { kind: "user" } })),
+      record(
+        message("assistant", [], {
+          toolCalls: [
+            {
+              type: "function",
+              id: "tool-1",
+              name: "Read",
+              arguments: '{"path":"README.md"}',
+            },
+          ],
+        }),
+        2,
+      ),
+    ]);
+
+    expect(events).toContainEqual({
+      type: "ToolCall",
+      payload: {
+        type: "function",
+        id: "tool-1",
+        function: { name: "ReadFile", arguments: '{"path":"README.md"}' },
+      },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("renders a failed tool result in the open turn", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Run it" }], { origin: { kind: "user" } })),
+      record(
+        message("tool", [{ type: "text", text: "command failed" }], {
+          toolCallId: "tool-1",
+          isError: true,
+        }),
+        2,
+      ),
+    ]);
+
+    expect(events).toContainEqual({
+      type: "ToolResult",
+      payload: {
+        tool_call_id: "tool-1",
+        return_value: {
+          is_error: true,
+          output: [{ type: "text", text: "command failed" }],
+          message: "",
+          display: [],
+        },
+      },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("closes a completed compaction when its replay record has a result", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Continue" }], { origin: { kind: "user" } })),
+      {
+        type: "compaction",
+        time: 2,
+        result: {
+          summary: "Earlier work",
+          compactedCount: 6,
+          tokensBefore: 1000,
+          tokensAfter: 200,
+        },
+      },
+    ]);
+
+    expect(events.filter((event) => event.type.startsWith("Compaction"))).toEqual([
+      { type: "CompactionBegin", payload: {}, _sessionId: "session-1" },
+      { type: "CompactionEnd", payload: {}, _sessionId: "session-1" },
+    ]);
+  });
+
+  it("leaves an unfinished compaction open when its replay record has no result", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Continue" }], { origin: { kind: "user" } })),
+      { type: "compaction", time: 2, instruction: "Keep decisions" },
+    ]);
+
+    expect(events.filter((event) => event.type.startsWith("Compaction"))).toEqual([
+      { type: "CompactionBegin", payload: {}, _sessionId: "session-1" },
+    ]);
+  });
+
+  it("renders plan mode when replay records a plan update inside a turn", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "Make a plan" }], { origin: { kind: "user" } })),
+      { type: "plan_updated", time: 2, enabled: true },
+    ]);
+
+    expect(events).toContainEqual({
+      type: "StatusUpdate",
+      payload: { plan_mode: true },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("separates consecutive user prompts into independently completed turns", () => {
+    const events = replay([
+      record(message("user", [{ type: "text", text: "First" }], { origin: { kind: "user" } }), 1),
+      record(message("assistant", [{ type: "text", text: "One" }]), 2),
+      record(message("user", [{ type: "text", text: "Second" }], { origin: { kind: "user" } }), 3),
+      record(message("assistant", [{ type: "text", text: "Two" }]), 4),
+    ]);
+
+    expect(events.filter((event) => event.type !== "StatusUpdate").map((event) => event.type)).toEqual([
+      "TurnBegin",
+      "StepBegin",
+      "ContentPart",
+      "stream_complete",
+      "TurnBegin",
+      "StepBegin",
+      "ContentPart",
+      "stream_complete",
+    ]);
+  });
+
+  it("does not expose an injected user message in resumed history", () => {
+    const events = replay([
+      record(
+        message("user", [{ type: "text", text: "<system>hidden reminder</system>" }], {
+          origin: { kind: "injection", variant: "system_reminder" },
+        }),
+      ),
+      record(message("user", [{ type: "text", text: "Visible prompt" }], { origin: { kind: "user" } }), 2),
+    ]);
+
+    expect(events.filter((event) => event.type === "TurnBegin")).toEqual([
+      {
+        type: "TurnBegin",
+        payload: { user_input: [{ type: "text", text: "Visible prompt" }] },
+        _sessionId: "session-1",
+      },
+    ]);
+  });
+
+  it("restores a user-invoked skill as its original slash command", () => {
+    const events = replay([
+      record(
+        message("user", [{ type: "text", text: "<expanded skill prompt>" }], {
+          origin: {
+            kind: "skill_activation",
+            activationId: "activation-1",
+            skillName: "review",
+            skillArgs: "focus on errors",
+            trigger: "user-slash",
+          },
+        }),
+      ),
+    ]);
+
+    expect(events).toContainEqual({
+      type: "TurnBegin",
+      payload: { user_input: [{ type: "text", text: "/skill:review focus on errors" }] },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("restores imported context as the original command and confirmation", () => {
+    const events = replay([
+      record(
+        message(
+          "user",
+          [
+            {
+              type: "text",
+              text: "<system>The user imported prior context.</system>",
+            },
+            {
+              type: "text",
+              text: '<imported_context source="file &apos;notes.md&apos;">\nPrior decision.\n</imported_context>',
+            },
+          ],
+          { origin: { kind: "user" } },
+        ),
+      ),
+    ]);
+
+    expect(events).toContainEqual({
+      type: "TurnBegin",
+      payload: { user_input: [{ type: "text", text: "/import notes.md" }] },
+      _sessionId: "session-1",
+    });
+    expect(events).toContainEqual({
+      type: "ContentPart",
+      payload: { type: "text", text: "Imported context from file 'notes.md' (15 chars)." },
+      _sessionId: "session-1",
+    });
+    expect(JSON.stringify(events)).not.toContain("Prior decision.");
+  });
+
+  it("does not count a model-invoked skill as a user-visible fork turn", () => {
+    const records: AgentReplayRecord[] = [
+      record(
+        message("user", [{ type: "text", text: "<expanded nested skill>" }], {
+          origin: {
+            kind: "skill_activation",
+            activationId: "activation-model",
+            skillName: "helper",
+            trigger: "model-tool",
+          },
+        }),
+      ),
+    ];
+
+    expect(replayRecordTurnCount(records)).toBe(0);
+    expect(replay(records).filter((event) => event.type === "TurnBegin")).toEqual([]);
+  });
+
+  it("counts only visible prompts when replay reports the number of turns", () => {
+    const records: AgentReplayRecord[] = [
+      record(message("user", [{ type: "text", text: "First" }], { origin: { kind: "user" } }), 1),
+      record(
+        message("user", [{ type: "text", text: "Hidden" }], {
+          origin: { kind: "injection", variant: "system_reminder" },
+        }),
+        2,
+      ),
+      record(
+        message("user", [{ type: "text", text: "/review" }], {
+          origin: {
+            kind: "plugin_command",
+            activationId: "activation-1",
+            pluginId: "review-plugin",
+            commandName: "review",
+            trigger: "user-slash",
+          },
+        }),
+        3,
+      ),
+    ];
+
+    expect(replayRecordTurnCount(records)).toBe(2);
+  });
+
+  it("routes repeated runs of one subagent to their corresponding Agent calls", () => {
+    const main = resumedAgent([
+      record(message("user", [{ type: "text", text: "First" }], { origin: { kind: "user" } }), 1),
+      record(message("assistant", [], {
+        toolCalls: [{ type: "function", id: "agent-call-1", name: "Agent", arguments: "{}" }],
+      }), 2),
+      record(message("tool", [{ type: "text", text: "agent_id: sub-1\nstatus: completed" }], {
+        toolCallId: "agent-call-1",
+      }), 5),
+      record(message("user", [{ type: "text", text: "Second" }], { origin: { kind: "user" } }), 10),
+      record(message("assistant", [], {
+        toolCalls: [{ type: "function", id: "agent-call-2", name: "Agent", arguments: "{}" }],
+      }), 11),
+      record(message("tool", [{ type: "text", text: "agent_id: sub-1\nstatus: completed" }], {
+        toolCallId: "agent-call-2",
+      }), 14),
+    ]);
+    const child = resumedAgent([
+      record(message("user", [{ type: "text", text: "child one" }], {
+        origin: { kind: "system_trigger", name: "subagent" },
+      }), 3),
+      record(message("assistant", [{ type: "text", text: "first child answer" }]), 4),
+      record(message("user", [{ type: "text", text: "child two" }], {
+        origin: { kind: "system_trigger", name: "subagent" },
+      }), 12),
+      record(message("assistant", [{ type: "text", text: "second child answer" }]), 13),
+    ], { type: "sub" });
+    const state: ResumedSessionState = {
+      sessionMetadata: {
+        createdAt: "",
+        updatedAt: "",
+        title: "",
+        isCustomTitle: false,
+        agents: {
+          main: { type: "main", parentAgentId: null },
+          "sub-1": { type: "sub", parentAgentId: "main" },
+        },
+        custom: {},
+      },
+      agents: { main, "sub-1": child },
+    };
+
+    const events = replaySessionToWebviewEvents(state, "session-1");
+
+    expect(events).toContainEqual(expect.objectContaining({
+      type: "SubagentEvent",
+      payload: {
+        parent_tool_call_id: "agent-call-1",
+        event: { type: "ContentPart", payload: { type: "text", text: "first child answer" } },
+      },
+    }));
+    expect(events).toContainEqual(expect.objectContaining({
+      type: "SubagentEvent",
+      payload: {
+        parent_tool_call_id: "agent-call-2",
+        event: { type: "ContentPart", payload: { type: "text", text: "second child answer" } },
+      },
+    }));
+  });
+});
diff --git a/apps/vscode/test/replay-resume.integration.test.ts b/apps/vscode/test/replay-resume.integration.test.ts
new file mode 100644
index 000000000..01706ea44
--- /dev/null
+++ b/apps/vscode/test/replay-resume.integration.test.ts
@@ -0,0 +1,317 @@
+/**
+ * Scenario: persisted Node SDK sessions are reopened and rendered by the VS Code replay adapter.
+ * Responsibilities: restored tool displays and child-agent steps through the public resume state.
+ * Wiring: Node SDK, core, storage, and HTTP provider adapter are real; only the remote provider is local.
+ * Run: pnpm --filter kimi-code exec vitest run --config vitest.config.ts test/replay-resume.integration.test.ts
+ */
+
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  createKimiHarness,
+  type Event,
+  type KimiHarness,
+  type Session,
+} from "@moonshot-ai/kimi-code-sdk";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  createFakeProviderHarness,
+  type FakeProviderHarness,
+} from "../../../packages/kosong/test/e2e/fake-provider-harness";
+import { replaySessionToWebviewEvents } from "../src/runtime/replay-adapter";
+
+const MODEL_ALIAS = "vscode-replay-test";
+
+interface ReplayRig {
+  readonly rootDir: string;
+  readonly workDir: string;
+  readonly harness: KimiHarness;
+  readonly provider: FakeProviderHarness;
+}
+
+const cleanups: Array<() => Promise<void>> = [];
+
+afterEach(async () => {
+  while (cleanups.length > 0) await cleanups.pop()?.();
+});
+
+async function createReplayRig(): Promise<ReplayRig> {
+  const rootDir = await mkdtemp(join(tmpdir(), "kimi-vscode-replay-"));
+  const homeDir = join(rootDir, "home");
+  const workDir = join(rootDir, "workspace");
+  await Promise.all([mkdir(homeDir), mkdir(workDir)]);
+  const provider = await createFakeProviderHarness();
+  const harness = createKimiHarness({
+    homeDir,
+    identity: { userAgentProduct: "kimi-code-vscode", version: "test" },
+  });
+  await harness.setConfig({
+    providers: {
+      local: {
+        type: "kimi",
+        baseUrl: `${provider.baseUrl}/v1`,
+        apiKey: "sk-test",
+      },
+    },
+    models: {
+      [MODEL_ALIAS]: {
+        provider: "local",
+        model: "mock-model",
+        maxContextSize: 128_000,
+      },
+    },
+    defaultModel: MODEL_ALIAS,
+  });
+  cleanups.push(async () => {
+    try {
+      await harness.close();
+    } finally {
+      try {
+        await provider.close();
+      } finally {
+        await rm(rootDir, { recursive: true, force: true });
+      }
+    }
+  });
+  return { rootDir, workDir, harness, provider };
+}
+
+function completionChunk(
+  delta: Record<string, unknown>,
+  finishReason: string | null = null,
+): Record<string, unknown> {
+  return {
+    id: "chatcmpl-vscode-replay",
+    object: "chat.completion.chunk",
+    created: 1,
+    model: "mock-model",
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  };
+}
+
+async function runPrompt(session: Session, prompt: string): Promise<void> {
+  const ended = waitForEvent(
+    session,
+    (event) => event.type === "turn.ended" && event.agentId === "main",
+  );
+  await session.prompt(prompt);
+  await ended;
+}
+
+function waitForEvent(
+  session: Session,
+  predicate: (event: Event) => boolean,
+): Promise<Event> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      unsubscribe();
+      reject(new Error("Timed out waiting for session event"));
+    }, 5_000);
+    const unsubscribe = session.onEvent((event) => {
+      if (!predicate(event)) return;
+      clearTimeout(timeout);
+      unsubscribe();
+      resolve(event);
+    });
+  });
+}
+
+describe("VS Code replay from a public Node SDK resume state", () => {
+  it("restores persisted file and todo displays", async () => {
+    const rig = await createReplayRig();
+    const filePath = join(rig.workDir, "sample.txt");
+    await writeFile(filePath, "before\n", "utf8");
+    let requestCount = 0;
+    rig.provider.route("POST", "/v1/chat/completions", async (_request, reply) => {
+      requestCount += 1;
+      if (requestCount === 1) {
+        await reply.sseJson(200, [
+          completionChunk({
+            tool_calls: [
+              {
+                index: 0,
+                id: "edit-call-1",
+                type: "function",
+                function: {
+                  name: "Edit",
+                  arguments: JSON.stringify({
+                    path: "sample.txt",
+                    old_string: "before",
+                    new_string: "after",
+                  }),
+                },
+              },
+              {
+                index: 1,
+                id: "write-call-1",
+                type: "function",
+                function: {
+                  name: "Write",
+                  arguments: JSON.stringify({
+                    path: "created.txt",
+                    content: "created content\n",
+                  }),
+                },
+              },
+              {
+                index: 2,
+                id: "todo-call-1",
+                type: "function",
+                function: {
+                  name: "TodoList",
+                  arguments: JSON.stringify({
+                    todos: [{ title: "Verify resume", status: "done" }],
+                  }),
+                },
+              },
+            ],
+          }),
+          completionChunk({}, "tool_calls"),
+        ]);
+        return;
+      }
+      await reply.sseJson(200, [
+        completionChunk({ content: "Changes complete." }),
+        completionChunk({}, "stop"),
+      ]);
+    });
+    const session = await rig.harness.createSession({
+      id: "ses_vscode_replay_displays",
+      workDir: rig.workDir,
+      model: MODEL_ALIAS,
+    });
+    await session.setPermission("yolo");
+    await runPrompt(session, "Update the file and checklist");
+    await session.close();
+
+    const resumed = await rig.harness.resumeSession({
+      id: session.id,
+      includeSubagents: true,
+    });
+    const state = resumed.getResumeState();
+    if (state === undefined) throw new Error("Expected public resume state");
+    const events = replaySessionToWebviewEvents(state, resumed.id);
+
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        type: "ToolResult",
+        payload: expect.objectContaining({
+          tool_call_id: "write-call-1",
+          return_value: expect.objectContaining({
+            display: [{
+              type: "diff",
+              path: join(rig.workDir, "created.txt"),
+              old_text: "",
+              new_text: "created content\n",
+            }],
+          }),
+        }),
+      }),
+    );
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        type: "ToolResult",
+        payload: expect.objectContaining({
+          tool_call_id: "edit-call-1",
+          return_value: expect.objectContaining({
+            display: [{ type: "diff", path: filePath, old_text: "before", new_text: "after" }],
+          }),
+        }),
+      }),
+    );
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        type: "ToolResult",
+        payload: expect.objectContaining({
+          tool_call_id: "todo-call-1",
+          return_value: expect.objectContaining({
+            display: [{
+              type: "todo",
+              items: [{ title: "Verify resume", status: "done" }],
+            }],
+          }),
+        }),
+      }),
+    );
+  });
+
+  it("restores a child step under its original Agent tool call", async () => {
+    const rig = await createReplayRig();
+    const childAnswer = `Subagent restored evidence. ${"Detailed persisted finding. ".repeat(10)}`;
+    let requestCount = 0;
+    rig.provider.route("POST", "/v1/chat/completions", async (_request, reply) => {
+      requestCount += 1;
+      if (requestCount === 1) {
+        await reply.sseJson(200, [
+          completionChunk({
+            tool_calls: [{
+              index: 0,
+              id: "agent-call-1",
+              type: "function",
+              function: {
+                name: "Agent",
+                arguments: JSON.stringify({
+                  prompt: "Inspect the workspace and report one finding.",
+                  description: "inspect workspace",
+                  subagent_type: "coder",
+                  run_in_background: false,
+                }),
+              },
+            }],
+          }),
+          completionChunk({}, "tool_calls"),
+        ]);
+        return;
+      }
+      if (requestCount === 2) {
+        await reply.sseJson(200, [
+          completionChunk({ content: childAnswer }),
+          completionChunk({}, "stop"),
+        ]);
+        return;
+      }
+      await reply.sseJson(200, [
+        completionChunk({ content: "Parent received the finding." }),
+        completionChunk({}, "stop"),
+      ]);
+    });
+    const session = await rig.harness.createSession({
+      id: "ses_vscode_replay_subagent",
+      workDir: rig.workDir,
+      model: MODEL_ALIAS,
+    });
+    await session.setPermission("yolo");
+    await runPrompt(session, "Delegate this inspection");
+    await session.close();
+
+    const resumed = await rig.harness.resumeSession({
+      id: session.id,
+      includeSubagents: true,
+    });
+    const state = resumed.getResumeState();
+    if (state === undefined) throw new Error("Expected public resume state");
+    const events = replaySessionToWebviewEvents(state, resumed.id);
+
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        type: "SubagentEvent",
+        payload: {
+          parent_tool_call_id: "agent-call-1",
+          event: { type: "StepBegin", payload: { n: 1 } },
+        },
+      }),
+    );
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        type: "SubagentEvent",
+        payload: {
+          parent_tool_call_id: "agent-call-1",
+          event: { type: "ContentPart", payload: { type: "text", text: childAnswer } },
+        },
+      }),
+    );
+  });
+});
diff --git a/apps/vscode/test/session-runtime.test.ts b/apps/vscode/test/session-runtime.test.ts
new file mode 100644
index 000000000..6caadfabb
--- /dev/null
+++ b/apps/vscode/test/session-runtime.test.ts
@@ -0,0 +1,733 @@
+/**
+ * Scenario: one VS Code session runtime adapts the public Node SDK session for one or more Webviews.
+ * Responsibilities: prompt conversion, event/terminal delivery, reverse RPC, cancellation, and baseline capture.
+ * Wiring: SessionRuntime is real; a small in-memory Session implements only the public SDK boundary.
+ * Run: pnpm exec vitest run --config apps/vscode/vitest.config.ts apps/vscode/test/session-runtime.test.ts
+ */
+
+import type {
+  ApprovalHandler,
+  ApprovalRequest,
+  Event,
+  JsonObject,
+  PermissionMode,
+  PromptInput,
+  QuestionHandler,
+  QuestionRequest,
+  Session,
+  SessionSummary,
+} from "@moonshot-ai/kimi-code-sdk";
+import { describe, expect, it } from "vitest";
+
+import { Events } from "../shared/bridge";
+import type { LegacyApprovalFlags } from "../src/runtime/legacy-approval";
+import { SessionRuntime } from "../src/runtime/session-runtime";
+
+interface BroadcastRecord {
+  readonly event: string;
+  readonly data: unknown;
+  readonly webviewId?: string;
+}
+
+interface BaselineRecord {
+  readonly session: Pick<SessionSummary, "id" | "workDir" | "metadata">;
+  readonly filePath: string;
+  readonly webviewIds: readonly string[];
+}
+
+interface FakeSessionBoundary {
+  readonly session: Session;
+  readonly promptInputs: Array<string | PromptInput>;
+  readonly steerInputs: Array<string | PromptInput>;
+  readonly handlerInstallations: { approval: number; question: number };
+  readonly metadataUpdates: JsonObject[];
+  readonly setPermissions: PermissionMode[];
+  readonly subscriptionCount: () => number;
+  readonly cancelCount: () => number;
+  readonly cancelCompactionCount: () => number;
+  readonly closeCount: () => number;
+  emit(event: Event): void;
+  rejectNextPrompt(error: Error): void;
+  rejectNextMetadataUpdate(error: Error): void;
+  requestApproval(request: ApprovalRequest): Promise<Awaited<ReturnType<ApprovalHandler>>>;
+  requestQuestion(request: QuestionRequest): Promise<Awaited<ReturnType<QuestionHandler>>>;
+}
+
+const DEFAULT_LEGACY_APPROVAL: LegacyApprovalFlags = { yolo: false, afk: false };
+
+function createFakeSession(): FakeSessionBoundary {
+  const listeners = new Set<(event: Event) => void>();
+  const promptInputs: Array<string | PromptInput> = [];
+  const steerInputs: Array<string | PromptInput> = [];
+  const handlerInstallations = { approval: 0, question: 0 };
+  const metadataUpdates: JsonObject[] = [];
+  const setPermissions: PermissionMode[] = [];
+  let approvalHandler: ApprovalHandler | undefined;
+  let questionHandler: QuestionHandler | undefined;
+  let nextPromptError: Error | undefined;
+  let nextMetadataError: Error | undefined;
+  let subscriptions = 0;
+  let cancellations = 0;
+  let compactionCancellations = 0;
+  let closes = 0;
+  let permission: PermissionMode = "manual";
+
+  const summary: SessionSummary = {
+    id: "session-1",
+    workDir: "/workspace",
+    sessionDir: "/home/sessions/session-1",
+    createdAt: 1,
+    updatedAt: 2,
+    metadata: { source: "vscode-test" },
+  };
+
+  const session = {
+    id: summary.id,
+    workDir: summary.workDir,
+    summary,
+    setApprovalHandler(handler: ApprovalHandler | undefined) {
+      approvalHandler = handler;
+      if (handler !== undefined) handlerInstallations.approval += 1;
+    },
+    setQuestionHandler(handler: QuestionHandler | undefined) {
+      questionHandler = handler;
+      if (handler !== undefined) handlerInstallations.question += 1;
+    },
+    onEvent(listener: (event: Event) => void) {
+      subscriptions += 1;
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async prompt(input: string | PromptInput) {
+      promptInputs.push(input);
+      if (nextPromptError !== undefined) {
+        const error = nextPromptError;
+        nextPromptError = undefined;
+        throw error;
+      }
+    },
+    async steer(input: string | PromptInput) {
+      steerInputs.push(input);
+    },
+    async cancel() {
+      cancellations += 1;
+    },
+    async cancelCompaction() {
+      compactionCancellations += 1;
+    },
+    async getStatus() {
+      return {
+        thinkingEffort: "off",
+        permission,
+        planMode: false,
+        contextTokens: 0,
+        maxContextTokens: 128_000,
+        contextUsage: 0,
+      };
+    },
+    async setPermission(mode: PermissionMode) {
+      permission = mode;
+      setPermissions.push(mode);
+    },
+    async updateMetadata(patch: JsonObject) {
+      if (nextMetadataError !== undefined) {
+        const error = nextMetadataError;
+        nextMetadataError = undefined;
+        throw error;
+      }
+      metadataUpdates.push(patch);
+    },
+    async close() {
+      closes += 1;
+    },
+  } as unknown as Session;
+
+  return {
+    session,
+    promptInputs,
+    steerInputs,
+    handlerInstallations,
+    metadataUpdates,
+    setPermissions,
+    subscriptionCount: () => subscriptions,
+    cancelCount: () => cancellations,
+    cancelCompactionCount: () => compactionCancellations,
+    closeCount: () => closes,
+    emit(event) {
+      for (const listener of listeners) listener(event);
+    },
+    rejectNextPrompt(error) {
+      nextPromptError = error;
+    },
+    rejectNextMetadataUpdate(error) {
+      nextMetadataError = error;
+    },
+    async requestApproval(request) {
+      if (approvalHandler === undefined) throw new Error("Approval handler is unavailable");
+      return approvalHandler(request);
+    },
+    async requestQuestion(request) {
+      if (questionHandler === undefined) throw new Error("Question handler is unavailable");
+      return questionHandler(request);
+    },
+  };
+}
+
+function createRuntime(legacyApproval = DEFAULT_LEGACY_APPROVAL) {
+  const sdk = createFakeSession();
+  const broadcasts: BroadcastRecord[] = [];
+  const baselines: BaselineRecord[] = [];
+  const runtime = new SessionRuntime({
+    session: sdk.session,
+    legacyApproval,
+    broadcast: (event, data, webviewId) => broadcasts.push({ event, data, webviewId }),
+    captureBaseline: (session, filePath, webviewIds) => {
+      baselines.push({ session, filePath, webviewIds });
+    },
+    log: () => undefined,
+  });
+  runtime.subscribe("view-1");
+  return { runtime, sdk, broadcasts, baselines };
+}
+
+function streamData(records: readonly BroadcastRecord[]): unknown[] {
+  return records.filter((record) => record.event === Events.StreamEvent).map((record) => record.data);
+}
+
+function turnStarted(): Event {
+  return {
+    type: "turn.started",
+    sessionId: "session-1",
+    agentId: "main",
+    turnId: 7,
+    origin: { kind: "user" },
+  };
+}
+
+function turnEnded(
+  reason: "completed" | "cancelled" | "failed",
+  error?: Extract<Event, { type: "turn.ended" }>["error"],
+): Event {
+  return {
+    type: "turn.ended",
+    sessionId: "session-1",
+    agentId: "main",
+    turnId: 7,
+    reason,
+    error,
+  };
+}
+
+describe("session runtime (adapts one SDK session for subscribed Webviews)", () => {
+  it("renders a host-only command without making it a forkable core turn", () => {
+    const { runtime, broadcasts } = createRuntime();
+
+    runtime.beginHostAction("/clear");
+    runtime.emitHostText("The context has been cleared.");
+    runtime.completeHostAction();
+
+    expect(streamData(broadcasts)).toEqual([
+      {
+        type: "TurnBegin",
+        payload: { user_input: "/clear", forkable: false },
+        _sessionId: "session-1",
+      },
+      { type: "StepBegin", payload: { n: 1 }, _sessionId: "session-1" },
+      {
+        type: "ContentPart",
+        payload: { type: "text", text: "The context has been cleared." },
+        _sessionId: "session-1",
+      },
+      {
+        type: "stream_complete",
+        result: { status: "finished" },
+        _sessionId: "session-1",
+      },
+    ]);
+  });
+
+  it("cancels a long-running host action and ignores its late completion", async () => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+    const actionId = runtime.beginHostAction("/init");
+
+    await runtime.cancel();
+    runtime.emitHostText("AGENTS.md has been generated.", actionId);
+    runtime.completeHostAction("finished", actionId);
+
+    expect(sdk.cancelCount()).toBe(1);
+    expect(sdk.cancelCompactionCount()).toBe(1);
+    expect(streamData(broadcasts)).toContainEqual({
+      type: "stream_complete",
+      result: { status: "cancelled" },
+      _sessionId: "session-1",
+    });
+    expect(JSON.stringify(streamData(broadcasts))).not.toContain("has been generated");
+  });
+
+  it("does not let a cancelled action finish a newer host command", async () => {
+    const { runtime, broadcasts } = createRuntime();
+    const initAction = runtime.beginHostAction("/init");
+    await runtime.cancel();
+    const clearAction = runtime.beginHostAction("/clear");
+
+    runtime.emitHostText("late init result", initAction);
+    runtime.completeHostAction("finished", initAction);
+
+    expect(runtime.isBusy).toBe(true);
+    runtime.emitHostText("The context has been cleared.", clearAction);
+    runtime.completeHostAction("finished", clearAction);
+    expect(runtime.isBusy).toBe(false);
+    expect(JSON.stringify(streamData(broadcasts))).not.toContain("late init result");
+  });
+
+  it("waits for the cancelled turn to settle before running an exclusive operation", async () => {
+    const { runtime, sdk } = createRuntime();
+    const prompt = runtime.prompt("keep working");
+    sdk.emit(turnStarted());
+    let operationStarted = false;
+
+    const operation = runtime.runExclusiveAfterCancelling(async () => {
+      operationStarted = true;
+      return "forked";
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(sdk.cancelCount()).toBe(1);
+    expect(operationStarted).toBe(false);
+    expect(runtime.isBusy).toBe(true);
+
+    sdk.emit(turnEnded("cancelled"));
+
+    await expect(prompt).resolves.toEqual({ status: "cancelled" });
+    await expect(operation).resolves.toBe("forked");
+    expect(operationStarted).toBe(true);
+    expect(runtime.isBusy).toBe(false);
+  });
+
+  it("keeps a public turn action attached to its original slash input", async () => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+
+    const result = runtime.runTurnAction("/skill:review carefully", async () => {
+      sdk.emit(turnStarted());
+      sdk.emit(turnEnded("completed"));
+    });
+
+    await expect(result).resolves.toEqual({ status: "finished" });
+    expect(streamData(broadcasts)).toContainEqual({
+      type: "TurnBegin",
+      payload: { user_input: "/skill:review carefully" },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("converts legacy media keys when a prompt crosses the SDK boundary", async () => {
+    const { runtime, sdk } = createRuntime();
+    const completion = runtime.prompt([
+      { type: "text", text: "Describe these files" },
+      { type: "image_url", image_url: { url: "data:image/png;base64,AA", id: "image-1" } },
+      { type: "video_url", video_url: { url: "file:///workspace/demo.mp4", id: "video-1" } },
+    ]);
+
+    sdk.emit(turnStarted());
+    sdk.emit(turnEnded("completed"));
+    await completion;
+
+    expect(sdk.promptInputs).toEqual([
+      [
+        { type: "text", text: "Describe these files" },
+        { type: "image_url", imageUrl: { url: "data:image/png;base64,AA", id: "image-1" } },
+        { type: "video_url", videoUrl: { url: "file:///workspace/demo.mp4", id: "video-1" } },
+      ],
+    ]);
+  });
+
+  it("broadcasts assistant text when the SDK streams a text delta", () => {
+    const { sdk, broadcasts } = createRuntime();
+
+    sdk.emit({
+      type: "assistant.delta",
+      sessionId: "session-1",
+      agentId: "main",
+      turnId: 7,
+      delta: "Implemented",
+    });
+
+    expect(streamData(broadcasts)).toContainEqual({
+      type: "ContentPart",
+      payload: { type: "text", text: "Implemented" },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("broadcasts model thinking when the SDK streams a thinking delta", () => {
+    const { sdk, broadcasts } = createRuntime();
+
+    sdk.emit({
+      type: "thinking.delta",
+      sessionId: "session-1",
+      agentId: "main",
+      turnId: 7,
+      delta: "Checking the edge case",
+    });
+
+    expect(streamData(broadcasts)).toContainEqual({
+      type: "ContentPart",
+      payload: { type: "think", think: "Checking the edge case" },
+      _sessionId: "session-1",
+    });
+  });
+
+  it("broadcasts a legacy tool call when an SDK tool starts", () => {
+    const { sdk, broadcasts } = createRuntime();
+
+    sdk.emit({
+      type: "tool.call.started",
+      sessionId: "session-1",
+      agentId: "main",
+      turnId: 7,
+      toolCallId: "tool-1",
+      name: "Read",
+      args: { path: "src/index.ts" },
+    });
+
+    expect(streamData(broadcasts)).toContainEqual({
+      type: "ToolCall",
+      payload: {
+        type: "function",
+        id: "tool-1",
+        function: { name: "ReadFile", arguments: '{"path":"src/index.ts"}' },
+      },
+      _sessionId: "session-1",
+    });
+  });
+
+  it.each([
+    ["completed", "finished"],
+    ["cancelled", "cancelled"],
+  ] as const)(
+    "emits one stream completion when a turn ends as %s",
+    async (reason, expectedStatus) => {
+      const { runtime, sdk, broadcasts } = createRuntime();
+      const completion = runtime.prompt("hello");
+      sdk.emit(turnStarted());
+
+      sdk.emit(turnEnded(reason));
+      sdk.emit(turnEnded(reason));
+
+      await expect(completion).resolves.toEqual({ status: expectedStatus });
+      expect(
+        streamData(broadcasts).filter(
+          (event) =>
+            typeof event === "object" &&
+            event !== null &&
+            "type" in event &&
+            event.type === "stream_complete",
+        ),
+      ).toEqual([
+        {
+          type: "stream_complete",
+          result: { status: expectedStatus },
+          _sessionId: "session-1",
+        },
+      ]);
+    },
+  );
+
+  it("emits one error when a failed turn terminal is repeated", async () => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+    const completion = runtime.prompt("hello");
+    const error = {
+      code: "provider.api_error" as const,
+      message: "Provider rejected the request",
+      retryable: true,
+    };
+    sdk.emit(turnStarted());
+
+    sdk.emit(turnEnded("failed", error));
+    sdk.emit(turnEnded("failed", error));
+
+    await expect(completion).resolves.toEqual({ status: "failed" });
+    expect(
+      streamData(broadcasts).filter(
+        (event) =>
+          typeof event === "object" && event !== null && "type" in event && event.type === "error",
+      ),
+    ).toHaveLength(1);
+  });
+
+  it("suppresses the trailing SDK error when a failed terminal already reported the same error", async () => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+    const completion = runtime.prompt("hello");
+    const error = {
+      code: "provider.api_error" as const,
+      message: "Provider rejected the request",
+      retryable: true,
+    };
+    sdk.emit(turnStarted());
+
+    sdk.emit(turnEnded("failed", error));
+    sdk.emit({
+      type: "error",
+      sessionId: "session-1",
+      agentId: "main",
+      ...error,
+    });
+
+    await completion;
+    expect(
+      streamData(broadcasts).filter(
+        (event) =>
+          typeof event === "object" && event !== null && "type" in event && event.type === "error",
+      ),
+    ).toHaveLength(1);
+  });
+
+  it("reports a preflight error when SDK prompt setup throws before turn start", async () => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+    sdk.rejectNextPrompt(new Error("Unable to initialize provider"));
+
+    await expect(runtime.prompt("hello")).resolves.toEqual({ status: "failed" });
+
+    expect(streamData(broadcasts)).toContainEqual({
+      type: "error",
+      code: "internal",
+      message: "Internal error occurred.",
+      detail: "Unable to initialize provider",
+      phase: "preflight",
+      _sessionId: "session-1",
+    });
+  });
+
+  it("requests SDK cancellation when the active response is stopped", async () => {
+    const { runtime, sdk } = createRuntime();
+    void runtime.prompt("hello");
+
+    await runtime.cancel();
+
+    expect(sdk.cancelCount()).toBe(1);
+  });
+
+  it("converts legacy media keys when steering an active response", async () => {
+    const { runtime, sdk } = createRuntime();
+    void runtime.prompt("hello");
+
+    await runtime.steer([
+      { type: "text", text: "Use this instead" },
+      { type: "image_url", image_url: { url: "file:///workspace/new.png" } },
+    ]);
+
+    expect(sdk.steerInputs).toEqual([
+      [
+        { type: "text", text: "Use this instead" },
+        { type: "image_url", imageUrl: { url: "file:///workspace/new.png" } },
+      ],
+    ]);
+  });
+
+  it("echoes a successful steer into the subscribed Webview", async () => {
+    const { runtime, broadcasts } = createRuntime();
+    runtime.subscribe("view-a");
+
+    await runtime.steer("Use this instead");
+
+    expect(streamData(broadcasts)).toContainEqual({
+      type: "SteerInput",
+      payload: { user_input: "Use this instead" },
+      _sessionId: "session-1",
+    });
+  });
+
+  it.each([
+    ["approve", { decision: "approved" }],
+    ["approve_for_session", { decision: "approved", scope: "session" }],
+    ["reject", { decision: "rejected" }],
+  ] as const)("resolves SDK approval when the Webview responds with %s", async (response, expected) => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+    const pending = sdk.requestApproval({
+      toolCallId: "tool-1",
+      toolName: "Bash",
+      action: "Run command",
+      display: { kind: "command", command: "pnpm test" },
+    });
+    const request = streamData(broadcasts).find(
+      (event) =>
+        typeof event === "object" &&
+        event !== null &&
+        "type" in event &&
+        event.type === "ApprovalRequest",
+    ) as { payload: { id: string } };
+
+    expect(runtime.respondApproval(request.payload.id, response)).toBe(true);
+    await expect(pending).resolves.toEqual(expected);
+  });
+
+  it("auto-approves SDK approval requests in legacy yolo mode", async () => {
+    const { sdk, broadcasts } = createRuntime({ yolo: true, afk: false });
+
+    await expect(sdk.requestApproval({
+      toolCallId: "tool-yolo",
+      toolName: "Bash",
+      action: "Run command",
+      display: { kind: "command", command: "pnpm test" },
+    })).resolves.toEqual({ decision: "approved" });
+    expect(streamData(broadcasts)).not.toContainEqual(
+      expect.objectContaining({ type: "ApprovalRequest" }),
+    );
+  });
+
+  it("restores core permission when a legacy flag cannot be persisted", async () => {
+    const { runtime, sdk } = createRuntime();
+    sdk.rejectNextMetadataUpdate(new Error("state is read-only"));
+
+    await expect(runtime.toggleLegacyApproval("afk")).rejects.toThrow("state is read-only");
+
+    expect(sdk.setPermissions).toEqual(["auto", "manual"]);
+    expect(runtime.legacyApprovalFlags).toEqual({ yolo: false, afk: false });
+  });
+
+  it("resolves an SDK question when the Webview submits answers", async () => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+    const pending = sdk.requestQuestion({
+      toolCallId: "question-1",
+      questions: [
+        {
+          question: "Choose a target",
+          header: "Target",
+          options: [{ label: "Tests", description: "Run focused tests" }],
+          multiSelect: false,
+        },
+      ],
+    });
+    const request = streamData(broadcasts).find(
+      (event) =>
+        typeof event === "object" &&
+        event !== null &&
+        "type" in event &&
+        event.type === "QuestionRequest",
+    ) as { payload: { id: string } };
+
+    expect(runtime.respondQuestion(request.payload.id, { "Choose a target": "Tests" })).toBe(true);
+    await expect(pending).resolves.toEqual({ answers: { "Choose a target": "Tests" } });
+  });
+
+  it("keeps SDK questions interactive in legacy yolo mode", async () => {
+    const { runtime, sdk, broadcasts } = createRuntime({ yolo: true, afk: false });
+    const pending = sdk.requestQuestion({
+      toolCallId: "question-yolo",
+      questions: [
+        {
+          question: "Continue?",
+          options: [{ label: "Yes" }],
+          multiSelect: false,
+        },
+      ],
+    });
+    const request = streamData(broadcasts).find(
+      (event) =>
+        typeof event === "object" &&
+        event !== null &&
+        "type" in event &&
+        event.type === "QuestionRequest",
+    ) as { payload: { id: string } };
+
+    expect(runtime.respondQuestion(request.payload.id, { "Continue?": "Yes" })).toBe(true);
+    await expect(pending).resolves.toEqual({ answers: { "Continue?": "Yes" } });
+  });
+
+  it("cancels a pending SDK approval when the session closes", async () => {
+    const { runtime, sdk } = createRuntime();
+    const pending = sdk.requestApproval({
+      toolCallId: "tool-1",
+      toolName: "Bash",
+      action: "Run command",
+      display: { kind: "command", command: "pnpm test" },
+    });
+
+    await runtime.close();
+
+    await expect(pending).resolves.toEqual({
+      decision: "cancelled",
+      feedback: "Session closed",
+    });
+  });
+
+  it("cancels a pending SDK question when the session closes", async () => {
+    const { runtime, sdk } = createRuntime();
+    const pending = sdk.requestQuestion({
+      questions: [
+        { question: "Continue?", options: [{ label: "Yes" }], multiSelect: false },
+      ],
+    });
+
+    await runtime.close();
+
+    await expect(pending).resolves.toBeNull();
+  });
+
+  it("fans out one SDK subscription to every Webview attached to the session", () => {
+    const { runtime, sdk, broadcasts } = createRuntime();
+    runtime.subscribe("view-2");
+
+    sdk.emit({
+      type: "assistant.delta",
+      sessionId: "session-1",
+      agentId: "main",
+      turnId: 7,
+      delta: "Shared update",
+    });
+
+    expect(sdk.subscriptionCount()).toBe(1);
+    expect(sdk.handlerInstallations).toEqual({ approval: 1, question: 1 });
+    expect(broadcasts.map((record) => record.webviewId)).toEqual(["view-1", "view-2"]);
+  });
+
+  it.each(["Write", "Edit"] as const)(
+    "captures the original file when %s starts with a path",
+    (name) => {
+      const { sdk, baselines } = createRuntime();
+
+      sdk.emit({
+        type: "tool.call.started",
+        sessionId: "session-1",
+        agentId: "main",
+        turnId: 7,
+        toolCallId: "tool-1",
+        name,
+        args: { path: "src/index.ts" },
+      });
+
+      expect(baselines).toEqual([
+        {
+          session: {
+            id: "session-1",
+            workDir: "/workspace",
+            metadata: { source: "vscode-test" },
+          },
+          filePath: "src/index.ts",
+          webviewIds: ["view-1"],
+        },
+      ]);
+    },
+  );
+
+  it.each([
+    ["Read", { path: "src/index.ts" }],
+    ["Write", {}],
+    ["Edit", { path: "" }],
+  ] as const)("does not capture a baseline when %s receives non-write input %#", (name, args) => {
+    const { sdk, baselines } = createRuntime();
+
+    sdk.emit({
+      type: "tool.call.started",
+      sessionId: "session-1",
+      agentId: "main",
+      turnId: 7,
+      toolCallId: "tool-1",
+      name,
+      args,
+    });
+
+    expect(baselines).toEqual([]);
+  });
+});
diff --git a/apps/vscode/test/settings-store.test.ts b/apps/vscode/test/settings-store.test.ts
new file mode 100644
index 000000000..1978e2df5
--- /dev/null
+++ b/apps/vscode/test/settings-store.test.ts
@@ -0,0 +1,371 @@
+/**
+ * Scenario: Webview state crosses the VS Code bridge during settings changes, MCP edits, and chat failures.
+ * Responsibilities: model metadata and selections remain provider-aware; MCP edits stay lossless; chat errors recover visibly.
+ * Wiring: the real Zustand store and MCP bridge; settings saves, toast, and the VS Code messaging API are the only replaced boundaries.
+ * Run: pnpm exec vitest run --config apps/vscode/vitest.config.ts test/settings-store.test.ts
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { MCP_SECRET_MASK } from "../shared/legacy-sdk";
+
+const boundary = vi.hoisted(() => ({
+  saveConfig: vi.fn(),
+  streamChat: vi.fn(),
+  abortChat: vi.fn(),
+  trackFiles: vi.fn(),
+  toastError: vi.fn(),
+}));
+
+vi.mock("@/services", () => ({
+  bridge: {
+    saveConfig: boundary.saveConfig,
+    streamChat: boundary.streamChat,
+    abortChat: boundary.abortChat,
+    trackFiles: boundary.trackFiles,
+  },
+}));
+vi.mock("@/components/ui/sonner", () => ({
+  toast: { error: boundary.toastError },
+}));
+
+import {
+  getMediaFallbackModel,
+  getModelThinkingMode,
+  groupModelsByProvider,
+  requiresManagedProviderLogin,
+  useSettingsStore,
+} from "../webview-ui/src/stores/settings.store";
+import { useChatStore } from "../webview-ui/src/stores/chat.store";
+
+const MODELS = [
+  { id: "plain", name: "Plain", provider: "managed:kimi-code", capabilities: [] },
+  {
+    id: "reasoning",
+    name: "Reasoning",
+    provider: "managed:kimi-code",
+    capabilities: ["thinking"],
+    support_efforts: ["low", "high"],
+    default_effort: "high",
+  },
+  { id: "always", name: "Always", provider: "managed:kimi-code", capabilities: ["always_thinking"] },
+];
+
+beforeEach(() => {
+  boundary.saveConfig.mockReset();
+  boundary.streamChat.mockReset();
+  boundary.streamChat.mockResolvedValue({ done: false });
+  boundary.abortChat.mockReset();
+  boundary.abortChat.mockResolvedValue({ aborted: true });
+  boundary.trackFiles.mockReset();
+  boundary.toastError.mockReset();
+  useSettingsStore.getState().initModels(MODELS, "plain", false);
+  useChatStore.setState({
+    sessionId: null,
+    messages: [],
+    isStreaming: false,
+    isCompacting: false,
+    handshakeReceived: false,
+    draftMedia: [],
+    lastStatus: null,
+    tokenUsage: { input_other: 0, output: 0, input_cache_read: 0, input_cache_creation: 0 },
+    activeTokenUsage: { input_other: 0, output: 0, input_cache_read: 0, input_cache_creation: 0 },
+    pendingInput: null,
+    queue: [],
+    pendingQuestion: null,
+    planMode: false,
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("Webview model settings persistence", () => {
+  it("persists the selected alias when display names collide across providers", () => {
+    boundary.saveConfig.mockResolvedValue({ ok: true });
+    useSettingsStore.getState().initModels([
+      { id: "openai/shared", name: "Shared", provider: "openai", capabilities: [] },
+      { id: "proxy/shared", name: "Shared", provider: "company-proxy", capabilities: [] },
+    ], "openai/shared", false);
+
+    useSettingsStore.getState().updateModel("proxy/shared");
+
+    expect(boundary.saveConfig).toHaveBeenCalledWith({
+      model: "proxy/shared",
+      thinking: false,
+      effort: "off",
+    });
+  });
+
+  it("rolls back the optimistic model selection when saving fails", async () => {
+    let rejectSave!: (error: Error) => void;
+    boundary.saveConfig.mockReturnValue(new Promise((_resolve, reject) => {
+      rejectSave = reject;
+    }));
+
+    useSettingsStore.getState().updateModel("reasoning");
+    expect(useSettingsStore.getState()).toMatchObject({
+      currentModel: "reasoning",
+      thinkingEffort: "off",
+    });
+
+    rejectSave(new Error("config.toml is read-only"));
+    await vi.waitFor(() => {
+      expect(useSettingsStore.getState()).toMatchObject({
+        currentModel: "plain",
+        thinkingEffort: "off",
+      });
+    });
+    expect(boundary.toastError).toHaveBeenCalledWith(
+      "Failed to save model settings: config.toml is read-only",
+    );
+  });
+
+  it("does not let an older failed save overwrite a newer selection", async () => {
+    let rejectFirst!: (error: Error) => void;
+    boundary.saveConfig
+      .mockReturnValueOnce(new Promise((_resolve, reject) => {
+        rejectFirst = reject;
+      }))
+      .mockResolvedValueOnce({ ok: true });
+
+    useSettingsStore.getState().updateModel("reasoning");
+    useSettingsStore.getState().updateModel("always");
+    rejectFirst(new Error("older request failed"));
+    await Promise.resolve();
+
+    expect(useSettingsStore.getState().currentModel).toBe("always");
+    expect(boundary.toastError).not.toHaveBeenCalled();
+  });
+});
+
+describe("Webview model metadata", () => {
+  it("keeps same-named models in separate provider groups", () => {
+    const groups = groupModelsByProvider([
+      { id: "kimi/shared", name: "Shared", provider: "managed:kimi-code", capabilities: [] },
+      { id: "proxy/shared", name: "Shared", provider: "company-proxy", capabilities: [] },
+    ]);
+
+    expect(groups.map((group) => ({
+      provider: group.provider,
+      label: group.label,
+      models: group.models.map((model) => model.id),
+    }))).toEqual([
+      { provider: "company-proxy", label: "company-proxy", models: ["proxy/shared"] },
+      { provider: "managed:kimi-code", label: "Kimi Code", models: ["kimi/shared"] },
+    ]);
+  });
+
+  it("offers a thinking toggle when a model declares adaptive thinking", () => {
+    expect(getModelThinkingMode({
+      id: "anthropic/claude",
+      name: "Claude",
+      provider: "anthropic",
+      capabilities: [],
+      adaptive_thinking: true,
+    })).toBe("switch");
+  });
+
+  it("prefers a compatible model from the current provider for media fallback", () => {
+    const current = {
+      id: "openai/text",
+      name: "Text",
+      provider: "openai",
+      capabilities: [],
+    };
+    const fallback = getMediaFallbackModel([
+      { id: "other/vision", name: "Vision A", provider: "other", capabilities: ["image_in"] },
+      { id: "openai/vision", name: "Vision B", provider: "openai", capabilities: ["image_in"] },
+    ], current);
+
+    expect(fallback?.id).toBe("openai/vision");
+  });
+
+  it("does not require Kimi login when the default model uses a custom provider", () => {
+    expect(requiresManagedProviderLogin([
+      { id: "local/model", name: "Local", provider: "local", capabilities: [] },
+    ], "local/model", false)).toBe(false);
+  });
+
+  it("requires Kimi login when the default model uses the managed provider", () => {
+    expect(requiresManagedProviderLogin([
+      { id: "kimi/model", name: "Kimi", provider: "managed:kimi-code", capabilities: [] },
+    ], "kimi/model", false)).toBe(true);
+  });
+});
+
+describe("Webview MCP update bridge", () => {
+  it("sends a lossless structured MCP edit request to the extension host", async () => {
+    const posted: unknown[] = [];
+    let receiveMessage: ((event: { data: unknown }) => void) | undefined;
+    vi.stubGlobal("document", {
+      body: { getAttribute: () => "mcp-test-view" },
+    });
+    vi.stubGlobal("window", {
+      addEventListener: (_type: string, listener: (event: { data: unknown }) => void) => {
+        receiveMessage = listener;
+      },
+    });
+    vi.stubGlobal("acquireVsCodeApi", () => ({
+      postMessage: (message: { id: string }) => {
+        posted.push(message);
+        queueMicrotask(() => receiveMessage?.({ data: { id: message.id, result: [] } }));
+      },
+      getState: () => undefined,
+      setState: () => undefined,
+    }));
+    vi.resetModules();
+    const { bridge } = await import("../webview-ui/src/services/bridge");
+
+    await bridge.updateMCPServer("old-name", {
+      name: "new-name",
+      transport: "stdio",
+      command: "C:\\Program Files\\Example MCP\\server.exe",
+      args: ["--config", "C:\\Users\\Example User\\mcp config.json"],
+      env: { SERVICE_TOKEN: MCP_SECRET_MASK, DEBUG: "1" },
+    });
+
+    expect(posted).toEqual([
+      expect.objectContaining({
+        method: "updateMCPServer",
+        webviewId: "mcp-test-view",
+        params: {
+          originalName: "old-name",
+          server: {
+            name: "new-name",
+            transport: "stdio",
+            command: "C:\\Program Files\\Example MCP\\server.exe",
+            args: ["--config", "C:\\Users\\Example User\\mcp config.json"],
+            env: { SERVICE_TOKEN: MCP_SECRET_MASK, DEBUG: "1" },
+          },
+        },
+      }),
+    ]);
+  });
+});
+
+describe("Webview chat error recovery", () => {
+  it("stops the pending state and keeps the input available when session setup fails", () => {
+    useChatStore.getState().sendMessage("retry this request");
+
+    useChatStore.getState().processEvent({
+      type: "error",
+      code: "session.state_invalid",
+      message: "Session data is invalid.",
+      detail: "state.json: Unexpected token at line 4",
+      phase: "preflight",
+    });
+
+    expect(useChatStore.getState()).toMatchObject({
+      isStreaming: false,
+      isCompacting: false,
+      pendingInput: { content: "retry this request", model: "plain" },
+    });
+  });
+
+  it("stops the response and retains provider detail when a running turn fails", () => {
+    useChatStore.getState().sendMessage("start a turn");
+    useChatStore.getState().processEvent({
+      type: "TurnBegin",
+      payload: { user_input: "start a turn" },
+    });
+    useChatStore.getState().processEvent({ type: "StepBegin", payload: { n: 1 } });
+
+    useChatStore.getState().processEvent({
+      type: "error",
+      code: "provider.api_error",
+      message: "Service temporarily unavailable.",
+      detail: "HTTP 400: function name is invalid",
+      phase: "runtime",
+    });
+
+    expect(useChatStore.getState().isStreaming).toBe(false);
+    expect(useChatStore.getState().messages.at(-1)?.inlineError).toEqual({
+      code: "provider.api_error",
+      message: "Service temporarily unavailable.",
+      detail: "HTTP 400: function name is invalid",
+    });
+  });
+});
+
+describe("Webview thinking mode parity with the TUI", () => {
+  it("derives thinking modes from metadata only, mirroring the TUI rules", () => {
+    const base = { id: "m", name: "M", provider: "p", capabilities: [] as string[] };
+    expect(getModelThinkingMode({ ...base, capabilities: ["thinking"], support_efforts: ["low", "high"] })).toBe("effort");
+    expect(getModelThinkingMode({ ...base, capabilities: ["always_thinking"] })).toBe("always");
+    expect(getModelThinkingMode({ ...base, capabilities: ["thinking"] })).toBe("switch");
+    expect(getModelThinkingMode({ ...base, adaptive_thinking: true })).toBe("switch");
+    expect(getModelThinkingMode({ ...base, name: "Kimi Thinking Pro" })).toBe("none");
+    expect(getModelThinkingMode(base)).toBe("none");
+  });
+});
+
+describe("Webview thinking effort parity with the TUI", () => {
+  it("resolves a boolean \"on\" to the model default for effort-capable models", () => {
+    boundary.saveConfig.mockResolvedValue({ ok: true });
+    useSettingsStore.getState().initModels(MODELS, "reasoning", false);
+
+    useSettingsStore.getState().selectThinkingEffort("on");
+
+    expect(useSettingsStore.getState().thinkingEffort).toBe("high");
+    expect(boundary.saveConfig).toHaveBeenCalledWith({ model: "reasoning", thinking: true, effort: "high" });
+  });
+
+  it("prefers the persisted configured effort when resolving \"on\"", () => {
+    boundary.saveConfig.mockResolvedValue({ ok: true });
+    useSettingsStore.getState().initModels(MODELS, "reasoning", false);
+    useSettingsStore.setState({ defaultThinkingEffort: "low" });
+
+    useSettingsStore.getState().selectThinkingEffort("on");
+
+    expect(useSettingsStore.getState().thinkingEffort).toBe("low");
+  });
+
+  it("keeps \"on\" for genuine boolean models", () => {
+    boundary.saveConfig.mockResolvedValue({ ok: true });
+    useSettingsStore.getState().initModels([
+      { id: "bool", name: "Bool", provider: "openai", capabilities: ["thinking"] },
+    ], "bool", false);
+
+    useSettingsStore.getState().selectThinkingEffort("on");
+
+    expect(useSettingsStore.getState().thinkingEffort).toBe("on");
+    expect(boundary.saveConfig).toHaveBeenCalledWith({ model: "bool", thinking: true, effort: "on" });
+  });
+
+  it("persists disabling thinking with thinking false", () => {
+    boundary.saveConfig.mockResolvedValue({ ok: true });
+    useSettingsStore.getState().initModels(MODELS, "reasoning", true);
+
+    useSettingsStore.getState().selectThinkingEffort("off");
+
+    expect(useSettingsStore.getState().thinkingEffort).toBe("off");
+    expect(boundary.saveConfig).toHaveBeenCalledWith({ model: "reasoning", thinking: false, effort: "off" });
+  });
+
+  it("rejects \"off\" for always-on effort models", () => {
+    boundary.saveConfig.mockResolvedValue({ ok: true });
+    useSettingsStore.getState().initModels([
+      { id: "always-effort", name: "AE", provider: "openai", capabilities: ["always_thinking"], support_efforts: ["low", "high"] },
+    ], "always-effort", true);
+    const previous = useSettingsStore.getState().thinkingEffort;
+    boundary.saveConfig.mockClear();
+
+    useSettingsStore.getState().selectThinkingEffort("off");
+
+    expect(useSettingsStore.getState().thinkingEffort).toBe(previous);
+    expect(boundary.saveConfig).not.toHaveBeenCalled();
+  });
+
+  it("rejects efforts outside support_efforts", () => {
+    boundary.saveConfig.mockResolvedValue({ ok: true });
+    useSettingsStore.getState().initModels(MODELS, "reasoning", false);
+    const previous = useSettingsStore.getState().thinkingEffort;
+    boundary.saveConfig.mockClear();
+
+    useSettingsStore.getState().selectThinkingEffort("ultra");
+
+    expect(useSettingsStore.getState().thinkingEffort).toBe(previous);
+    expect(boundary.saveConfig).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/vscode/test/vsix-package.test.ts b/apps/vscode/test/vsix-package.test.ts
new file mode 100644
index 000000000..dc1ccb30b
--- /dev/null
+++ b/apps/vscode/test/vsix-package.test.ts
@@ -0,0 +1,254 @@
+/**
+ * Scenario: maintainers package and inspect the VS Code extension on any host OS.
+ * Responsibilities: six-target argument handling, actionable failures, isolated
+ * dev state, manifest/resource hygiene, unresolved imports, and entry loading.
+ * Wiring: real Node packaging/verifier CLIs and filesystem; VSIX directory
+ * fixtures replace only the external Marketplace archive producer.
+ * Run: pnpm --filter kimi-code exec vitest run --config vitest.config.ts test/vsix-package.test.ts
+ */
+import { spawnSync } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+const appRoot = resolve(import.meta.dirname, '..');
+const packageScript = join(appRoot, 'scripts', 'vsix-package.mjs');
+const verifierScript = join(appRoot, 'scripts', 'vsix-verify.mjs');
+const prepareDevScript = join(appRoot, 'scripts', 'prepare-dev.mjs');
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe('VSIX package CLI (target planning and validation)', () => {
+  it('plans all six supported targets when no target is supplied', async () => {
+    const outputDir = await makeTempDir('kimi-package-plan-');
+
+    const result = runNode(packageScript, ['--dry-run', '--out-dir', outputDir]);
+
+    expect(result.status).toBe(0);
+    expect(result.stdout.match(/Would package /g)).toHaveLength(6);
+    expect(result.stdout).toContain('kimi-code-darwin-x64.vsix');
+    expect(result.stdout).toContain('kimi-code-darwin-arm64.vsix');
+    expect(result.stdout).toContain('kimi-code-linux-x64.vsix');
+    expect(result.stdout).toContain('kimi-code-linux-arm64.vsix');
+    expect(result.stdout).toContain('kimi-code-win32-x64.vsix');
+    expect(result.stdout).toContain('kimi-code-win32-arm64.vsix');
+  });
+
+  it('accepts a Windows ARM target when the output path contains spaces', async () => {
+    const root = await makeTempDir('kimi-package-windows-');
+    const outputDir = join(root, 'output with spaces');
+
+    const result = runNode(packageScript, [
+      '--',
+      '--dry-run',
+      '--target',
+      'win32-arm64',
+      '--out-dir',
+      outputDir,
+    ]);
+
+    expect(result.status).toBe(0);
+    expect(result.stdout.match(/Would package /g)).toHaveLength(1);
+    expect(result.stdout).toContain('kimi-code-win32-arm64.vsix');
+  });
+
+  it('rejects an unknown target before a build starts', () => {
+    const result = runNode(packageScript, ['plan9-x64', '--dry-run']);
+
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain('Unknown VSIX target "plan9-x64"');
+    expect(result.stderr).toContain('win32-arm64');
+  });
+});
+
+describe('VSIX verifier CLI (package contract and failure details)', () => {
+  it('passes an unpacked Windows package when the entry is self-contained', async () => {
+    const fixture = await makeVsixFixture('win32-x64');
+
+    const result = runNode(verifierScript, [
+      '--target',
+      'win32-x64',
+      '--directory',
+      fixture,
+    ]);
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('static audit and entry import smoke passed (package-only)');
+  });
+
+  it('reports the expected target when the VSIX manifest has a different target', async () => {
+    const fixture = await makeVsixFixture('darwin-arm64');
+
+    const result = runNode(verifierScript, [
+      '--target',
+      'linux-x64',
+      '--directory',
+      fixture,
+    ]);
+
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain('VSIX manifest target is darwin-arm64, expected linux-x64');
+  });
+
+  it('names a missing required Webview resource', async () => {
+    const fixture = await makeVsixFixture('darwin-x64');
+    await rm(join(fixture, 'extension', 'dist', 'webview.js'));
+
+    const result = runNode(verifierScript, [
+      '--target',
+      'darwin-x64',
+      '--directory',
+      fixture,
+    ]);
+
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain('Required VSIX resource is missing: extension/dist/webview.js');
+  });
+
+  it('reports a bare runtime dependency left in the extension bundle', async () => {
+    const fixture = await makeVsixFixture('linux-arm64');
+    await writeFile(
+      join(fixture, 'extension', 'dist', 'extension.js'),
+      "import leftPad from 'left-pad';\nexport function activate() { return leftPad; }\n",
+    );
+
+    const result = runNode(verifierScript, [
+      '--target',
+      'linux-arm64',
+      '--directory',
+      fixture,
+    ]);
+
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain('Bare runtime dependency "left-pad"');
+  });
+
+  it('rejects generated session state inside the package', async () => {
+    const fixture = await makeVsixFixture('win32-arm64');
+    const stateDir = join(fixture, 'extension', 'runtime', 'profile');
+    await mkdir(stateDir, { recursive: true });
+    await writeFile(join(stateDir, 'session.json'), '{}');
+
+    const result = runNode(verifierScript, [
+      '--target',
+      'win32-arm64',
+      '--directory',
+      fixture,
+    ]);
+
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain('Forbidden package path segment "runtime"');
+  });
+
+  it('rejects a persisted state directory inside the package', async () => {
+    const fixture = await makeVsixFixture('win32-x64');
+    const stateDir = join(fixture, 'extension', 'state');
+    await mkdir(stateDir, { recursive: true });
+    await writeFile(join(stateDir, 'extension.json'), '{}');
+
+    const result = runNode(verifierScript, [
+      '--target',
+      'win32-x64',
+      '--directory',
+      fixture,
+    ]);
+
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain('Forbidden package path segment "state"');
+  });
+});
+
+describe('Extension Development Host setup (isolated local state)', () => {
+  it('creates the complete isolated directory layout for a debug launch', async () => {
+    const parent = await makeTempDir('kimi-dev-profile-');
+    const baseDir = join(parent, 'vscode-extension-dev');
+
+    const result = runNode(prepareDevScript, ['--base-dir', baseDir]);
+
+    expect(result.status).toBe(0);
+    await expect(readFile(join(baseDir, 'workspace', 'README.md'), 'utf8')).resolves.toContain(
+      'Isolated Kimi Code extension development workspace',
+    );
+    await expect(directoryExists(join(baseDir, 'user-data'))).resolves.toBe(true);
+    await expect(directoryExists(join(baseDir, 'extensions'))).resolves.toBe(true);
+    await expect(directoryExists(join(baseDir, 'kimi-home'))).resolves.toBe(true);
+  });
+
+  it('refuses to clear a directory without the dedicated safety suffix', async () => {
+    const unsafeDir = await makeTempDir('kimi-dev-unsafe-');
+    await writeFile(join(unsafeDir, 'keep.txt'), 'keep');
+
+    const result = runNode(prepareDevScript, ['--base-dir', unsafeDir]);
+
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain('Refusing to reset unsafe development directory');
+    await expect(readFile(join(unsafeDir, 'keep.txt'), 'utf8')).resolves.toBe('keep');
+  });
+});
+
+async function makeTempDir(prefix: string): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+async function makeVsixFixture(target: string): Promise<string> {
+  const root = await makeTempDir('kimi-vsix-fixture-');
+  const extensionDir = join(root, 'extension');
+  const distDir = join(extensionDir, 'dist');
+  const resourcesDir = join(extensionDir, 'resources');
+  await Promise.all([
+    mkdir(distDir, { recursive: true }),
+    mkdir(resourcesDir, { recursive: true }),
+  ]);
+
+  const packageJson = await readFile(join(appRoot, 'package.json'), 'utf8');
+  await Promise.all([
+    writeFile(join(root, '[Content_Types].xml'), '<Types />'),
+    writeFile(
+      join(root, 'extension.vsixmanifest'),
+      `<PackageManifest><Metadata><Identity TargetPlatform="${target}" /></Metadata></PackageManifest>`,
+    ),
+    writeFile(join(extensionDir, 'package.json'), packageJson),
+    writeFile(join(extensionDir, 'readme.md'), '# Fixture\n'),
+    writeFile(join(extensionDir, 'LICENSE.txt'), 'fixture license\n'),
+    writeFile(
+      join(distDir, 'extension.js'),
+      "/** @type {import('../types/index').Extension} */\nimport * as vscode from 'vscode';\nexport function activate() { return vscode; }\n",
+    ),
+    writeFile(join(distDir, 'webview.js'), 'globalThis.__kimiWebview = true;\n'),
+    writeFile(join(distDir, 'kimi-banner-dark.svg'), '<svg />'),
+    writeFile(join(distDir, 'kimi-banner-light.svg'), '<svg />'),
+    writeFile(join(distDir, 'kimi-logo.png'), 'fixture'),
+    writeFile(join(resourcesDir, 'kimi-icon-storefront.png'), 'fixture'),
+    writeFile(join(resourcesDir, 'kimi-icon.svg'), '<svg />'),
+  ]);
+  return root;
+}
+
+function runNode(script: string, args: string[]) {
+  const result = spawnSync(process.execPath, [script, ...args], {
+    cwd: appRoot,
+    encoding: 'utf8',
+    env: { ...process.env, VSCE_PAT: '', OVSX_PAT: '' },
+  });
+  if (result.error !== undefined) throw result.error;
+  return {
+    status: result.status,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  };
+}
+
+async function directoryExists(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
diff --git a/apps/vscode/test/workspace-paths.test.ts b/apps/vscode/test/workspace-paths.test.ts
new file mode 100644
index 000000000..008d06621
--- /dev/null
+++ b/apps/vscode/test/workspace-paths.test.ts
@@ -0,0 +1,438 @@
+/**
+ * Scenario: Webview file paths stay inside the selected working directory.
+ * Responsibilities: directory/search/open/mention paths are scoped, normalized, and symlink-safe.
+ * Wiring: real temporary local files plus the public handler/bridge surfaces;
+ * VS Code host APIs are the only stubbed boundary.
+ * Run: pnpm --filter kimi-code exec vitest run --config vitest.config.ts test/workspace-paths.test.ts
+ */
+import { mkdtemp, mkdir, readFile, readdir, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Event, Session } from "@moonshot-ai/kimi-code-sdk";
+import type * as vscode from "vscode";
+import { Methods } from "../shared/bridge";
+import { BridgeHandler } from "../src/bridge-handler";
+import { fileHandlers } from "../src/handlers/file.handler";
+import type { HandlerContext } from "../src/handlers/types";
+import { FileManager } from "../src/managers/file.manager";
+import { SessionRuntime } from "../src/runtime/session-runtime";
+import { areSameFsPath, isFsPathInsideOrEqual } from "../src/utils/fs-path";
+import { relativeWorkspacePath } from "../src/utils/workspace-path";
+
+const vscodeHost = vi.hoisted(() => {
+  function normalizeUriPath(value: string): string {
+    const segments: string[] = [];
+    for (const segment of value.replaceAll("\\", "/").split("/")) {
+      if (!segment || segment === ".") continue;
+      if (segment === "..") segments.pop();
+      else segments.push(segment);
+    }
+    return `/${segments.join("/")}`;
+  }
+
+  class Uri {
+    readonly query: string;
+
+    constructor(
+      readonly scheme: string,
+      readonly authority: string,
+      readonly path: string,
+      readonly fsPath: string,
+      query = "",
+    ) {
+      this.query = query;
+    }
+
+    static file(fsPath: string): Uri {
+      return new Uri("file", "", normalizeUriPath(fsPath), fsPath);
+    }
+
+    static remote(authority: string, fsPath: string): Uri {
+      return new Uri("vscode-remote", authority, normalizeUriPath(fsPath), fsPath);
+    }
+
+    static joinPath(base: Uri, ...segments: string[]): Uri {
+      const path = normalizeUriPath(`${base.path}/${segments.join("/")}`);
+      const suffix = segments.join("/");
+      const separator = base.fsPath.endsWith("/") ? "" : "/";
+      return new Uri(base.scheme, base.authority, path, `${base.fsPath}${separator}${suffix}`);
+    }
+
+    static from(parts: { scheme: string; path?: string; query?: string }): Uri {
+      const path = parts.path ?? "";
+      return new Uri(parts.scheme, "", path, path, parts.query);
+    }
+
+    toString(): string {
+      return `${this.scheme}://${this.authority}${this.path}${this.query ? `?${this.query}` : ""}`;
+    }
+  }
+
+  class RelativePattern {
+    readonly baseUri: Uri;
+    readonly base: string;
+
+    constructor(base: Uri, readonly pattern: string) {
+      this.baseUri = base;
+      this.base = base.fsPath;
+    }
+  }
+
+  const readDirectory = vi.fn();
+  const stat = vi.fn();
+  const readFile = vi.fn();
+  const findFiles = vi.fn();
+  const executeCommand = vi.fn();
+  const showWarningMessage = vi.fn();
+
+  return {
+    Uri,
+    RelativePattern,
+    readDirectory,
+    stat,
+    readFile,
+    findFiles,
+    executeCommand,
+    showWarningMessage,
+    workspaceFolders: [] as Array<{ uri: Uri }>,
+  };
+});
+
+vi.mock("vscode", () => ({
+  Uri: vscodeHost.Uri,
+  RelativePattern: vscodeHost.RelativePattern,
+  FileType: { Unknown: 0, File: 1, Directory: 2, SymbolicLink: 64 },
+  QuickPickItemKind: { Separator: -1 },
+  workspace: {
+    get workspaceFolders() {
+      return vscodeHost.workspaceFolders;
+    },
+    fs: {
+      readDirectory: vscodeHost.readDirectory,
+      stat: vscodeHost.stat,
+      readFile: vscodeHost.readFile,
+    },
+    findFiles: vscodeHost.findFiles,
+    createFileSystemWatcher: () => ({
+      onDidChange: vi.fn(),
+      onDidCreate: vi.fn(),
+      onDidDelete: vi.fn(),
+      dispose: vi.fn(),
+    }),
+    getConfiguration: () => ({ get: (_key: string, fallback: unknown) => fallback }),
+    textDocuments: [],
+  },
+  commands: { executeCommand: vscodeHost.executeCommand },
+  window: {
+    activeTextEditor: undefined,
+    showWarningMessage: vscodeHost.showWarningMessage,
+    showQuickPick: vi.fn(),
+    showOpenDialog: vi.fn(),
+  },
+}));
+
+vi.mock("@moonshot-ai/kimi-code-sdk", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@moonshot-ai/kimi-code-sdk")>();
+  return {
+    ...original,
+    createKimiHarness: () => ({
+      homeDir: "/tmp/kimi-code-test-home",
+      close: vi.fn(),
+    }),
+  };
+});
+
+let root: string;
+let fileManager: FileManager;
+let bridges: BridgeHandler[];
+let sessionRuntimes: SessionRuntime[];
+let extraRoots: string[];
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), "kimi-vscode-workspace-paths-"));
+  vscodeHost.workspaceFolders.splice(0, vscodeHost.workspaceFolders.length, { uri: vscodeHost.Uri.file(root) });
+  vscodeHost.readDirectory.mockImplementation(async (uri: { fsPath: string }) =>
+    (await readdir(uri.fsPath, { withFileTypes: true })).map((entry) => [
+      entry.name,
+      entry.isDirectory() ? 2 : entry.isSymbolicLink() ? 64 : 1,
+    ]),
+  );
+  vscodeHost.stat.mockImplementation((uri: { fsPath: string }) => stat(uri.fsPath));
+  vscodeHost.readFile.mockImplementation((uri: { fsPath: string }) => readFile(uri.fsPath));
+  vscodeHost.findFiles.mockResolvedValue([]);
+  fileManager = new FileManager({} as never, vi.fn());
+  bridges = [];
+  sessionRuntimes = [];
+  extraRoots = [];
+});
+
+afterEach(async () => {
+  await Promise.all(sessionRuntimes.map((runtime) => runtime.close()));
+  await Promise.all(bridges.map((bridge) => bridge.dispose()));
+  fileManager.dispose();
+  vi.clearAllMocks();
+  await Promise.all([root, ...extraRoots].map((directory) => rm(directory, { recursive: true, force: true })));
+});
+
+describe("Webview workspace paths (selected-directory containment)", () => {
+  it("returns no entries when directory traversal is requested", async () => {
+    const workDir = join(root, "project");
+    await mkdir(workDir);
+
+    const files = await getProjectFiles(workDir, { directory: "../" });
+
+    expect(files).toEqual([]);
+    expect(vscodeHost.readDirectory).not.toHaveBeenCalled();
+  });
+
+  it("returns no entries when an absolute directory is requested", async () => {
+    const workDir = join(root, "project");
+    await mkdir(workDir);
+
+    const files = await getProjectFiles(workDir, { directory: join(root, "outside") });
+
+    expect(files).toEqual([]);
+    expect(vscodeHost.readDirectory).not.toHaveBeenCalled();
+  });
+
+  it("returns no entries when a Windows absolute directory is requested", async () => {
+    const workDir = join(root, "project");
+    await mkdir(workDir);
+
+    const files = await getProjectFiles(workDir, { directory: "C:\\outside" });
+
+    expect(files).toEqual([]);
+    expect(vscodeHost.readDirectory).not.toHaveBeenCalled();
+  });
+
+  it("returns no entries when a Windows drive-relative directory is requested", async () => {
+    const workDir = join(root, "project");
+    await mkdir(workDir);
+
+    const files = await getProjectFiles(workDir, { directory: "C:outside" });
+
+    expect(files).toEqual([]);
+    expect(vscodeHost.readDirectory).not.toHaveBeenCalled();
+  });
+
+  it("omits a symlink when its target is outside the selected working directory", async () => {
+    const workDir = join(root, "project");
+    const outside = join(root, "outside");
+    await Promise.all([mkdir(workDir), mkdir(outside)]);
+    await writeFile(join(outside, "secret.txt"), "secret");
+    await symlink(outside, join(workDir, "outside-link"));
+
+    const files = await getProjectFiles(workDir, { directory: "." });
+
+    expect(files).toEqual([]);
+  });
+
+  it("searches within the selected subdirectory using work-directory-relative results", async () => {
+    const workDir = join(root, "project", "subproject");
+    const inside = join(workDir, "src", "inside.ts");
+    const sibling = join(root, "project", "sibling.ts");
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await Promise.all([writeFile(inside, "inside"), writeFile(sibling, "sibling")]);
+    vscodeHost.findFiles.mockResolvedValue([vscodeHost.Uri.file(inside), vscodeHost.Uri.file(sibling)]);
+
+    const files = await getProjectFiles(workDir, { query: "inside" });
+
+    const include = vscodeHost.findFiles.mock.calls[0]?.[0] as InstanceType<typeof vscodeHost.RelativePattern>;
+    expect(include.baseUri.fsPath).toBe(workDir);
+    expect(files).toEqual([{ path: "src/inside.ts", name: "inside.ts", isDirectory: false }]);
+  });
+
+  it("normalizes native Windows separators during directory navigation", async () => {
+    const workDir = join(root, "project");
+    await mkdir(join(workDir, "src", "nested"), { recursive: true });
+    await writeFile(join(workDir, "src", "nested", "app.ts"), "app");
+
+    const files = await getProjectFiles(workDir, { directory: "src\\nested" });
+
+    expect(files).toEqual([{ path: "src/nested/app.ts", name: "app.ts", isDirectory: false }]);
+  });
+
+  it("preserves the remote workspace URI while listing a directory", async () => {
+    const remoteRoot = vscodeHost.Uri.remote("ssh-remote+example", "/workspace/project");
+    vscodeHost.readDirectory.mockResolvedValue([["remote.ts", 1]]);
+    const ctx = createContext(remoteRoot);
+
+    const files = await fileHandlers[Methods.GetProjectFiles]!({ directory: "." }, ctx);
+
+    const requestedUri = vscodeHost.readDirectory.mock.calls[0]?.[0];
+    expect(requestedUri).toMatchObject({ scheme: "vscode-remote", authority: "ssh-remote+example" });
+    expect(files).toEqual([{ path: "remote.ts", name: "remote.ts", isDirectory: false }]);
+  });
+
+  it("refuses to open a symlink whose target lies outside the selected working directory", async () => {
+    const workDir = join(root, "project");
+    const outside = join(root, "outside.txt");
+    await mkdir(workDir);
+    await writeFile(outside, "secret");
+    await symlink(outside, join(workDir, "secret.txt"));
+    const ctx = createContext(vscodeHost.Uri.file(workDir));
+
+    const result = await fileHandlers[Methods.OpenFile]!({ filePath: "secret.txt" }, ctx);
+
+    expect(result).toEqual({ ok: false });
+    expect(vscodeHost.executeCommand).not.toHaveBeenCalled();
+  });
+
+  it("omits an outside symlink when an SDK Write event requests baseline capture", async () => {
+    const workDir = join(root, "project");
+    const outsideRoot = await mkdtemp(join(tmpdir(), "kimi-vscode-baseline-outside-"));
+    extraRoots.push(outsideRoot);
+    const outside = join(outsideRoot, "outside.txt");
+    const linkedFile = join(workDir, "linked.txt");
+    await mkdir(workDir);
+    await writeFile(outside, "secret");
+    await symlink(outside, linkedFile);
+    const bridge = createBridge();
+    let emit!: (event: Event) => void;
+    const session = {
+      id: "session-1",
+      workDir,
+      summary: { id: "session-1", workDir },
+      setApprovalHandler: vi.fn(),
+      setQuestionHandler: vi.fn(),
+      onEvent(listener: (event: Event) => void) {
+        emit = listener;
+        return vi.fn();
+      },
+      close: vi.fn(),
+    } as unknown as Session;
+    const runtime = new SessionRuntime({
+      session,
+      legacyApproval: { yolo: false, afk: false },
+      broadcast: vi.fn(),
+      captureBaseline: (summary, filePath, webviewIds) => {
+        bridge.captureFileBaseline(summary, filePath, webviewIds);
+      },
+      log: vi.fn(),
+    });
+    sessionRuntimes.push(runtime);
+
+    emit({
+      type: "tool.call.started",
+      sessionId: "session-1",
+      agentId: "main",
+      turnId: 1,
+      toolCallId: "tool-1",
+      name: "Write",
+      args: { path: linkedFile },
+    });
+
+    await expect(bridge.baselineManager.getChanges({ id: "session-1", workDir })).resolves.toEqual([]);
+  });
+
+  it("builds an editor mention relative to the selected working directory", async () => {
+    const workDir = join(root, "project", "subproject");
+    const inside = join(workDir, "src", "inside.ts");
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await writeFile(inside, "inside");
+    const bridge = createBridge();
+    await bridge.handle({ id: "set", method: Methods.SetWorkDir, params: { workDir } }, "view-1");
+
+    const mention = await bridge.getEditorMention(
+      "view-1",
+      vscodeHost.Uri.file(inside) as vscode.Uri,
+      emptySelection(),
+    );
+
+    expect(mention).toBe("@src/inside.ts");
+  });
+
+  it("omits an editor mention when the file is outside the selected working directory", async () => {
+    const workDir = join(root, "project", "subproject");
+    const sibling = join(root, "project", "sibling.ts");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(sibling, "sibling");
+    const bridge = createBridge();
+    await bridge.handle({ id: "set", method: Methods.SetWorkDir, params: { workDir } }, "view-1");
+
+    const mention = await bridge.getEditorMention(
+      "view-1",
+      vscodeHost.Uri.file(sibling) as vscode.Uri,
+      emptySelection(),
+    );
+
+    expect(mention).toBeNull();
+  });
+
+  it("rejects a selected working directory whose symlink target leaves the workspace", async () => {
+    const outside = await mkdtemp(join(tmpdir(), "kimi-vscode-outside-"));
+    extraRoots.push(outside);
+    const linkedWorkDir = join(root, "linked-project");
+    await symlink(outside, linkedWorkDir);
+    const bridge = createBridge();
+
+    const result = await bridge.handle(
+      { id: "set", method: Methods.SetWorkDir, params: { workDir: linkedWorkDir } },
+      "view-1",
+    );
+
+    expect(result).toEqual({ id: "set", result: { ok: false } });
+  });
+});
+
+describe("native workspace path comparison (Windows drive and UNC semantics)", () => {
+  it("treats slash and casing differences as the same Windows drive path", () => {
+    expect(areSameFsPath("C:\\Users\\Example User\\项目", "c:/users/example user/项目")).toBe(true);
+  });
+
+  it("keeps an in-share UNC child relative to its workspace", () => {
+    const rootUri = vscodeHost.Uri.file("\\\\Server\\Share\\Workspace");
+    const childUri = vscodeHost.Uri.file("\\\\server\\share\\workspace\\src\\app.ts");
+
+    expect(relativeWorkspacePath(rootUri as vscode.Uri, childUri as vscode.Uri)).toBe("src/app.ts");
+  });
+
+  it("rejects a UNC path from another share", () => {
+    expect(
+      isFsPathInsideOrEqual(
+        "\\\\Server\\Share\\Workspace",
+        "\\\\Server\\OtherShare\\Workspace\\app.ts",
+      ),
+    ).toBe(false);
+  });
+});
+
+async function getProjectFiles(workDir: string, params: { query?: string; directory?: string }) {
+  return fileHandlers[Methods.GetProjectFiles]!(params, createContext(vscodeHost.Uri.file(workDir)));
+}
+
+function createContext(workDirUri: InstanceType<typeof vscodeHost.Uri>): HandlerContext {
+  return {
+    webviewId: "view-1",
+    workDir: workDirUri.fsPath,
+    workDirUri: workDirUri as vscode.Uri,
+    workspaceRoot: root,
+    workspaceRootUri: vscodeHost.workspaceFolders[0]!.uri as vscode.Uri,
+    workspaceState: {} as vscode.Memento,
+    requireWorkDir: () => workDirUri.fsPath,
+    requireWorkDirUri: () => workDirUri as vscode.Uri,
+    fileManager,
+  } as HandlerContext;
+}
+
+function createBridge(): BridgeHandler {
+  const bridge = new BridgeHandler(
+    vi.fn(),
+    { get: vi.fn(), update: vi.fn() } as unknown as vscode.Memento,
+    join(root, "global-storage"),
+    vi.fn(),
+    vi.fn(),
+    vi.fn(),
+  );
+  bridges.push(bridge);
+  return bridge;
+}
+
+function emptySelection(): vscode.Selection {
+  return {
+    isEmpty: true,
+    start: { line: 0 },
+    end: { line: 0 },
+  } as vscode.Selection;
+}
diff --git a/apps/vscode/tsconfig.json b/apps/vscode/tsconfig.json
new file mode 100644
index 000000000..bc9d28463
--- /dev/null
+++ b/apps/vscode/tsconfig.json
@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ES2024"],
+    "types": ["node", "vscode"],
+    "sourceMap": true,
+    "declaration": false,
+    "noEmit": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "paths": {
+      "@/*": ["./src/*"],
+      "shared/*": ["./shared/*"],
+      "@moonshot-ai/kimi-code-sdk": ["../../packages/node-sdk/src/index.ts"]
+    }
+  },
+  "include": ["src/**/*", "shared/**/*", "test/**/*"],
+  "exclude": ["dist", "node_modules", "webview-ui", "test/settings-store.test.ts"]
+}
diff --git a/apps/vscode/tsdown.config.ts b/apps/vscode/tsdown.config.ts
new file mode 100644
index 000000000..2adf78dca
--- /dev/null
+++ b/apps/vscode/tsdown.config.ts
@@ -0,0 +1,48 @@
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+
+import { defineConfig } from 'tsdown';
+
+import { rawTextPlugin } from '../../build/raw-text-plugin.mjs';
+
+const require = createRequire(import.meta.url);
+const pkg = require('./package.json') as { version: string };
+const root = import.meta.dirname;
+
+export default defineConfig({
+  entry: ['./src/extension.ts'],
+  format: ['esm'],
+  target: 'node20',
+  outDir: 'dist',
+  clean: true,
+  dts: false,
+  sourcemap: false,
+  plugins: [rawTextPlugin()],
+  alias: {
+    '@moonshot-ai/kimi-code-sdk': resolve(root, '../../packages/node-sdk/src/index.ts'),
+    '@moonshot-ai/migration-legacy': resolve(root, '../../packages/migration-legacy/src/index.ts'),
+    '@moonshot-ai/agent-core': resolve(root, '../../packages/agent-core/src/index.ts'),
+    '@moonshot-ai/kaos': resolve(root, '../../packages/kaos/src/index.ts'),
+    '@moonshot-ai/kimi-code-oauth': resolve(root, '../../packages/oauth/src/index.ts'),
+    '@moonshot-ai/kosong': resolve(root, '../../packages/kosong/src/index.ts'),
+  },
+  define: {
+    __EXTENSION_VERSION__: JSON.stringify(pkg.version),
+  },
+  banner: {
+    js: [
+      "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'),
+  },
+  deps: {
+    onlyBundle: false,
+    alwaysBundle: [/^@moonshot-ai\//, 'zod'],
+    neverBundle: ['vscode'],
+  },
+  outputOptions: {
+    entryFileNames: 'extension.js',
+  },
+});
diff --git a/apps/vscode/vitest.config.ts b/apps/vscode/vitest.config.ts
new file mode 100644
index 000000000..3f0b71013
--- /dev/null
+++ b/apps/vscode/vitest.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'node:path';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@': resolve(import.meta.dirname, 'webview-ui/src'),
+      shared: resolve(import.meta.dirname, 'shared'),
+    },
+  },
+  test: {
+    include: ['test/**/*.test.ts'],
+    environment: 'node',
+  },
+});
diff --git a/apps/vscode/webview-ui/components.json b/apps/vscode/webview-ui/components.json
new file mode 100644
index 000000000..9823830a3
--- /dev/null
+++ b/apps/vscode/webview-ui/components.json
@@ -0,0 +1,24 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "radix-nova",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/styles/index.css",
+    "baseColor": "zinc",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "tabler",
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}
diff --git a/apps/vscode/webview-ui/index.html b/apps/vscode/webview-ui/index.html
new file mode 100644
index 000000000..ed8edcd58
--- /dev/null
+++ b/apps/vscode/webview-ui/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 Code</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/apps/vscode/webview-ui/public/kimi-banner-dark.svg b/apps/vscode/webview-ui/public/kimi-banner-dark.svg
new file mode 100644
index 000000000..746420861
--- /dev/null
+++ b/apps/vscode/webview-ui/public/kimi-banner-dark.svg
@@ -0,0 +1,6 @@
+<svg width="60" height="20" viewBox="0 0 60 20" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M22.353 19.5805C22.353 19.8122 22.5408 20 22.7725 20H25.4629C25.6946 20 25.8824 19.8122 25.8824 19.5805V0.419508C25.8824 0.187821 25.6946 0 25.4629 0H22.7725C22.5408 0 22.353 0.18782 22.353 0.419507V19.5805Z" fill="white"/>
+<path d="M56.4707 19.5805C56.4707 19.8122 56.6585 20 56.8902 20H59.5806C59.8123 20 60.0001 19.8122 60.0001 19.5805V0.419508C60.0001 0.187821 59.8123 0 59.5806 0H56.8902C56.6585 0 56.4707 0.18782 56.4707 0.419507V19.5805Z" fill="white"/>
+<path d="M45.7863 0C45.5929 0 45.4246 0.132211 45.3787 0.3201L41.4 16.6327C41.3337 16.9001 41.0206 16.9001 40.956 16.6327L36.9756 0.320062C36.9298 0.132192 36.7639 0 36.5705 0C35.2694 0 31.1569 0 29.8292 0C29.5976 0 29.4116 0.18782 29.4116 0.419507V19.5805C29.4116 19.8122 29.5994 20 29.8311 20H32.8187C33.0504 20 33.2382 19.8177 33.2382 19.586C33.2382 17.0211 33.2382 3.47115 33.2382 3.47115C33.2382 3.14919 33.6159 3.08234 33.6921 3.39198L37.6659 19.6799C37.7117 19.8678 37.8801 20 38.0735 20H44.2808C44.4742 20 44.6426 19.8678 44.6884 19.6799L48.6605 3.39374C48.7367 3.0841 49.1144 3.15095 49.1144 3.47291V19.5805C49.1144 19.8122 49.3023 20 49.5339 20H52.5215C52.7532 20 52.941 19.8122 52.941 19.5805V0.419508C52.941 0.187821 52.7532 0 52.5215 0H45.7863Z" fill="white"/>
+<path d="M9.5491 9.27327L17.6651 0.70805C17.9184 0.440692 17.7289 0 17.3606 0H13.5836C13.4716 0 13.3643 0.044742 13.2856 0.124271L3.9835 9.51434C3.8391 9.66039 3.62564 9.53018 3.62564 9.29615V0.419507C3.62564 0.18782 3.43782 0 3.20614 0H0.419507C0.18782 0 0 0.18782 0 0.419507V19.5805C0 19.8122 0.18782 20 0.419507 20H3.20614C3.43782 20 3.62564 19.8122 3.62564 19.5805V15.7593C3.62564 15.6748 3.65547 15.5939 3.70726 15.5411L6.57795 12.6095C6.64701 12.5392 6.74276 12.5286 6.81966 12.5814L14.4979 18.397C15.6207 19.1749 17.0503 19.6847 18.3594 19.8976C18.6062 19.9378 18.8235 19.7427 18.8235 19.4927C18.8235 18.2378 18.8235 16.8429 18.8235 16.0317C18.8235 15.8258 18.6739 15.6519 18.4726 15.6086C17.7133 15.4451 16.8692 15.1352 16.2291 14.6912L9.58206 9.73781C9.44394 9.64279 9.42667 9.3982 9.5491 9.27327Z" fill="white"/>
+</svg>
diff --git a/apps/vscode/webview-ui/public/kimi-banner-light.svg b/apps/vscode/webview-ui/public/kimi-banner-light.svg
new file mode 100644
index 000000000..bdfe65a77
--- /dev/null
+++ b/apps/vscode/webview-ui/public/kimi-banner-light.svg
@@ -0,0 +1,6 @@
+<svg width="60" height="20" viewBox="0 0 60 20" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M22.353 19.5805C22.353 19.8122 22.5408 20 22.7725 20H25.4629C25.6946 20 25.8824 19.8122 25.8824 19.5805V0.419508C25.8824 0.187821 25.6946 0 25.4629 0H22.7725C22.5408 0 22.353 0.18782 22.353 0.419507V19.5805Z" fill="black"/>
+<path d="M56.4707 19.5805C56.4707 19.8122 56.6585 20 56.8902 20H59.5806C59.8123 20 60.0001 19.8122 60.0001 19.5805V0.419508C60.0001 0.187821 59.8123 0 59.5806 0H56.8902C56.6585 0 56.4707 0.18782 56.4707 0.419507V19.5805Z" fill="black"/>
+<path d="M45.7863 0C45.5929 0 45.4246 0.132211 45.3787 0.3201L41.4 16.6327C41.3337 16.9001 41.0206 16.9001 40.956 16.6327L36.9756 0.320062C36.9298 0.132192 36.7639 0 36.5705 0C35.2694 0 31.1569 0 29.8292 0C29.5976 0 29.4116 0.18782 29.4116 0.419507V19.5805C29.4116 19.8122 29.5994 20 29.8311 20H32.8187C33.0504 20 33.2382 19.8177 33.2382 19.586C33.2382 17.0211 33.2382 3.47115 33.2382 3.47115C33.2382 3.14919 33.6159 3.08234 33.6921 3.39198L37.6659 19.6799C37.7117 19.8678 37.8801 20 38.0735 20H44.2808C44.4742 20 44.6426 19.8678 44.6884 19.6799L48.6605 3.39374C48.7367 3.0841 49.1144 3.15095 49.1144 3.47291V19.5805C49.1144 19.8122 49.3023 20 49.5339 20H52.5215C52.7532 20 52.941 19.8122 52.941 19.5805V0.419508C52.941 0.187821 52.7532 0 52.5215 0H45.7863Z" fill="black"/>
+<path d="M9.5491 9.27327L17.6651 0.70805C17.9184 0.440692 17.7289 0 17.3606 0H13.5836C13.4716 0 13.3643 0.044742 13.2856 0.124271L3.9835 9.51434C3.8391 9.66039 3.62564 9.53018 3.62564 9.29615V0.419507C3.62564 0.18782 3.43782 0 3.20614 0H0.419507C0.18782 0 0 0.18782 0 0.419507V19.5805C0 19.8122 0.18782 20 0.419507 20H3.20614C3.43782 20 3.62564 19.8122 3.62564 19.5805V15.7593C3.62564 15.6748 3.65547 15.5939 3.70726 15.5411L6.57795 12.6095C6.64701 12.5392 6.74276 12.5286 6.81966 12.5814L14.4979 18.397C15.6207 19.1749 17.0503 19.6847 18.3594 19.8976C18.6062 19.9378 18.8235 19.7427 18.8235 19.4927C18.8235 18.2378 18.8235 16.8429 18.8235 16.0317C18.8235 15.8258 18.6739 15.6519 18.4726 15.6086C17.7133 15.4451 16.8692 15.1352 16.2291 14.6912L9.58206 9.73781C9.44394 9.64279 9.42667 9.3982 9.5491 9.27327Z" fill="black"/>
+</svg>
diff --git a/apps/vscode/webview-ui/public/kimi-logo.png b/apps/vscode/webview-ui/public/kimi-logo.png
new file mode 100644
index 000000000..033c0f4fb
Binary files /dev/null and b/apps/vscode/webview-ui/public/kimi-logo.png differ
diff --git a/apps/vscode/webview-ui/src/App.tsx b/apps/vscode/webview-ui/src/App.tsx
new file mode 100644
index 000000000..4a343fe89
--- /dev/null
+++ b/apps/vscode/webview-ui/src/App.tsx
@@ -0,0 +1,139 @@
+// node/vscode_extension/webview-ui/src/App.tsx
+import { useEffect, useState, useCallback } from "react";
+import { Header } from "./components/Header";
+import { ChatArea } from "./components/ChatArea";
+import { InputArea } from "./components/inputarea/InputArea";
+import { MCPServersModal } from "./components/MCPServersModal";
+import { WorkDirModal } from "./components/WorkDirModal";
+import { ConfigErrorScreen } from "./components/ConfigErrorScreen";
+import { LoginScreen } from "./components/LoginScreen";
+import { Toaster, toast } from "./components/ui/sonner";
+import { useChatStore, useSettingsStore } from "./stores";
+import { bridge, Events } from "./services";
+import { useAppInit } from "./hooks/useAppInit";
+import { isPreflightError } from "shared/errors";
+import type { UIStreamEvent, StreamError, ExtensionConfig } from "shared/types";
+import "./styles/index.css";
+
+function MainContent({ onAuthAction }: { onAuthAction: () => void }) {
+  const { processEvent, startNewConversation, sessionId } = useChatStore();
+  const { setMCPServers, setExtensionConfig, extensionConfig } = useSettingsStore();
+
+  useEffect(() => {
+    return bridge.on(Events.StreamEvent, (event: UIStreamEvent) => {
+      // 只有当前已有 session 时才过滤，确保 session_start 能正常处理
+      if (sessionId && "_sessionId" in event && event._sessionId && event._sessionId !== sessionId) {
+        console.log("Ignored stream event from another session:", event._sessionId);
+        return;
+      }
+      processEvent(event);
+      if (event.type === "error") {
+        const streamError = event as StreamError;
+        if (isPreflightError(streamError.code || "UNKNOWN")) {
+          toast.error(streamError.message);
+        }
+      }
+    });
+  }, [processEvent, sessionId]);
+
+  useEffect(() => {
+    const unsubs = [
+      bridge.on(Events.MCPServersChanged, setMCPServers),
+      bridge.on(Events.ExtensionConfigChanged, ({ config }: { config: ExtensionConfig }) => setExtensionConfig(config)),
+      bridge.on(Events.FocusInput, () => document.querySelector<HTMLTextAreaElement>("textarea")?.focus()),
+      bridge.on(Events.NewConversation, () => {
+        void startNewConversation().catch((error: unknown) => {
+          toast.error(error instanceof Error ? error.message : String(error));
+        });
+      }),
+    ];
+    return () => unsubs.forEach((u) => u());
+  }, [setMCPServers, setExtensionConfig, startNewConversation]);
+
+  useEffect(() => {
+    if (!extensionConfig.enableNewConversationShortcut) return;
+    const handler = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "n") {
+        e.preventDefault();
+        void startNewConversation().catch((error: unknown) => {
+          toast.error(error instanceof Error ? error.message : String(error));
+        });
+      }
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [extensionConfig.enableNewConversationShortcut, startNewConversation]);
+
+  return (
+    <>
+      <div className="flex-1 min-h-0 relative group/chat">
+        <ChatArea />
+      </div>
+      <div className="shrink-0 max-h-[80vh] flex flex-col min-h-0">
+        <InputArea onAuthAction={onAuthAction} />
+      </div>
+      <MCPServersModal />
+      <WorkDirModal />
+    </>
+  );
+}
+
+export default function App() {
+  const { status, errorMessage, modelsCount, refresh } = useAppInit();
+  const [skippedLogin, setSkippedLogin] = useState(false);
+
+  const handleLoginSuccess = useCallback(() => {
+    refresh();
+  }, [refresh]);
+
+  const handleSkip = useCallback(() => {
+    setSkippedLogin(true);
+  }, []);
+
+  const handleAuthAction = useCallback(() => {
+    setSkippedLogin(false);
+    refresh();
+  }, [refresh]);
+
+  // 未登录且未跳过
+  if (status === "not-logged-in" && !skippedLogin) {
+    return (
+      <div className="flex flex-col h-screen text-foreground overflow-hidden">
+        <Header />
+        <LoginScreen onLoginSuccess={handleLoginSuccess} onSkip={handleSkip} />
+        <Toaster position="top-center" />
+      </div>
+    );
+  }
+
+  // 跳过登录但没有模型
+  if (skippedLogin && modelsCount === 0) {
+    return (
+      <div className="flex flex-col h-screen text-foreground overflow-hidden">
+        <Header />
+        <ConfigErrorScreen type="no-models" errorMessage={errorMessage} onRefresh={refresh} onBackToLogin={() => setSkippedLogin(false)} />
+        <Toaster position="top-center" />
+      </div>
+    );
+  }
+
+  // 其他错误状态
+  if (status !== "ready" && status !== "not-logged-in") {
+    return (
+      <div className="flex flex-col h-screen text-foreground overflow-hidden">
+        <Header />
+        <ConfigErrorScreen type={status} errorMessage={errorMessage} onRefresh={refresh} />
+        <Toaster position="top-center" />
+      </div>
+    );
+  }
+
+  // 正常状态
+  return (
+    <div className="flex flex-col h-screen text-foreground overflow-hidden">
+      <Header />
+      <MainContent onAuthAction={handleAuthAction} />
+      <Toaster position="top-center" />
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ActionMenu.tsx b/apps/vscode/webview-ui/src/components/ActionMenu.tsx
new file mode 100644
index 000000000..f6ee7a2c9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ActionMenu.tsx
@@ -0,0 +1,149 @@
+import { useState } from "react";
+import { IconSettings, IconServer, IconLogout, IconLogin, IconLoader2, IconRefresh, IconFileText, IconFolder } from "@tabler/icons-react";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Button } from "@/components/ui/button";
+import { Separator } from "@/components/ui/separator";
+import { useSettingsStore } from "@/stores";
+import { bridge } from "@/services";
+import { toast } from "@/components/ui/sonner";
+import { cn } from "@/lib/utils";
+
+interface ActionMenuProps {
+  className?: string;
+  onAuthAction?: () => void;
+}
+
+function MenuSection({ title, subtitle, children }: { title: string; subtitle?: string; children: React.ReactNode }) {
+  return (
+    <div className="py-1">
+      <div className="px-2.5 py-1 text-[10px] font-medium text-muted-foreground uppercase tracking-wider flex items-center justify-between">
+        <span>{title}</span>
+        {subtitle && <span className="normal-case tracking-normal">{subtitle}</span>}
+      </div>
+      {children}
+    </div>
+  );
+}
+
+function MenuItem({ onClick, disabled, danger, children }: { onClick: () => void; disabled?: boolean; danger?: boolean; children: React.ReactNode }) {
+  return (
+    <button
+      onClick={onClick}
+      disabled={disabled}
+      className={cn(
+        "w-full flex items-center gap-2 px-2.5 py-1.5 text-xs hover:bg-accent transition-colors text-left cursor-pointer",
+        disabled && "opacity-50 cursor-not-allowed",
+        danger && "text-red-500 hover:text-red-600",
+      )}
+    >
+      {children}
+    </button>
+  );
+}
+
+export function ActionMenu({ className, onAuthAction }: ActionMenuProps) {
+  const [open, setOpen] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const { setMCPModalOpen, isLoggedIn, setIsLoggedIn, extensionConfig } = useSettingsStore();
+
+  const handleOpenSettings = () => {
+    void bridge.openSettings();
+    setOpen(false);
+  };
+
+  const handleOpenMCPServers = () => {
+    setMCPModalOpen(true);
+    setOpen(false);
+  };
+
+  const handleChangeWorkDir = () => {
+    useSettingsStore.getState().setWorkDirModalOpen(true);
+    setOpen(false);
+  };
+
+  const handleReset = () => {
+    setOpen(false);
+    void bridge.reloadWebview();
+  };
+
+  const handleShowLogs = () => {
+    void bridge.showLogs();
+    setOpen(false);
+  };
+
+  const handleAuthAction = async () => {
+    setLoading(true);
+    try {
+      if (isLoggedIn) {
+        await bridge.logout();
+        setIsLoggedIn(false);
+      } else {
+        const result = await bridge.login();
+        if (result.success) {
+          setIsLoggedIn(true);
+        } else {
+          toast.error(result.error ?? "Sign-in failed. Check the logs for details.");
+        }
+      }
+    } finally {
+      setLoading(false);
+      setOpen(false);
+    }
+    onAuthAction?.();
+  };
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger asChild>
+        <Button variant="ghost" size="icon-xs" className={cn("text-muted-foreground", className)}>
+          <IconSettings className="size-3.5" />
+        </Button>
+      </PopoverTrigger>
+      <PopoverContent className="w-[calc(100vw-1rem)] max-w-72 p-1.5 gap-0!" align="end" side="top">
+        <MenuSection title="Settings">
+          <MenuItem onClick={handleChangeWorkDir}>
+            <IconFolder className="size-4 text-muted-foreground" />
+            <span className="flex-1">Working Directory</span>
+          </MenuItem>
+          <MenuItem onClick={handleOpenMCPServers}>
+            <IconServer className="size-4 text-muted-foreground" />
+            <span className="flex-1">MCP Servers</span>
+          </MenuItem>
+          <MenuItem onClick={handleOpenSettings}>
+            <IconSettings className="size-4 text-muted-foreground" />
+            <span className="flex-1">General Config</span>
+            <span className="text-[10px] text-muted-foreground">↗</span>
+          </MenuItem>
+        </MenuSection>
+
+        <Separator className="my-px" />
+
+        <MenuSection title="Support" subtitle={extensionConfig.version ? `v${extensionConfig.version}` : undefined}>
+          <MenuItem onClick={handleShowLogs}>
+            <IconFileText className="size-4 text-muted-foreground" />
+            <span className="flex-1">Show Logs</span>
+          </MenuItem>
+          <MenuItem onClick={handleReset}>
+            <IconRefresh className="size-4 text-muted-foreground" />
+            <span className="flex-1">Reset Kimi</span>
+          </MenuItem>
+        </MenuSection>
+
+        <Separator className="my-px" />
+
+        <MenuSection title="Account">
+          <MenuItem
+            onClick={() => {
+              void handleAuthAction();
+            }}
+            disabled={loading}
+            danger={isLoggedIn}
+          >
+            {loading ? <IconLoader2 className="size-4 animate-spin" /> : isLoggedIn ? <IconLogout className="size-4" /> : <IconLogin className="size-4 text-muted-foreground" />}
+            <span className="flex-1">{loading ? "Processing..." : isLoggedIn ? "Sign out" : "Sign in"}</span>
+          </MenuItem>
+        </MenuSection>
+      </PopoverContent>
+    </Popover>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ApprovalDialog.tsx b/apps/vscode/webview-ui/src/components/ApprovalDialog.tsx
new file mode 100644
index 000000000..6c2d87735
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ApprovalDialog.tsx
@@ -0,0 +1,82 @@
+import { useState, useEffect } from "react";
+import { IconChevronDown, IconChevronUp } from "@tabler/icons-react";
+import { useApprovalStore } from "@/stores";
+import { DisplayBlocks } from "./DisplayBlocks";
+import { cn } from "@/lib/utils";
+import type { ApprovalResponse } from "shared/legacy-sdk";
+
+export function ApprovalDialog() {
+  const { pending, respondToRequest } = useApprovalStore();
+  const [selectedIndex, setSelectedIndex] = useState(1);
+  const [expanded, setExpanded] = useState(false);
+
+  const req = pending[0];
+
+  // Auto-expand if there's a diff block (code change)
+  useEffect(() => {
+    if (req) {
+      const hasDiff = req.display?.some((b) => b.type === "diff") ?? false;
+      setExpanded(hasDiff);
+    }
+  }, [req?.id]);
+
+  if (!req) return null;
+  const hasDisplay = req.display && req.display.length > 0;
+
+  const handleResponse = async (response: ApprovalResponse) => {
+    await respondToRequest(req.id, response);
+    setSelectedIndex(1);
+    setExpanded(false);
+  };
+
+  const options = [
+    { key: "approve", label: "Yes", index: 1 },
+    { key: "approve_for_session", label: "Yes, for this session", index: 2 },
+    { key: "reject", label: "No", index: 3 },
+  ] as const;
+
+  return (
+    <div className={cn("mb-0.5 border border-blue-200 dark:border-blue-800 rounded-lg overflow-hidden bg-background flex flex-col shrink")}>
+      <div className="p-2 space-y-2 flex-1 min-h-0 overflow-hidden flex flex-col">
+        <div className="flex items-center justify-between shrink-0">
+          <div className="text-xs font-semibold text-foreground">Allow this {req.action.toLowerCase()}?</div>
+          {hasDisplay && (
+            <button onClick={() => setExpanded(!expanded)} className="p-1 hover:bg-muted rounded transition-colors">
+              {expanded ? <IconChevronDown className="size-4 text-muted-foreground" /> : <IconChevronUp className="size-4 text-muted-foreground" />}
+            </button>
+          )}
+        </div>
+
+        <div className="text-xs text-foreground/90 break-all leading-relaxed bg-muted/30 py-2 px-2 rounded shrink-0 max-h-20 overflow-y-auto font-mono">{req.description}</div>
+
+        {hasDisplay && (
+          <div className={cn("overflow-y-auto", expanded ? "flex-1 min-h-0" : "max-h-24")}>
+            <DisplayBlocks blocks={req.display} maxHeight={expanded ? "max-h-none" : "max-h-20"} />
+          </div>
+        )}
+
+        <div className="text-xs text-muted-foreground shrink-0">{req.sender}</div>
+
+        <div className="space-y-1.5 pt-1 shrink-0">
+          {options.map((opt) => (
+            <button
+              key={opt.key}
+              onClick={() => {
+                void handleResponse(opt.key);
+              }}
+              onMouseEnter={() => setSelectedIndex(opt.index)}
+              className={cn(
+                "w-full text-left px-2 py-1 rounded-md text-xs transition-colors",
+                "border border-border cursor-pointer",
+                selectedIndex === opt.index ? "bg-blue-500 text-white border-blue-500" : "bg-background hover:bg-muted/50",
+              )}
+            >
+              <span className={cn("mr-2", selectedIndex === opt.index ? "text-blue-200" : "text-muted-foreground")}>{opt.index}</span>
+              <span className="font-medium">{opt.label}</span>
+            </button>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/BottomToolbar.tsx b/apps/vscode/webview-ui/src/components/BottomToolbar.tsx
new file mode 100644
index 000000000..dde016c6b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/BottomToolbar.tsx
@@ -0,0 +1,96 @@
+import { useState, useEffect } from "react";
+import { IconChevronUp, IconStack2, IconFileCode } from "@tabler/icons-react";
+import { useChatStore } from "@/stores";
+import { bridge, Events } from "@/services";
+import { cn } from "@/lib/utils";
+import { FileChangesPanel } from "./FileChangesPanel";
+import { QueuedMessagesPanel } from "./QueuedMessagesPanel";
+import { ApprovalDialog } from "./ApprovalDialog";
+import { QuestionDialog } from "./QuestionDialog";
+import type { FileChange } from "shared/types";
+
+type TabId = "queue" | "changes" | null;
+
+export function BottomToolbar() {
+  const { queue } = useChatStore();
+  const [activeTab, setActiveTab] = useState<TabId>(null);
+  const [fileChanges, setFileChanges] = useState<FileChange[]>([]);
+
+  useEffect(() => {
+    return bridge.on<FileChange[]>(Events.FileChangesUpdated, setFileChanges);
+  }, []);
+
+  // Auto-close tab when data becomes empty
+  useEffect(() => {
+    if (activeTab === "queue" && queue.length === 0) {
+      setActiveTab(null);
+    }
+    if (activeTab === "changes" && fileChanges.length === 0) {
+      setActiveTab(null);
+    }
+  }, [activeTab, queue.length, fileChanges.length]);
+
+  const hasQueue = queue.length > 0;
+  const hasChanges = fileChanges.length > 0;
+  const hasTabs = hasQueue || hasChanges;
+
+  const toggleTab = (tab: TabId) => {
+    setActiveTab((prev) => (prev === tab ? null : tab));
+  };
+
+  const fileStats = fileChanges.reduce((a, c) => ({ additions: a.additions + c.additions, deletions: a.deletions + c.deletions }), { additions: 0, deletions: 0 });
+
+  return (
+    <div className="flex flex-col min-h-0 flex-1 overflow-hidden">
+      {/* ApprovalDialog and QuestionDialog - priority, shrink-0 */}
+      <ApprovalDialog />
+      <QuestionDialog />
+
+      {/* Queue/Changes panel - takes remaining space */}
+      {activeTab && (
+        <div className="flex-1 min-h-16 max-h-32 overflow-y-auto mb-0.5 border border-border/60 rounded-md bg-card">
+          {activeTab === "queue" && <QueuedMessagesPanel />}
+          {activeTab === "changes" && <FileChangesPanel changes={fileChanges} />}
+        </div>
+      )}
+
+      {/* Tab bar - always at bottom, shrink-0 */}
+      {hasTabs && (
+        <div className="shrink-0 mb-0.5 rounded-md overflow-hidden bg-card">
+          <div className="flex items-center gap-1 py-0.5 min-h-7">
+            {hasQueue && (
+              <button
+                onClick={() => toggleTab("queue")}
+                className={cn(
+                  "flex items-center gap-1.5 px-2 py-0.5 rounded text-xs transition-colors",
+                  activeTab === "queue" ? "bg-accent text-accent-foreground" : "hover:bg-muted/50 text-muted-foreground",
+                )}
+              >
+                <IconStack2 className="size-3.5" />
+                <span>{queue.length} Queued</span>
+                <IconChevronUp className={cn("size-3 transition-transform", activeTab === "queue" && "rotate-180")} />
+              </button>
+            )}
+
+            {hasChanges && (
+              <button
+                onClick={() => toggleTab("changes")}
+                className={cn(
+                  "flex items-center gap-1.5 px-2 py-0.5 rounded text-xs transition-colors",
+                  activeTab === "changes" ? "bg-accent text-accent-foreground" : "hover:bg-muted/50 text-muted-foreground",
+                )}
+              >
+                <IconFileCode className="size-3.5" />
+                <span>{fileChanges.length} Changed</span>
+                <span className="text-[10px] tabular-nums">
+                  <span className="text-green-600 dark:text-green-400">+{fileStats.additions}</span> <span className="text-red-600 dark:text-red-400">-{fileStats.deletions}</span>
+                </span>
+                <IconChevronUp className={cn("size-3 transition-transform", activeTab === "changes" && "rotate-180")} />
+              </button>
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ChatArea.tsx b/apps/vscode/webview-ui/src/components/ChatArea.tsx
new file mode 100644
index 000000000..cc086b951
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ChatArea.tsx
@@ -0,0 +1,63 @@
+import ScrollToBottom, { useScrollToBottom, useSticky } from "react-scroll-to-bottom";
+import { IconArrowDown } from "@tabler/icons-react";
+import { ChatMessage } from "./ChatMessage";
+import { WelcomeScreen } from "./WelcomeScreen";
+import { useChatStore } from "@/stores";
+import { cn } from "@/lib/utils";
+import { getForkTurnIndex } from "shared/fork-turn-index";
+
+function ScrollButton() {
+  const scrollToBottom = useScrollToBottom();
+  const [sticky] = useSticky();
+
+  if (sticky) return null;
+
+  return (
+    <button
+      onClick={() => scrollToBottom()}
+      className={cn("absolute bottom-4 right-4 p-2 rounded-full z-10", "bg-blue-400 text-white shadow-lg", "hover:bg-blue-600 transition-all")}
+    >
+      <IconArrowDown className="size-4" />
+    </button>
+  );
+}
+
+function MessageList() {
+  const { messages, isStreaming } = useChatStore();
+
+  return (
+    <>
+      <div className="">
+        {messages.map((message, idx) => (
+          <ChatMessage
+            key={message.id}
+            message={message}
+            turnIndex={getForkTurnIndex(messages, idx)}
+            isStreaming={isStreaming && idx === messages.length - 1 && message.role === "assistant"}
+          />
+        ))}
+      </div>
+      <ScrollButton />
+    </>
+  );
+}
+
+export function ChatArea() {
+  const { messages } = useChatStore();
+
+  if (messages.length === 0) {
+    return (
+      <div className="h-full flex items-center justify-center relative">
+        <WelcomeScreen />
+      </div>
+    );
+  }
+
+  return (
+    <div className="h-full relative">
+      <ScrollToBottom className="h-full" scrollViewClassName="h-full overflow-y-auto overflow-x-hidden" followButtonClassName="hidden" initialScrollBehavior="auto">
+        <MessageList />
+      </ScrollToBottom>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ChatMessage.tsx b/apps/vscode/webview-ui/src/components/ChatMessage.tsx
new file mode 100644
index 000000000..91c660776
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ChatMessage.tsx
@@ -0,0 +1,338 @@
+import { useState, Fragment } from "react";
+import { IconLoader3, IconGitFork } from "@tabler/icons-react";
+import { cn } from "@/lib/utils";
+import { Content } from "@/lib/content";
+import { Markdown } from "./Markdown";
+import { ToolCallCard } from "./ToolRenderers";
+import { CopyButton } from "./CopyButton";
+import { ThinkingBlock } from "./ThinkingBlock";
+import { CompactionCard } from "./CompactionCard";
+import { MediaThumbnail } from "./MediaThumbnail";
+import { MediaPreviewModal } from "./MediaPreviewModal";
+import { InlineError } from "./InlineError";
+import { PlanCard } from "./PlanCard";
+import { StreamingConfirmDialog } from "./StreamingConfirmDialog";
+import { Button } from "@/components/ui/button";
+import { toast } from "@/components/ui/sonner";
+import { useChatStore } from "@/stores";
+import { bridge } from "@/services";
+import type { ChatMessage as ChatMessageType, UIStep, UIStepItem } from "@/stores/chat.store";
+import type { ContentPart } from "shared/legacy-sdk";
+
+interface ChatMessageProps {
+  message: ChatMessageType;
+  /** 0-indexed turn number for this message */
+  turnIndex?: number;
+  isStreaming?: boolean;
+}
+
+function ThinkingIndicator() {
+  return (
+    <div className="flex items-center gap-2 mt-1 text-blue-500/80 py-1">
+      <IconLoader3 className="size-3.5 animate-spin" />
+      <span className="text-[11px] font-medium tracking-wide">Processing...</span>
+    </div>
+  );
+}
+
+function SteerBubble({ content }: { content: string | ContentPart[] }) {
+  const text = typeof content === "string" ? content : Content.getText(content);
+  return (
+    <div className="flex justify-end my-1">
+      <div className="max-w-[85%] px-3 py-1 rounded-2xl rounded-br-md bg-zinc-100 dark:bg-zinc-800 text-foreground">
+        <p className="text-xs leading-relaxed">{text}</p>
+      </div>
+    </div>
+  );
+}
+
+function StepItemRenderer({ item }: { item: UIStepItem }) {
+  switch (item.type) {
+    case "thinking":
+      return <ThinkingBlock content={item.content} finished={item.finished} />;
+    case "text":
+      return <Markdown content={item.content} className="text-xs leading-relaxed" enableEnrichment={item.finished === true} />;
+    case "tool_use":
+      return <ToolCallCard call={item.call} result={item.result} subagentSteps={item.subagent_steps} />;
+    case "compaction":
+      return <CompactionCard />;
+    case "steer":
+      return <SteerBubble content={item.content} />;
+    default:
+      return null;
+  }
+}
+
+function StepContent({ step, showConnector }: { step: UIStep; showConnector?: boolean }) {
+  const hasItems = step.items.length > 0;
+  const hasToolOrThinking = step.items.some((item) => item.type === "tool_use" || item.type === "thinking" || item.type === "compaction");
+  const showIndicator = hasToolOrThinking;
+  const hasActiveItem = step.items.some((item) => (item.type === "text" || item.type === "thinking") && !item.finished);
+
+  if (!hasItems) {
+    return null;
+  }
+
+  return (
+    <div className="flex gap-2">
+      {showIndicator ? (
+        <div className="hidden @[420px]:flex shrink-0 w-5 flex-col items-center relative">
+          <div
+            className={cn("size-1.5 rounded-full mt-2 shrink-0 relative z-10", hasActiveItem ? "bg-blue-400 shadow-[0_0_8px_rgba(59,130,246,0.6)] animate-pulse" : "bg-blue-400")}
+          />
+          {showConnector && (
+            <div
+              className={cn(
+                "absolute left-1/2 w-px",
+                hasActiveItem ? "bg-gradient-to-b from-zinc-300 to-transparent dark:from-zinc-600 dark:to-transparent" : "bg-zinc-300 dark:bg-zinc-600",
+              )}
+              style={{ top: "calc(0.5rem + 0.1875rem)", bottom: "calc(-0.75rem - 0.5rem - 0.1875rem)", transform: "translateX(-50%)" }}
+            />
+          )}
+        </div>
+      ) : (
+        <div className="hidden @[420px]:block shrink-0 w-5" />
+      )}
+      <div className="flex-1 min-w-0 space-y-2">
+        {step.items.map((item, idx) => (
+          <StepItemRenderer key={`${step.n}-${idx}`} item={item} />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function MessageMedia({ images, videos, onPreview }: { images: string[]; videos: string[]; onPreview: (src: string) => void }) {
+  if (images.length === 0 && videos.length === 0) {
+    return null;
+  }
+  return (
+    <div className="flex flex-wrap gap-2 my-2">
+      {images.map((src, idx) => (
+        <MediaThumbnail key={`img-${idx}`} src={src} size="md" onClick={() => onPreview(src)} />
+      ))}
+      {videos.map((src, idx) => (
+        <MediaThumbnail key={`vid-${idx}`} src={src} size="md" onClick={() => onPreview(src)} />
+      ))}
+    </div>
+  );
+}
+
+interface StepGroup {
+  planMode: boolean;
+  steps: UIStep[];
+  startIndex: number;
+}
+
+function groupStepsByPlanMode(steps: UIStep[]): StepGroup[] {
+  const groups: StepGroup[] = [];
+  for (let i = 0; i < steps.length; i++) {
+    const isPlan = steps[i].planMode === true;
+    const last = groups.at(-1);
+    if (last && last.planMode === isPlan) {
+      last.steps.push(steps[i]);
+    } else {
+      groups.push({ planMode: isPlan, steps: [steps[i]], startIndex: i });
+    }
+  }
+  return groups;
+}
+
+interface ForkButtonProps {
+  turnIndex: number;
+  className?: string;
+}
+
+function ForkButton({ turnIndex, className }: ForkButtonProps) {
+  const [showConfirm, setShowConfirm] = useState(false);
+  const [isForking, setIsForking] = useState(false);
+  const { sessionId, isStreaming, loadSession } = useChatStore();
+
+  const handleFork = () => {
+    if (!sessionId || turnIndex < 0) return;
+    setShowConfirm(true);
+  };
+
+  const doFork = async () => {
+    if (!sessionId) return;
+
+    setIsForking(true);
+    try {
+      const result = await bridge.forkSession(sessionId, turnIndex);
+      if (result) {
+        // Load the forked session
+        const events = await bridge.loadSessionHistory(result.sessionId);
+        await loadSession(result.sessionId, events);
+      }
+    } catch (error) {
+      toast.error(`Failed to fork conversation: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      setIsForking(false);
+      setShowConfirm(false);
+    }
+  };
+
+  return (
+    <>
+      <Button
+        variant="ghost"
+        size="icon-xs"
+        className={cn(
+          "h-5 w-5 text-muted-foreground hover:text-foreground transition-all border-0! hover:bg-zinc-200 dark:hover:bg-zinc-800 cursor-pointer",
+          isForking && "opacity-50 pointer-events-none",
+          className,
+        )}
+        onClick={handleFork}
+        disabled={isForking || !sessionId}
+        title="Fork conversation from this point"
+      >
+        <IconGitFork className="size-3.5" />
+      </Button>
+
+      <StreamingConfirmDialog
+        open={showConfirm}
+        onOpenChange={setShowConfirm}
+        title="Fork Conversation"
+        description={
+          isStreaming
+            ? "The current conversation is still generating a response. Forking will stop the generation and create a new conversation from this point. Continue?"
+            : "This will create a new conversation branching from this point. All messages after this turn will be removed in the forked conversation. Continue?"
+        }
+        confirmLabel="Fork"
+        onConfirm={() => { void doFork(); }}
+        confirmLoading={isForking}
+        confirmDisabled={isForking}
+        cancelDisabled={isForking}
+      />
+    </>
+  );
+}
+
+function UserMessage({ message }: { message: ChatMessageType }) {
+  const [previewMedia, setPreviewMedia] = useState<string | null>(null);
+  const displayContent = Content.getText(message.content);
+  const images = Content.getImages(message.content);
+  const videos = Content.getVideos(message.content);
+
+  return (
+    <div className="px-3 pt-3 pb-1 flex justify-end">
+      <div className={cn("max-w-[85%] px-3.5 py-1.5 rounded-2xl rounded-br-md", "bg-zinc-100 dark:bg-zinc-800", "text-foreground")}>
+        {displayContent && (
+          // FIX: removed whitespace-pre-wrap — it conflicted with ReactMarkdown's
+          // block-level elements (<p>, <ol>, <li>), doubling vertical spacing.
+          // ReactMarkdown already handles paragraph breaks from \n\n.
+          <div className="text-xs leading-relaxed wrap-break-word">
+            <Markdown content={displayContent} enableEnrichment enableLocalImageRender={false} />
+          </div>
+        )}
+        <MessageMedia images={images} videos={videos} onPreview={setPreviewMedia} />
+      </div>
+      <MediaPreviewModal src={previewMedia} onClose={() => setPreviewMedia(null)} />
+    </div>
+  );
+}
+
+function AssistantMessage({ message, turnIndex, isStreaming }: { message: ChatMessageType; turnIndex?: number; isStreaming?: boolean }) {
+  const [previewMedia, setPreviewMedia] = useState<string | null>(null);
+  const { isCompacting } = useChatStore();
+
+  const steps = message.steps || [];
+  const hasSteps = steps.length > 0;
+  const images = Content.getImages(message.content);
+  const videos = Content.getVideos(message.content);
+
+  const stepHasIndicator = steps.map((step) => step.items.some((item) => item.type === "tool_use" || item.type === "thinking" || item.type === "compaction"));
+
+  const contentToCopy = (() => {
+    if (!hasSteps) {
+      return typeof message.content === "string" ? message.content : "";
+    }
+    const lastStep = steps[steps.length - 1];
+    const textItems = lastStep.items.filter((item) => item.type === "text");
+    if (textItems.length > 0) {
+      return textItems.map((item) => (item as { type: "text"; content: string }).content).join("\n");
+    }
+    return typeof message.content === "string" ? message.content : "";
+  })();
+
+  if (!isStreaming && !hasMessageContent(message) && !message.inlineError) {
+    return null;
+  }
+
+  const displayContent = typeof message.content === "string" ? message.content : "";
+  const isShowingInlineError = message.inlineError && !isStreaming;
+
+  return (
+    <div className="@container px-3 py-3 group/message">
+      <div className="flex gap-3 flex-col">
+        <div className="flex flex-row items-center justify-start gap-2">
+          <div className="shrink-0 size-5 rounded flex items-center justify-center text-[10px] font-medium bg-blue-500 text-white">K</div>
+          <div className="text-xs font-semibold text-muted-foreground uppercase tracking-wide">Kimi</div>
+        </div>
+
+        <div className="flex-1 min-w-0">
+          <div className="flex flex-col">
+            <div className="[&>*:not(:last-child)]:mb-3">
+              {hasSteps &&
+                groupStepsByPlanMode(steps).map((group, gi) => {
+                  const totalSteps = steps.length;
+                  const stepsContent = group.steps.map((step, i) => {
+                    const globalIndex = group.startIndex + i;
+                    const isLastInGroup = i === group.steps.length - 1;
+                    const isLastOverall = globalIndex === totalSteps - 1;
+                    const hasIndicator = stepHasIndicator[globalIndex];
+                    const hasNextIndicator = stepHasIndicator.slice(globalIndex + 1).some(Boolean);
+                    const showConnector = hasIndicator && hasNextIndicator && !isLastInGroup && !isLastOverall;
+                    return <StepContent key={step.n} step={step} showConnector={showConnector} />;
+                  });
+
+                  if (group.planMode) {
+                    return <PlanCard key={`plan-${gi}`}>{stepsContent}</PlanCard>;
+                  }
+                  return <Fragment key={`normal-${gi}`}>{stepsContent}</Fragment>;
+                })}
+              {!hasSteps && displayContent && <Markdown content={displayContent} className="text-xs leading-relaxed @[420px]:pl-5" enableEnrichment={!isStreaming} />}
+              {(images.length > 0 || videos.length > 0) && (
+                <div className="@[420px]:pl-5">
+                  <MessageMedia images={images} videos={videos} onPreview={setPreviewMedia} />
+                </div>
+              )}
+            </div>
+
+            {/* 内嵌错误显示 */}
+            {isShowingInlineError && message.inlineError && (
+              <div className="@[420px]:pl-5">
+                <InlineError error={message.inlineError} />
+              </div>
+            )}
+            <div className="flex flex-row items-center space-between">
+              <div className="inline-flex flex-1">{isStreaming && !isShowingInlineError && !isCompacting && <ThinkingIndicator />}</div>
+              <div className="inline-flex flex-1" />
+              {!isStreaming && contentToCopy.trim().length > 0 && (
+                <div className="flex justify-start pt-1 gap-1 opacity-0 group-hover/message:opacity-100 transition-opacity duration-100">
+                  <CopyButton content={contentToCopy} />
+                  {message.forkable !== false && turnIndex !== undefined && turnIndex >= 0 && <ForkButton turnIndex={turnIndex} />}
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+      <MediaPreviewModal src={previewMedia} onClose={() => setPreviewMedia(null)} />
+    </div>
+  );
+}
+
+function hasMessageContent(message: ChatMessageType): boolean {
+  if (!Content.isEmpty(message.content)) {
+    return true;
+  }
+  return message.steps?.some((s) => s.items.length > 0) ?? false;
+}
+
+export function ChatMessage({ message, turnIndex, isStreaming }: ChatMessageProps) {
+  if (message.role === "user") {
+    return <UserMessage message={message} />;
+  }
+  return <AssistantMessage message={message} turnIndex={turnIndex} isStreaming={isStreaming} />;
+}
diff --git a/apps/vscode/webview-ui/src/components/ChatStatus.tsx b/apps/vscode/webview-ui/src/components/ChatStatus.tsx
new file mode 100644
index 000000000..e11f84208
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ChatStatus.tsx
@@ -0,0 +1,117 @@
+import { useChatStore } from "@/stores";
+import { cn } from "@/lib/utils";
+import { IconArrowUp, IconArrowDown, IconBrandSpeedtest, IconRefresh } from "@tabler/icons-react";
+import { Tooltip, TooltipContent, TooltipTrigger } from "./ui/tooltip";
+
+export function TokenInfo() {
+  const { lastStatus, tokenUsage, activeTokenUsage } = useChatStore();
+
+  const inputTotal =
+    tokenUsage.input_other +
+    tokenUsage.input_cache_read +
+    tokenUsage.input_cache_creation +
+    activeTokenUsage.input_other +
+    activeTokenUsage.input_cache_read +
+    activeTokenUsage.input_cache_creation;
+
+  const outputTotal = tokenUsage.output + activeTokenUsage.output;
+
+  const contextPercent = lastStatus?.context_usage ? Math.round(lastStatus.context_usage * 1000) / 10 : 0;
+
+  return (
+    <div className="space-y-2">
+      <div className="text-[10px] text-muted-foreground uppercase tracking-wider">Token Usage</div>
+      <div className="grid grid-cols-3 gap-2 text-xs">
+        <div className="flex flex-col">
+          <span className="text-muted-foreground text-[10px]">Context</span>
+          <span className={cn(contextPercent > 80 && "text-amber-500", contextPercent > 95 && "text-destructive")}>{contextPercent}%</span>
+        </div>
+        <div className="flex flex-col">
+          <span className="text-muted-foreground text-[10px]">Input</span>
+          <span>{inputTotal.toLocaleString()}</span>
+        </div>
+        <div className="flex flex-col">
+          <span className="text-muted-foreground text-[10px]">Output</span>
+          <span>{outputTotal.toLocaleString()}</span>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function ChatStatus() {
+  const { lastStatus, tokenUsage, activeTokenUsage } = useChatStore();
+
+  if (!lastStatus) {
+    return null;
+  }
+
+  const { context_usage } = lastStatus;
+  const retrying = lastStatus.retrying;
+
+  const inputTotal =
+    tokenUsage.input_other +
+    tokenUsage.input_cache_read +
+    tokenUsage.input_cache_creation +
+    activeTokenUsage.input_other +
+    activeTokenUsage.input_cache_read +
+    activeTokenUsage.input_cache_creation;
+
+  const outputTotal = tokenUsage.output + activeTokenUsage.output;
+
+  const contextPercent = context_usage ? Math.round(context_usage * 1000) / 10 : 0;
+
+  return (
+    <div className="flex items-center gap-3 text-[10px] text-muted-foreground border border-border/40 rounded-full px-2 py-0.5 select-none h-6 box-border mr-2 @max-[240px]:hidden">
+      {retrying && (
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <span className="flex items-center gap-1 text-amber-500">
+              <IconRefresh className="size-3" />
+              Retry {retrying.next_attempt}/{retrying.max_attempts}
+            </span>
+          </TooltipTrigger>
+          <TooltipContent>
+            Retrying in {Math.ceil(retrying.delay_ms / 1000)}s: {retrying.message}
+          </TooltipContent>
+        </Tooltip>
+      )}
+      {retrying && <div className="w-px h-3 bg-border/50" />}
+      <div className="flex items-center gap-1.5" title="Context Window Usage">
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <span className="flex items-center gap-1.5">
+              <IconBrandSpeedtest className="size-3 opacity-70" />
+              <span className={cn(contextPercent > 80 && "text-amber-500", contextPercent > 95 && "text-destructive")}>{contextPercent}%</span>
+            </span>
+          </TooltipTrigger>
+          <TooltipContent>Context Window Usage</TooltipContent>
+        </Tooltip>
+      </div>
+      <div className="w-px h-3 bg-border/50 @max-[440px]:hidden" />
+      <div className="flex items-center gap-1.5 @max-[440px]:hidden" title="Total Input Tokens">
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <span className="flex items-center gap-1.5">
+              <IconArrowUp className="size-3 opacity-70" />
+              <span>{inputTotal.toLocaleString()}</span>
+            </span>
+          </TooltipTrigger>
+          <TooltipContent>Total Input Tokens</TooltipContent>
+        </Tooltip>
+      </div>
+      <div className="w-px h-3 bg-border/50 @max-[440px]:hidden" />
+      <div className="flex items-center gap-1.5 @max-[440px]:hidden" title="Output Tokens">
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <span className="flex items-center gap-1.5">
+              <IconArrowDown className="size-3 opacity-70" />
+              <span>{outputTotal.toLocaleString()}</span>
+            </span>
+          </TooltipTrigger>
+          <TooltipContent>Total Output Tokens</TooltipContent>
+        </Tooltip>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/CompactionCard.tsx b/apps/vscode/webview-ui/src/components/CompactionCard.tsx
new file mode 100644
index 000000000..fa87df768
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/CompactionCard.tsx
@@ -0,0 +1,23 @@
+import { IconLoader2 } from "@tabler/icons-react";
+import { useChatStore } from "@/stores";
+
+export function CompactionCard() {
+  const { isCompacting } = useChatStore();
+
+  return (
+    <div className="rounded-lg border border-border bg-muted/20 overflow-hidden">
+      <div className="flex items-center gap-3 px-3 py-2.5">
+        {isCompacting ? (
+          <IconLoader2 className="size-4 text-blue-500 animate-spin" />
+        ) : (
+          <div className="size-4 flex items-center justify-center">
+            <div className="size-2 rounded-full bg-emerald-500" />
+          </div>
+        )}
+        <div className="flex-1 min-w-0">
+          <div className="text-xs font-medium text-foreground">{isCompacting ? "Compacting context..." : "Context compacted"}</div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ConfigErrorScreen.tsx b/apps/vscode/webview-ui/src/components/ConfigErrorScreen.tsx
new file mode 100644
index 000000000..a70bf6a9b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ConfigErrorScreen.tsx
@@ -0,0 +1,185 @@
+import { useState } from "react";
+import {
+  IconAlertTriangle,
+  IconArrowLeft,
+  IconCheck,
+  IconCopy,
+  IconFileSettings,
+  IconFolderOpen,
+  IconLoader2,
+  IconRefresh,
+  IconTerminal2,
+} from "@tabler/icons-react";
+
+import { bridge } from "@/services";
+import { Button } from "@/components/ui/button";
+import { KimiMascot } from "./KimiMascot";
+
+interface Props {
+  type: "loading" | "runtime-error" | "no-models" | "no-workspace";
+  errorMessage?: string | null;
+  onRefresh?: () => void;
+  onBackToLogin?: () => void;
+}
+
+function ErrorDetails({ message }: { message?: string | null }) {
+  const [copied, setCopied] = useState(false);
+
+  if (!message) return null;
+
+  const copyError = async () => {
+    await navigator.clipboard.writeText(message);
+    setCopied(true);
+    window.setTimeout(() => setCopied(false), 2_000);
+  };
+
+  return (
+    <div className="bg-muted/50 rounded-lg p-4 text-left space-y-2">
+      <div className="flex items-center justify-between gap-2 text-xs text-muted-foreground">
+        <div className="flex items-center gap-2 min-w-0">
+          <IconTerminal2 className="size-4" />
+          <span>Error details</span>
+        </div>
+        <Button
+          onClick={() => {
+            void copyError();
+          }}
+          variant="ghost"
+          size="xs"
+          className="h-6 px-1.5 gap-1 shrink-0"
+        >
+          {copied ? <IconCheck className="size-3" /> : <IconCopy className="size-3" />}
+          {copied ? "Copied" : "Copy"}
+        </Button>
+      </div>
+      <pre className="max-h-36 overflow-auto whitespace-pre-wrap break-words text-xs bg-background rounded px-3 py-2 font-mono text-foreground">{message}</pre>
+    </div>
+  );
+}
+
+function NoModelsContent({ onRefresh, onBackToLogin }: Pick<Props, "onRefresh" | "onBackToLogin">) {
+  return (
+    <>
+      <div className="space-y-2">
+        <div className="inline-flex items-center gap-2 text-amber-500">
+          <IconAlertTriangle className="size-5" />
+          <span className="text-sm font-medium">Model setup required</span>
+        </div>
+        <p className="text-xs text-muted-foreground">
+          Sign in with a Kimi account, or configure a provider and model in your shared Kimi Code <code className="bg-muted px-1 rounded">config.toml</code>.
+        </p>
+      </div>
+
+      <div className="bg-muted/50 rounded-lg p-4 text-left space-y-2">
+        <div className="flex items-center gap-2 text-xs font-medium">
+          <IconFileSettings className="size-4" />
+          Shared Kimi Code configuration
+        </div>
+        <p className="text-xs text-muted-foreground">
+          VS Code and the terminal UI use the same Kimi Code home, configuration, credentials, and sessions.
+        </p>
+      </div>
+
+      <div className="flex flex-col min-[400px]:flex-row min-[400px]:justify-between gap-2 w-full">
+        {onBackToLogin && (
+          <Button onClick={onBackToLogin} variant="ghost" size="sm" className="gap-1 text-muted-foreground">
+            <IconArrowLeft className="size-3" />
+            Back to sign in
+          </Button>
+        )}
+        {onRefresh && (
+          <Button onClick={onRefresh} variant="ghost" size="sm" className="gap-1 text-muted-foreground">
+            <IconRefresh className="size-3" />
+            Reload
+          </Button>
+        )}
+      </div>
+    </>
+  );
+}
+
+export function ConfigErrorScreen({ type, errorMessage, onRefresh, onBackToLogin }: Props) {
+  if (type === "loading") {
+    return (
+      <div className="h-full flex items-center justify-center p-6">
+        <div className="text-center space-y-4">
+          <KimiMascot className="h-10 mx-auto opacity-50" />
+          <div className="inline-flex items-center gap-2 text-muted-foreground">
+            <IconLoader2 className="size-4 animate-spin" />
+            <span className="text-sm">Starting Kimi Code...</span>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  if (type === "no-workspace") {
+    return (
+      <div className="h-full flex items-center justify-center p-6">
+        <div className="max-w-sm text-center space-y-6">
+          <KimiMascot className="h-10 mx-auto opacity-50" />
+          <div className="space-y-2">
+            <div className="inline-flex items-center gap-2 text-amber-500">
+              <IconFolderOpen className="size-5" />
+              <span className="text-sm font-medium">No workspace open</span>
+            </div>
+            <p className="text-xs text-muted-foreground">Open a folder to start using Kimi Code.</p>
+          </div>
+          <Button
+            onClick={() => {
+              void bridge.openFolder();
+            }}
+            className="gap-2"
+          >
+            <IconFolderOpen className="size-4" />
+            Open Folder
+          </Button>
+        </div>
+      </div>
+    );
+  }
+
+  if (type === "no-models") {
+    return (
+      <div className="h-full flex items-center justify-center p-6">
+        <div className="max-w-sm text-center space-y-6">
+          <KimiMascot className="h-10 mx-auto opacity-50" />
+          <NoModelsContent onRefresh={onRefresh} onBackToLogin={onBackToLogin} />
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex-1 min-h-0 overflow-y-auto p-6">
+      <div className="max-w-sm mx-auto text-center space-y-6">
+        <KimiMascot className="h-10 mx-auto opacity-50" />
+        <div className="space-y-2">
+          <div className="inline-flex items-center gap-2 text-red-500">
+            <IconAlertTriangle className="size-5" />
+            <span className="text-sm font-medium">Kimi Code could not start</span>
+          </div>
+          <p className="text-xs text-muted-foreground">Check the error below. Full diagnostics are available in the Kimi Code output channel.</p>
+        </div>
+        <ErrorDetails message={errorMessage} />
+        <div className="flex gap-2 justify-center">
+          <Button
+            onClick={() => {
+              void bridge.showLogs();
+            }}
+            variant="outline"
+            size="sm"
+          >
+            Show Logs
+          </Button>
+          {onRefresh && (
+            <Button onClick={onRefresh} size="sm" className="gap-1">
+              <IconRefresh className="size-3" />
+              Retry
+            </Button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/CopyButton.tsx b/apps/vscode/webview-ui/src/components/CopyButton.tsx
new file mode 100644
index 000000000..31f71cb99
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/CopyButton.tsx
@@ -0,0 +1,45 @@
+import { useState } from "react";
+import { IconCopy, IconCheck } from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+interface CopyButtonProps {
+  content: string;
+  className?: string;
+}
+
+export function CopyButton({ content, className }: CopyButtonProps) {
+  const [isCopied, setIsCopied] = useState(false);
+
+  const handleCopy = async () => {
+    if (!content) return;
+
+    try {
+      await navigator.clipboard.writeText(content);
+      setIsCopied(true);
+      setTimeout(() => setIsCopied(false), 2000);
+    } catch (err) {
+      console.error("Failed to copy:", err);
+    }
+  };
+
+  if (!content) return null;
+
+  return (
+    <Button
+      variant="ghost"
+      size="icon-xs"
+      className={cn(
+        "h-5 w-5 text-muted-foreground hover:text-foreground transition-all border-0! hover:bg-zinc-200 dark:hover:bg-zinc-800 cursor-pointer",
+        isCopied && "text-emerald-500 hover:text-emerald-600",
+        className,
+      )}
+      onClick={() => {
+        void handleCopy();
+      }}
+      title="Copy message"
+    >
+      {isCopied ? <IconCheck className="size-3.5" /> : <IconCopy className="size-3.5" />}
+    </Button>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/DisplayBlocks.tsx b/apps/vscode/webview-ui/src/components/DisplayBlocks.tsx
new file mode 100644
index 000000000..f435e782d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/DisplayBlocks.tsx
@@ -0,0 +1,227 @@
+import { useMemo } from "react";
+import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
+import { oneDark, oneLight } from "react-syntax-highlighter/dist/esm/styles/prism";
+import type { DisplayBlock, DiffBlock, TodoBlock, BriefBlock, ShellBlock } from "shared/legacy-sdk";
+import { cn } from "@/lib/utils";
+import * as Diff from "diff";
+
+function useIsDark(): boolean {
+  return typeof document !== "undefined" && document.documentElement.classList.contains("dark");
+}
+
+interface DiffBlockProps {
+  block: DiffBlock;
+  maxHeight?: string;
+}
+
+interface DiffPart {
+  value: string;
+  added?: boolean;
+  removed?: boolean;
+}
+
+function renderDiffLine(parts: DiffPart[], type: "added" | "removed"): React.ReactNode {
+  return parts.map((part, i) => {
+    if (type === "removed") {
+      if (part.added) return null;
+      return (
+        <span key={i} className={cn(part.removed && "bg-red-300/50 dark:bg-red-700/50 rounded-sm")}>
+          {part.value}
+        </span>
+      );
+    } else {
+      if (part.removed) return null;
+      return (
+        <span key={i} className={cn(part.added && "bg-emerald-300/50 dark:bg-emerald-700/50 rounded-sm")}>
+          {part.value}
+        </span>
+      );
+    }
+  });
+}
+
+// Extract diff computation to a pure function for memoization
+function computeDiffLines(oldText: string, newText: string): { oldLines: DiffPart[][]; newLines: DiffPart[][] } {
+  const diffParts = Diff.diffWords(oldText, newText);
+
+  const oldLines: DiffPart[][] = [];
+  const newLines: DiffPart[][] = [];
+  let currentOldLine: DiffPart[] = [];
+  let currentNewLine: DiffPart[] = [];
+
+  for (const part of diffParts) {
+    const lines = part.value.split("\n");
+    lines.forEach((line, lineIndex) => {
+      const isLastLine = lineIndex === lines.length - 1;
+      const partForLine: DiffPart = {
+        value: line,
+        added: part.added,
+        removed: part.removed,
+      };
+
+      if (!part.added) {
+        currentOldLine.push(partForLine);
+      }
+      if (!part.removed) {
+        currentNewLine.push(partForLine);
+      }
+
+      if (!isLastLine) {
+        if (!part.added) {
+          oldLines.push(currentOldLine);
+          currentOldLine = [];
+        }
+        if (!part.removed) {
+          newLines.push(currentNewLine);
+          currentNewLine = [];
+        }
+      }
+    });
+  }
+
+  if (currentOldLine.length > 0) oldLines.push(currentOldLine);
+  if (currentNewLine.length > 0) newLines.push(currentNewLine);
+
+  return { oldLines, newLines };
+}
+
+export function DiffBlockView({ block, maxHeight = "max-h-40" }: DiffBlockProps) {
+  const fileName = block.path.split("/").pop() || block.path;
+  const hasOld = block.old_text.length > 0;
+  const hasNew = block.new_text.length > 0;
+
+  const { oldLines, newLines } = useMemo(() => computeDiffLines(block.old_text, block.new_text), [block.old_text, block.new_text]);
+
+  return (
+    <div className="text-[11px] border border-border rounded-md overflow-hidden">
+      <div className="px-2 py-1 bg-muted/50 border-b border-border text-muted-foreground truncate">{fileName}</div>
+      <div className="flex flex-col md:flex-row">
+        {hasOld && (
+          <div className="bg-red-500/5 dark:bg-red-500/10 border-b md:border-b-0 md:border-r border-border/50 flex-1 min-w-0">
+            <div className={cn("px-2 py-1.5 overflow-auto", maxHeight)}>
+              {oldLines.map((lineParts, i) => (
+                <div key={i} className="flex">
+                  <span className="text-red-500 select-none mr-2 shrink-0">-</span>
+                  <span className="text-red-600 dark:text-red-400 whitespace-pre-wrap break-all">{renderDiffLine(lineParts, "removed") || " "}</span>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+        {hasNew && (
+          <div className="bg-emerald-500/5 dark:bg-emerald-500/10 flex-1 min-w-0">
+            <div className={cn("px-2 py-1.5 overflow-auto", maxHeight)}>
+              {newLines.map((lineParts, i) => (
+                <div key={i} className="flex">
+                  <span className="text-emerald-500 select-none mr-2 shrink-0">+</span>
+                  <span className="text-emerald-600 dark:text-emerald-400 whitespace-pre-wrap break-all">{renderDiffLine(lineParts, "added") || " "}</span>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+interface TodoBlockProps {
+  block: TodoBlock;
+}
+
+export function TodoBlockView({ block }: TodoBlockProps) {
+  return (
+    <div className="text-xs border border-border rounded-md overflow-hidden">
+      {block.items.map((item, i) => (
+        <div key={i} className={cn("px-2 py-1.5 flex items-center gap-2", i !== block.items.length - 1 && "border-b border-border/50")}>
+          <span
+            className={cn(
+              "size-2 rounded-full shrink-0",
+              item.status === "done" && "bg-emerald-500",
+              item.status === "in_progress" && "bg-amber-500",
+              item.status === "pending" && "bg-zinc-400",
+            )}
+          />
+          <span className="truncate">{item.title}</span>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+interface BriefBlockProps {
+  block: BriefBlock;
+}
+
+export function BriefBlockView({ block }: BriefBlockProps) {
+  return <div className="text-xs text-muted-foreground bg-muted/30 rounded-md px-2 py-1.5">{block.text}</div>;
+}
+
+interface ShellBlockProps {
+  block: ShellBlock;
+  maxHeight?: string;
+}
+
+export function ShellBlockView({ block, maxHeight = "max-h-40" }: ShellBlockProps) {
+  console.log("ShellBlockView render", { block });
+  const isDark = useIsDark();
+  const language = block.language || "bash";
+
+  return (
+    <div className="text-[11px] border border-border rounded-md overflow-hidden">
+      <div className="px-2 py-1 bg-muted/50 border-b border-border text-muted-foreground flex items-center gap-2">
+        <span className="font-mono">$</span>
+        <span>Shell Command</span>
+      </div>
+      <div className={cn("overflow-auto", maxHeight)}>
+        <SyntaxHighlighter
+          style={isDark ? oneDark : oneLight}
+          language={language}
+          PreTag="div"
+          customStyle={{ margin: 0, padding: "0.5rem", fontSize: "11px", background: "transparent" }}
+          codeTagProps={{ style: { backgroundColor: "transparent" } }}
+        >
+          {block.command}
+        </SyntaxHighlighter>
+      </div>
+    </div>
+  );
+}
+
+interface DisplayBlockViewProps {
+  block: DisplayBlock;
+  maxHeight?: string;
+}
+
+export function DisplayBlockView({ block, maxHeight }: DisplayBlockViewProps) {
+  switch (block.type) {
+    case "diff":
+      return <DiffBlockView block={block as DiffBlock} maxHeight={maxHeight} />;
+    case "todo":
+      return <TodoBlockView block={block as TodoBlock} />;
+    case "brief":
+      return <BriefBlockView block={block as BriefBlock} />;
+    default:
+      return null;
+  }
+}
+
+interface DisplayBlocksProps {
+  blocks: DisplayBlock[];
+  maxHeight?: string;
+  className?: string;
+}
+
+export function DisplayBlocks({ blocks, maxHeight, className }: DisplayBlocksProps) {
+  if (!blocks || blocks.length === 0) {
+    return null;
+  }
+
+  return (
+    <div className={cn("space-y-2", className)}>
+      {blocks.map((block, i) => (
+        <DisplayBlockView key={i} block={block} maxHeight={maxHeight} />
+      ))}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/FileChangesPanel.tsx b/apps/vscode/webview-ui/src/components/FileChangesPanel.tsx
new file mode 100644
index 000000000..ac6e6bddd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/FileChangesPanel.tsx
@@ -0,0 +1,185 @@
+import { useState } from "react";
+import { IconFilePlus, IconFileMinus, IconFileX, IconArrowBackUp, IconCheck, IconGitCompare } from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { useChatStore } from "@/stores";
+import { bridge } from "@/services";
+import { cn } from "@/lib/utils";
+import { FileChange } from "shared/types";
+import { toast } from "./ui/sonner";
+
+const STATUS_CONFIG = {
+  Added: { icon: IconFilePlus, color: "text-green-600 dark:text-green-400" },
+  Deleted: { icon: IconFileX, color: "text-red-600 dark:text-red-400" },
+  Modified: { icon: IconFileMinus, color: "text-yellow-600 dark:text-yellow-400" },
+} as const;
+
+function getTotalStats(changes: FileChange[]) {
+  return changes.reduce(
+    (a, c) => ({
+      additions: a.additions + c.additions,
+      deletions: a.deletions + c.deletions,
+    }),
+    { additions: 0, deletions: 0 },
+  );
+}
+
+interface FileItemProps {
+  file: FileChange;
+  onRevert: () => void;
+  onKeep: () => void;
+  onViewDiff: () => void;
+  disabled: boolean;
+  isStreaming?: boolean;
+}
+
+function FileItem({ file, onRevert, onKeep, onViewDiff, disabled, isStreaming }: FileItemProps) {
+  const { icon: Icon, color } = STATUS_CONFIG[file.status];
+  const name = file.path.split("/").pop() || file.path;
+  const dir = file.path.includes("/") ? file.path.slice(0, file.path.lastIndexOf("/")) : "";
+
+  return (
+    <div className="group flex items-center gap-1.5 px-2.5 py-1.5 hover:bg-accent/50 text-xs">
+      <Icon className={cn("size-3.5 shrink-0", color)} />
+      <div className="flex-1 min-w-0 text-left truncate hover:underline cursor-pointer" onClick={onViewDiff} title={file.path}>
+        <span className="font-medium">{name}</span>
+        {dir && <span className="ml-1 text-muted-foreground text-[10px]">{dir}</span>}
+      </div>
+      <div className="flex items-center gap-0.5 opacity-0 group-hover:opacity-100 transition-opacity">
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button variant="ghost" size="icon" className="size-5 border-0! cursor-pointer hover:bg-accent" onClick={onViewDiff}>
+              <IconGitCompare className="size-3" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>View Changes</TooltipContent>
+        </Tooltip>
+        {!isStreaming && (
+          <>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <Button variant="ghost" size="icon" className="size-5 border-0! cursor-pointer hover:bg-accent" onClick={onRevert} disabled={disabled}>
+                  <IconArrowBackUp className="size-3" />
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent>Undo Changes</TooltipContent>
+            </Tooltip>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <Button variant="ghost" size="icon" className="size-5 border-0! cursor-pointer hover:bg-accent" onClick={onKeep} disabled={disabled}>
+                  <IconCheck className="size-3" />
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent>Keep Changes</TooltipContent>
+            </Tooltip>
+          </>
+        )}
+      </div>
+      <div className="flex items-center gap-1 text-[10px] tabular-nums shrink-0">
+        <span className="text-green-600 dark:text-green-400">+{file.additions}</span>
+        <span className="text-red-600 dark:text-red-400">-{file.deletions}</span>
+      </div>
+    </div>
+  );
+}
+
+interface FileChangesPanelProps {
+  changes: FileChange[];
+}
+
+export function FileChangesPanel({ changes }: FileChangesPanelProps) {
+  const { isStreaming } = useChatStore();
+  const [loading, setLoading] = useState(false);
+
+  const handleRevert = async (filePath?: string) => {
+    setLoading(true);
+    try {
+      await bridge.revertFiles(filePath);
+    } catch (error) {
+      toast.error(`Unable to undo changes: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleKeep = async (filePath?: string) => {
+    setLoading(true);
+    try {
+      await bridge.keepChanges(filePath);
+    } catch (error) {
+      toast.error(`Unable to keep changes: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const stats = getTotalStats(changes);
+
+  if (!changes.length) {
+    return <div className="px-2.5 py-3 text-xs text-muted-foreground text-center">No file changes</div>;
+  }
+
+  return (
+    <div className="flex flex-col bg-card shrink">
+      {/* Header with actions */}
+      <div className="flex items-center justify-between px-2.5 py-1.5 text-xs bg-muted/30">
+        <div className="flex items-center gap-2">
+          <span className="text-muted-foreground">
+            {changes.length} file{changes.length !== 1 ? "s" : ""}
+          </span>
+          <div className="flex items-center gap-1 text-[10px] tabular-nums">
+            <span className="text-green-600 dark:text-green-400">+{stats.additions}</span>
+            <span className="text-red-600 dark:text-red-400">-{stats.deletions}</span>
+          </div>
+        </div>
+        {!isStreaming && (
+          <div className="flex gap-1">
+            <Button
+              variant="default"
+              size="sm"
+              className="h-5 px-2 text-[10px] cursor-pointer"
+              onClick={() => {
+                void handleKeep();
+              }}
+              disabled={loading}
+            >
+              Keep All
+            </Button>
+            <Button
+              variant="secondary"
+              size="sm"
+              className="h-5 px-2 text-[10px] cursor-pointer"
+              onClick={() => {
+                void handleRevert();
+              }}
+              disabled={loading}
+            >
+              Undo All
+            </Button>
+          </div>
+        )}
+      </div>
+
+      {/* File list */}
+      <div className="overflow-y-auto flex-1">
+        {changes.map((file) => (
+          <FileItem
+            key={file.path}
+            file={file}
+            onRevert={() => {
+              void handleRevert(file.path);
+            }}
+            onKeep={() => {
+              void handleKeep(file.path);
+            }}
+            onViewDiff={() => {
+              void bridge.openFileDiff(file.path);
+            }}
+            disabled={loading}
+            isStreaming={isStreaming}
+          />
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/FilePickerMenu.tsx b/apps/vscode/webview-ui/src/components/FilePickerMenu.tsx
new file mode 100644
index 000000000..7f6d8159f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/FilePickerMenu.tsx
@@ -0,0 +1,173 @@
+import { useEffect, useRef } from "react";
+import { IconFolder, IconFile, IconArrowLeft, IconFolderOpen, IconPhoto } from "@tabler/icons-react";
+import { cn } from "@/lib/utils";
+
+export type FilePickerMode = "search" | "folder";
+
+export interface FileItem {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  highlightedName?: React.ReactNode;
+}
+
+interface FilePickerMenuProps {
+  mode: FilePickerMode;
+  items: FileItem[];
+  currentPath: string;
+  selectedIndex: number;
+  isLoading?: boolean;
+  showMediaOption?: boolean;
+  onSelectMedia?: () => void;
+  onSwitchToFolder: () => void;
+  onSwitchToSearch: () => void;
+  onSelectItem: (item: FileItem) => void;
+  onNavigateUp: () => void;
+  onNavigateInto: (item: FileItem) => void;
+  onHover: (index: number) => void;
+}
+
+function truncateMiddle(str: string, maxLen: number): string {
+  if (str.length <= maxLen) return str;
+  const ellipsis = "...";
+  const charsToShow = maxLen - ellipsis.length;
+  const frontChars = Math.ceil(charsToShow / 2);
+  const backChars = Math.floor(charsToShow / 2);
+  return str.slice(0, frontChars) + ellipsis + str.slice(-backChars);
+}
+
+export function FilePickerMenu({
+  mode,
+  items,
+  currentPath,
+  selectedIndex,
+  isLoading,
+  showMediaOption = true,
+  onSelectMedia,
+  onSwitchToFolder,
+  onSwitchToSearch,
+  onSelectItem,
+  onNavigateUp,
+  onNavigateInto,
+  onHover,
+}: FilePickerMenuProps) {
+  const selectedRef = useRef<HTMLButtonElement>(null);
+
+  useEffect(() => {
+    selectedRef.current?.scrollIntoView({ block: "nearest" });
+  }, [selectedIndex]);
+
+  const preventFocus = (e: React.MouseEvent) => e.preventDefault();
+
+  // Calculate header count based on mode and options
+  const getHeaderCount = () => {
+    if (mode === "search") {
+      // Select media (if shown) + Browse folders
+      return showMediaOption ? 2 : 1;
+    } else {
+      // Back to search + optional parent nav
+      return currentPath ? 2 : 1;
+    }
+  };
+
+  const headerCount = getHeaderCount();
+
+  return (
+    <div className="rounded-md border bg-popover shadow-md overflow-hidden">
+      {mode === "search" ? (
+        <>
+          {showMediaOption && onSelectMedia && (
+            <button
+              ref={selectedIndex === 0 ? selectedRef : null}
+              onMouseDown={preventFocus}
+              onClick={onSelectMedia}
+              onMouseEnter={() => onHover(0)}
+              className={cn("w-full px-2 py-1.5 text-left flex items-center gap-2 border-b border-border", selectedIndex === 0 ? "bg-accent" : "hover:bg-accent/50")}
+            >
+              <IconPhoto className="size-3.5 text-muted-foreground" />
+              <span className="text-xs">Select images or videos...</span>
+            </button>
+          )}
+          <button
+            ref={selectedIndex === (showMediaOption ? 1 : 0) ? selectedRef : null}
+            onMouseDown={preventFocus}
+            onClick={onSwitchToFolder}
+            onMouseEnter={() => onHover(showMediaOption ? 1 : 0)}
+            className={cn(
+              "w-full px-2 py-1.5 text-left flex items-center gap-2 border-b border-border",
+              selectedIndex === (showMediaOption ? 1 : 0) ? "bg-accent" : "hover:bg-accent/50",
+            )}
+          >
+            <IconFolderOpen className="size-3.5 text-muted-foreground" />
+            <span className="text-xs">Browse folders...</span>
+          </button>
+        </>
+      ) : (
+        <>
+          <button
+            ref={selectedIndex === 0 ? selectedRef : null}
+            onMouseDown={preventFocus}
+            onClick={onSwitchToSearch}
+            onMouseEnter={() => onHover(0)}
+            className={cn("w-full px-2 py-1.5 text-left flex items-center gap-2 border-b border-border", selectedIndex === 0 ? "bg-accent" : "hover:bg-accent/50")}
+          >
+            <IconArrowLeft className="size-3.5 text-muted-foreground" />
+            <span className="text-xs">Back to search</span>
+          </button>
+          {currentPath && (
+            <button
+              ref={selectedIndex === 1 ? selectedRef : null}
+              onMouseDown={preventFocus}
+              onClick={onNavigateUp}
+              onMouseEnter={() => onHover(1)}
+              className={cn("w-full px-2 py-1.5 text-left flex items-center gap-2 border-b border-border/50", selectedIndex === 1 ? "bg-accent" : "hover:bg-accent/50")}
+            >
+              <IconFolder className="size-3.5 text-muted-foreground" />
+              <span className="text-xs font-medium">..</span>
+              <span className="text-[10px] text-muted-foreground truncate">({currentPath.split("/").pop()})</span>
+            </button>
+          )}
+        </>
+      )}
+      <div className="max-h-64 overflow-y-auto">
+        {isLoading ? (
+          <div className="px-2 py-4 text-center text-xs text-muted-foreground">Loading...</div>
+        ) : items.length === 0 ? (
+          <div className="px-2 py-4 text-center text-xs text-muted-foreground">{mode === "search" ? "No files found" : "Empty folder"}</div>
+        ) : (
+          items.map((item, idx) => {
+            const itemIndex = idx + headerCount;
+            return (
+              <button
+                key={item.path}
+                ref={itemIndex === selectedIndex ? selectedRef : null}
+                onMouseDown={preventFocus}
+                onClick={() => {
+                  if (item.isDirectory && mode === "search") {
+                    onNavigateInto(item);
+                  } else {
+                    onSelectItem(item);
+                  }
+                }}
+                onMouseEnter={() => onHover(itemIndex)}
+                className={cn("w-full px-2 py-1.5 text-left flex items-center justify-between gap-3", itemIndex === selectedIndex ? "bg-accent" : "hover:bg-accent/50")}
+              >
+                <span className="flex items-center gap-1.5 text-xs shrink-0">
+                  {item.isDirectory ? <IconFolder className="size-3 text-muted-foreground" /> : <IconFile className="size-3 text-muted-foreground" />}
+                  <span className={cn(item.isDirectory && "font-medium")}>
+                    {mode === "folder" ? item.name : item.highlightedName || item.name}
+                    {item.isDirectory && "/"}
+                  </span>
+                </span>
+                <span className="flex items-center gap-1.5">
+                  <span className="text-[10px] text-muted-foreground truncate max-w-32">{truncateMiddle(item.path, 25)}</span>
+                  {item.isDirectory && mode === "folder" && <span className="text-[10px] text-muted-foreground">→</span>}
+                </span>
+              </button>
+            );
+          })
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/Header.tsx b/apps/vscode/webview-ui/src/components/Header.tsx
new file mode 100644
index 000000000..0ffcfd492
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/Header.tsx
@@ -0,0 +1,107 @@
+import { useState } from "react";
+import { IconPlus, IconChevronDown, IconInfoCircle } from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { StreamingConfirmDialog } from "./StreamingConfirmDialog";
+import { KimiLogo } from "./KimiLogo";
+import { SessionList } from "./SessionList";
+import { useChatStore } from "@/stores";
+import { ChatStatus, TokenInfo } from "./ChatStatus";
+
+export function Header() {
+  const [showSessionList, setShowSessionList] = useState(false);
+  const [showSessionInfo, setShowSessionInfo] = useState(false);
+  const [showConfirmNew, setShowConfirmNew] = useState(false);
+  const { startNewConversation, sessionId, messages, isStreaming } = useChatStore();
+
+  const handleNewSession = async () => {
+    // If streaming, show confirmation dialog
+    if (isStreaming) {
+      setShowConfirmNew(true);
+      return;
+    }
+
+    await doStartNewSession();
+  };
+
+  const doStartNewSession = async () => {
+    await startNewConversation();
+    setShowSessionList(false);
+    setShowConfirmNew(false);
+  };
+
+  return (
+    <header className="flex items-center justify-between px-3 py-2 border-b border-border shrink-0 @container">
+      <div className="flex items-center gap-2 shrink-0">
+        <KimiLogo className="size-5 shrink-0" />
+        <span className="text-sm font-semibold whitespace-nowrap">Kimi Code</span>
+      </div>
+      <div className="flex items-center gap-1">
+        {sessionId && (
+          <Button
+            variant="ghost"
+            size="xs"
+            className="gap-1 h-6 border-0! pl-px! pr-1! text-muted-foreground hover:text-foreground @max-[320px]:hidden"
+            onClick={() => setShowSessionInfo(true)}
+          >
+            <span className="text-[11px] @max-[500px]:hidden">Session</span>
+            <IconInfoCircle className="size-3.5 hidden @max-[500px]:block" />
+          </Button>
+        )}
+        <ChatStatus />
+        <Popover open={showSessionList} onOpenChange={setShowSessionList}>
+          <PopoverTrigger asChild>
+            <Button variant="ghost" size="xs" className="gap-1 h-6">
+              <span className="text-xs @max-[280px]:hidden">History</span>
+              <IconChevronDown className="size-3.5" />
+            </Button>
+          </PopoverTrigger>
+          <PopoverContent align="end" className="w-[20rem] max-w-[calc(100vw-1rem)] p-0">
+            <SessionList onClose={() => setShowSessionList(false)} />
+          </PopoverContent>
+        </Popover>
+        <Button
+          variant="ghost"
+          size="icon-xs"
+          onClick={() => {
+            void handleNewSession();
+          }}
+        >
+          <IconPlus className="size-3.5" />
+        </Button>
+      </div>
+
+      <Dialog open={showSessionInfo} onOpenChange={setShowSessionInfo}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle className="text-sm">Session Details</DialogTitle>
+            <DialogDescription className="text-xs">Details for this conversation.</DialogDescription>
+          </DialogHeader>
+          <div className="space-y-3 py-2">
+            <div>
+              <div className="text-[10px] text-muted-foreground uppercase tracking-wider mb-1">Session ID</div>
+              <code className="text-xs font-mono text-foreground break-all select-all">{sessionId}</code>
+            </div>
+            <div>
+              <div className="text-[10px] text-muted-foreground uppercase tracking-wider mb-1">Messages</div>
+              <span className="text-xs text-foreground">{messages.length}</span>
+            </div>
+            <TokenInfo />
+          </div>
+        </DialogContent>
+      </Dialog>
+
+      <StreamingConfirmDialog
+        open={showConfirmNew}
+        onOpenChange={(open) => !open && setShowConfirmNew(false)}
+        title="Start New Conversation?"
+        description="The current conversation is still generating a response. Starting a new one will truncate the output. Are you sure you want to continue?"
+        confirmLabel="New Conversation"
+        onConfirm={() => {
+          void doStartNewSession();
+        }}
+      />
+    </header>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/InlineError.tsx b/apps/vscode/webview-ui/src/components/InlineError.tsx
new file mode 100644
index 000000000..7ccbe7502
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/InlineError.tsx
@@ -0,0 +1,36 @@
+import { IconAlertCircle, IconRefresh } from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import { useChatStore } from "@/stores";
+import { cn } from "@/lib/utils";
+import type { InlineError as InlineErrorType } from "../stores/chat.store";
+
+interface InlineErrorProps {
+  error: InlineErrorType;
+}
+
+export function InlineError({ error }: InlineErrorProps) {
+  const { retryLastMessage, isStreaming } = useChatStore();
+
+  // 如果 detail 和 message 不同，则显示详细错误信息
+  const showDetail = error.detail && error.detail !== error.message;
+
+  return (
+    <div className={cn("flex flex-col gap-1 px-3 py-2 mt-2 rounded-md", "bg-red-50 dark:bg-red-950/30", "border border-red-200 dark:border-red-900/50")}>
+      <div className="flex items-center gap-2">
+        <IconAlertCircle className="size-4 text-red-500 shrink-0" />
+        <span className="text-xs text-red-600 dark:text-red-400 flex-1">{error.message}</span>
+        <Button
+          variant="ghost"
+          size="sm"
+          className="h-6 px-2 text-xs text-red-600 dark:text-red-400 hover:bg-red-100 dark:hover:bg-red-900/30"
+          onClick={retryLastMessage}
+          disabled={isStreaming}
+        >
+          <IconRefresh className="size-3.5 mr-1" />
+          Retry
+        </Button>
+      </div>
+      {showDetail && <div className="text-[10px] text-red-500/70 dark:text-red-400/70 pl-6 font-mono break-all">{error.detail}</div>}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/KimiLogo.tsx b/apps/vscode/webview-ui/src/components/KimiLogo.tsx
new file mode 100644
index 000000000..d4a940a24
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/KimiLogo.tsx
@@ -0,0 +1,11 @@
+import { useExtensionImageUrl } from "./hooks/useExtensionImageUrl";
+
+export function KimiLogo({ className }: { className?: string }) {
+  const logoUrl = useExtensionImageUrl("kimi-logo.png");
+
+  if (!logoUrl) {
+    return null;
+  }
+
+  return <img src={logoUrl} alt="KIMI" className={className} aria-label="KIMI" />;
+}
diff --git a/apps/vscode/webview-ui/src/components/KimiMascot.tsx b/apps/vscode/webview-ui/src/components/KimiMascot.tsx
new file mode 100644
index 000000000..92a85a236
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/KimiMascot.tsx
@@ -0,0 +1,29 @@
+import { useState, useEffect } from "react";
+import { useExtensionImageUrl } from "./hooks/useExtensionImageUrl";
+
+export function KimiMascot({ className }: { className?: string }) {
+  const [isDark, setIsDark] = useState(() => document.documentElement.classList.contains("dark"));
+
+  useEffect(() => {
+    const checkTheme = () => {
+      setIsDark(document.documentElement.classList.contains("dark"));
+    };
+
+    const observer = new MutationObserver(checkTheme);
+    observer.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["class"],
+    });
+
+    return () => observer.disconnect();
+  }, []);
+
+  const imageName = isDark ? "kimi-banner-dark.svg" : "kimi-banner-light.svg";
+  const logoUrl = useExtensionImageUrl(imageName);
+
+  if (!logoUrl) {
+    return null;
+  }
+
+  return <img src={logoUrl} alt="KIMI" className={className} aria-label="KIMI" />;
+}
diff --git a/apps/vscode/webview-ui/src/components/LoginScreen.tsx b/apps/vscode/webview-ui/src/components/LoginScreen.tsx
new file mode 100644
index 000000000..f572abc7e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/LoginScreen.tsx
@@ -0,0 +1,181 @@
+import { useState, useEffect } from "react";
+import { IconLoader2, IconCopy, IconCheck, IconExternalLink, IconArrowRight } from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import { KimiMascot } from "./KimiMascot";
+import { bridge, Events } from "@/services";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+
+interface LoginScreenProps {
+  onLoginSuccess: () => void;
+  onSkip: () => void;
+}
+
+type LoginState = "idle" | "pending" | "error";
+
+function isPaymentRequiredError(error: string | null): boolean {
+  if (!error) return false;
+  return error.includes("402") || error.toLowerCase().includes("payment required");
+}
+
+export function LoginScreen({ onLoginSuccess, onSkip }: LoginScreenProps) {
+  const [state, setState] = useState<LoginState>("idle");
+  const [url, setUrl] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [copied, setCopied] = useState(false);
+  const [showSubscribeDialog, setShowSubscribeDialog] = useState(false);
+
+  useEffect(() => {
+    return bridge.on<{ url: string }>(Events.LoginUrl, ({ url }) => {
+      setUrl(url);
+    });
+  }, []);
+
+  const handleLogin = async () => {
+    setState("pending");
+    setUrl(null);
+    setError(null);
+    try {
+      const result = await bridge.login();
+      if (result.success) {
+        onLoginSuccess();
+      } else {
+        const errorMessage = result.error || "Login failed";
+        if (isPaymentRequiredError(errorMessage)) {
+          setShowSubscribeDialog(true);
+          setState("idle");
+        } else {
+          setState("error");
+          setError(errorMessage);
+        }
+      }
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      if (isPaymentRequiredError(errorMessage)) {
+        setShowSubscribeDialog(true);
+        setState("idle");
+      } else {
+        setState("error");
+        setError(errorMessage);
+      }
+    }
+  };
+
+  const handleSubscribe = () => {
+    window.open("https://www.kimi.com/code", "_blank");
+    setShowSubscribeDialog(false);
+  };
+
+  const handleCopyUrl = async () => {
+    if (!url) return;
+    await navigator.clipboard.writeText(url);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2000);
+  };
+
+  if (state === "pending") {
+    return (
+      <div className="h-full flex items-center justify-center p-6">
+        <div className="max-w-sm w-full text-center space-y-6">
+          <KimiMascot className="h-12 mx-auto" />
+          <div className="space-y-2">
+            <div className="inline-flex items-center gap-2 text-blue-500">
+              <IconLoader2 className="size-5 animate-spin" />
+              <span className="text-sm font-medium">Waiting for authorization...</span>
+            </div>
+            <p className="text-xs leading-5 text-muted-foreground text-left">A browser window should open automatically. Complete the sign-in process there.</p>
+          </div>
+          {url && (
+            <div className="bg-muted/50 rounded-lg p-2 text-left space-y-3">
+              <p className="text-xs text-muted-foreground">If the browser didn&apos;t open, visit this URL:</p>
+              <div className="flex items-center gap-2">
+                <code className="flex-1 text-xs bg-background rounded px-2 py-1.5 font-mono break-all select-all">{url}</code>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="shrink-0 size-8"
+                  onClick={() => {
+                    void handleCopyUrl();
+                  }}
+                >
+                  {copied ? <IconCheck className="size-4 text-emerald-500" /> : <IconCopy className="size-4" />}
+                </Button>
+              </div>
+              <a href={url} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1.5 text-xs text-blue-500 hover:underline">
+                <IconExternalLink className="size-3.5" />
+                Open in browser
+              </a>
+            </div>
+          )}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <>
+      <div className="h-full flex items-center justify-center p-6">
+        <div className="max-w-sm w-full text-center space-y-6">
+          <KimiMascot className="h-12 mx-auto" />
+          <div className="space-y-2">
+            <h1 className="text-lg font-semibold">Welcome to Kimi Code</h1>
+            <div className="text-left space-y-2">
+              <p className="text-xs leading-5">Use Kimi Code with your Kimi account subscription or your existing API setup.</p>
+            </div>
+          </div>
+
+          {error && (
+            <div className="bg-red-50 dark:bg-red-950/30 border border-red-200 dark:border-red-900/50 rounded-lg px-3 py-2 text-left">
+              <p className="text-xs text-red-600 dark:text-red-400">{error}</p>
+            </div>
+          )}
+
+          <div className="space-y-5">
+            <div className="text-left space-y-1">
+              <Button
+                onClick={() => {
+                  void handleLogin();
+                }}
+                className="w-full justify-center gap-2"
+              >
+                Sign in with Kimi Account
+              </Button>
+              <p className="text-[11px] text-muted-foreground leading-4">Use your Kimi account and Kimi Code subscription.</p>
+            </div>
+
+            <div className="text-left space-y-1">
+              <Button type="button" variant="outline" onClick={onSkip} className="w-full relative justify-center font-normal">
+                <span>Skip</span>
+                <IconArrowRight className="size-4 text-muted-foreground absolute right-3" />
+              </Button>
+              <p className="text-[11px] text-muted-foreground leading-4">Use your existing API key configuration.</p>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <AlertDialog open={showSubscribeDialog} onOpenChange={setShowSubscribeDialog}>
+        <AlertDialogContent size="sm">
+          <AlertDialogHeader>
+            <AlertDialogTitle>Subscription Required</AlertDialogTitle>
+            <AlertDialogDescription>
+              Your account does not have an active Kimi Code subscription. Please subscribe to continue using Kimi Code with your account.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel onClick={() => setShowSubscribeDialog(false)}>Skip</AlertDialogCancel>
+            <AlertDialogAction onClick={handleSubscribe}>Subscribe</AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/MCPServersModal.tsx b/apps/vscode/webview-ui/src/components/MCPServersModal.tsx
new file mode 100644
index 000000000..326534f61
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/MCPServersModal.tsx
@@ -0,0 +1,580 @@
+import { useState, useEffect, useMemo } from "react";
+import {
+  IconX,
+  IconPlus,
+  IconTrash,
+  IconServer,
+  IconKey,
+  IconRefresh,
+  IconPlugConnected,
+  IconLoader2,
+  IconWorld,
+  IconTerminal2,
+  IconBrandGithub,
+  IconChevronDown,
+} from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { useSettingsStore } from "@/stores";
+import { bridge } from "@/services";
+import { RECOMMENDED_MCP_SERVERS, recommendedToConfig, type RecommendedMCPServer } from "@/services/recommended-mcp";
+import { cn } from "@/lib/utils";
+import { MCP_SECRET_MASK, type MCPServerConfig } from "shared/legacy-sdk";
+
+type TransportType = "stdio" | "http";
+
+interface KeyValueField {
+  key: string;
+  value: string;
+}
+
+interface FormData {
+  name: string;
+  transport: TransportType;
+  url: string;
+  command: string;
+  args: string[];
+  envVars: KeyValueField[];
+  headerVars: KeyValueField[];
+  bearerTokenEnvVar: string;
+  requiresAuth: boolean;
+}
+
+function emptyForm(): FormData {
+  return {
+    name: "",
+    transport: "stdio",
+    url: "",
+    command: "",
+    args: [""],
+    envVars: [],
+    headerVars: [],
+    bearerTokenEnvVar: "",
+    requiresAuth: false,
+  };
+}
+
+function serverToForm(s?: MCPServerConfig): FormData {
+  if (!s) return emptyForm();
+  const isHttp = s.transport === "http";
+  return {
+    name: s.name,
+    transport: isHttp ? "http" : "stdio",
+    url: s.url ?? "",
+    command: s.command ?? "",
+    args: s.args ? [...s.args] : [],
+    envVars: s.env ? Object.entries(s.env).map(([key, value]) => ({ key, value })) : [],
+    headerVars: s.headers ? Object.entries(s.headers).map(([key, value]) => ({ key, value })) : [],
+    bearerTokenEnvVar: s.bearerTokenEnvVar ?? "",
+    requiresAuth: s.auth === "oauth",
+  };
+}
+
+function formToConfig(f: FormData): MCPServerConfig {
+  const env = f.envVars.reduce((acc, { key, value }) => (key.trim() ? { ...acc, [key.trim()]: value } : acc), {} as Record<string, string>);
+  const headers = f.headerVars.reduce((acc, { key, value }) => (key.trim() ? { ...acc, [key.trim()]: value } : acc), {} as Record<string, string>);
+  if (f.transport === "http") {
+    const bearerTokenEnvVar = f.bearerTokenEnvVar.trim();
+    return {
+      name: f.name.trim(),
+      transport: "http",
+      url: f.url.trim(),
+      headers: Object.keys(headers).length > 0 ? headers : undefined,
+      bearerTokenEnvVar: bearerTokenEnvVar || undefined,
+      auth: f.requiresAuth ? "oauth" : undefined,
+    };
+  }
+  const args = f.args.filter((arg) => arg.length > 0);
+  return {
+    name: f.name.trim(),
+    transport: "stdio",
+    command: f.command.trim(),
+    args: args.length > 0 ? args : undefined,
+    env: Object.keys(env).length > 0 ? env : undefined,
+  };
+}
+
+function validateForm(f: FormData): string | null {
+  if (!f.name.trim()) return "Name required";
+  if (f.transport === "http" && !f.url.trim()) return "URL required";
+  if (f.transport === "stdio" && !f.command.trim()) return "Command required";
+  return null;
+}
+
+function KeyValueFields({
+  label,
+  fields,
+  onChange,
+}: {
+  label: string;
+  fields: KeyValueField[];
+  onChange: (fields: KeyValueField[]) => void;
+}) {
+  return (
+    <div>
+      <div className="flex items-center justify-between">
+        <Label className="text-[10px] text-muted-foreground">{label}</Label>
+        <button
+          onClick={() => onChange([...fields, { key: "", value: "" }])}
+          className="text-xs text-muted-foreground hover:text-foreground"
+        >
+          + Add
+        </button>
+      </div>
+      {fields.map((field, index) => (
+        <div key={index} className="flex items-center gap-1 mt-1">
+          <Input
+            value={field.key}
+            onChange={(event) => onChange(fields.map((item, itemIndex) => (
+              itemIndex === index ? { ...item, key: event.target.value } : item
+            )))}
+            placeholder="KEY"
+            className="h-6 text-xs font-mono flex-1"
+          />
+          <span className="text-muted-foreground text-xs">=</span>
+          <Input
+            type={field.value === MCP_SECRET_MASK ? "password" : "text"}
+            value={field.value}
+            onChange={(event) => onChange(fields.map((item, itemIndex) => (
+              itemIndex === index ? { ...item, value: event.target.value } : item
+            )))}
+            placeholder="value"
+            className="h-6 text-xs font-mono flex-1"
+          />
+          <button
+            onClick={() => onChange(fields.filter((_, itemIndex) => itemIndex !== index))}
+            className="text-muted-foreground hover:text-destructive p-1"
+          >
+            <IconX className="size-3" />
+          </button>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function ServerForm({
+  data,
+  onChange,
+  onSubmit,
+  onCancel,
+  submitLabel,
+}: {
+  data: FormData;
+  onChange: (d: FormData) => void;
+  onSubmit: () => void;
+  onCancel: () => void;
+  submitLabel: string;
+}) {
+  const [error, setError] = useState<string | null>(null);
+  const set = <K extends keyof FormData>(k: K, v: FormData[K]) => {
+    onChange({ ...data, [k]: v });
+    setError(null);
+  };
+  const handleSubmit = () => {
+    const err = validateForm(data);
+    if (err) {
+      setError(err);
+      return;
+    }
+    onSubmit();
+  };
+
+  return (
+    <div className="space-y-3 pt-2 border-t border-border/50">
+      <div className="grid grid-cols-2 gap-2">
+        <div>
+          <Label className="text-[10px] text-muted-foreground">Name</Label>
+          <Input value={data.name} onChange={(e) => set("name", e.target.value)} className="h-7 text-xs" />
+        </div>
+        <div>
+          <Label className="text-[10px] text-muted-foreground">Transport</Label>
+          <div className="flex gap-1">
+            {(["stdio", "http"] as const).map((t) => (
+              <button
+                key={t}
+                onClick={() => set("transport", t)}
+                className={cn(
+                  "flex-1 h-7 text-xs rounded border flex items-center justify-center gap-1",
+                  data.transport === t ? "border-blue-500 bg-blue-500/10 text-blue-500" : "border-border",
+                )}
+              >
+                {t === "stdio" ? <IconTerminal2 className="size-3" /> : <IconWorld className="size-3" />}
+                {t}
+              </button>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {data.transport === "http" ? (
+        <>
+          <div>
+            <Label className="text-[10px] text-muted-foreground">URL</Label>
+            <Input value={data.url} onChange={(e) => set("url", e.target.value)} placeholder="https://..." className="h-7 text-xs font-mono" />
+            <label className="flex items-center gap-1.5 mt-1.5 cursor-pointer">
+              <input type="checkbox" checked={data.requiresAuth} onChange={(e) => set("requiresAuth", e.target.checked)} className="rounded size-3" />
+              <span className="text-xs text-muted-foreground">Requires OAuth</span>
+            </label>
+          </div>
+          <KeyValueFields
+            label="Headers"
+            fields={data.headerVars}
+            onChange={(headerVars) => set("headerVars", headerVars)}
+          />
+          <div>
+            <Label className="text-[10px] text-muted-foreground">Bearer Token Environment Variable</Label>
+            <Input
+              value={data.bearerTokenEnvVar}
+              onChange={(e) => set("bearerTokenEnvVar", e.target.value)}
+              placeholder="MCP_TOKEN"
+              className="h-7 text-xs font-mono"
+            />
+          </div>
+        </>
+      ) : (
+        <div className="space-y-2">
+          <div>
+            <Label className="text-[10px] text-muted-foreground">Command</Label>
+            <Input value={data.command} onChange={(e) => set("command", e.target.value)} placeholder="npx" className="h-7 text-xs font-mono" />
+          </div>
+          <div>
+            <div className="flex items-center justify-between">
+              <Label className="text-[10px] text-muted-foreground">Arguments</Label>
+              <button
+                onClick={() => set("args", [...data.args, ""])}
+                className="text-xs text-muted-foreground hover:text-foreground"
+              >
+                + Add
+              </button>
+            </div>
+            {data.args.map((arg, index) => (
+              <div key={index} className="flex items-center gap-1 mt-1">
+                <Input
+                  value={arg}
+                  onChange={(event) => set("args", data.args.map((item, itemIndex) => (
+                    itemIndex === index ? event.target.value : item
+                  )))}
+                  placeholder={index === 0 ? "-y" : "@pkg/name"}
+                  className="h-7 text-xs font-mono flex-1"
+                />
+                <button
+                  onClick={() => set("args", data.args.filter((_, itemIndex) => itemIndex !== index))}
+                  className="text-muted-foreground hover:text-destructive p-1"
+                >
+                  <IconX className="size-3" />
+                </button>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+
+      {data.transport === "stdio" && (
+        <KeyValueFields
+          label="Environment Variables"
+          fields={data.envVars}
+          onChange={(envVars) => set("envVars", envVars)}
+        />
+      )}
+
+      {error && <p className="text-[10px] text-destructive">{error}</p>}
+
+      <div className="flex justify-end gap-2">
+        <Button variant="ghost" size="sm" className="h-6 text-xs" onClick={onCancel}>
+          Cancel
+        </Button>
+        <Button size="sm" className="h-6 text-xs" onClick={handleSubmit}>
+          {submitLabel}
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+function ServerItem({ server, onDelete }: { server: MCPServerConfig; onDelete: () => void }) {
+  const [expanded, setExpanded] = useState(false);
+  const [form, setForm] = useState(() => serverToForm(server));
+  const [testOutput, setTestOutput] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const { setMCPServers } = useSettingsStore();
+
+  const isHttp = server.transport === "http";
+
+  const handleUpdate = async () => {
+    try {
+      const servers = await bridge.updateMCPServer(server.name, formToConfig(form));
+      setMCPServers(servers);
+      setExpanded(false);
+    } catch (error) {
+      setTestOutput(`Update failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+
+  const handleAction = async (action: () => Promise<any>) => {
+    setIsLoading(true);
+    setTestOutput(null);
+    try {
+      await action();
+    } catch (error) {
+      setExpanded(true);
+      setTestOutput(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleTest = () =>
+    handleAction(async () => {
+      setExpanded(true);
+      const result = await bridge.testMCP(server.name);
+      setTestOutput(result.output);
+    });
+
+  const handleAuth = () => handleAction(() => bridge.authMCP(server.name));
+  const handleResetAuth = () => handleAction(() => bridge.resetAuthMCP(server.name));
+
+  return (
+    <div className="rounded-md border border-border/60 bg-card/30">
+      <div className="flex items-center gap-2 px-2.5 py-1.5 cursor-pointer hover:bg-muted/30" onClick={() => setExpanded(!expanded)}>
+        <div className={cn("size-6 rounded flex items-center justify-center text-xs", isHttp ? "bg-blue-500/10 text-blue-500" : "bg-emerald-500/10 text-emerald-500")}>
+          {isHttp ? <IconWorld className="size-3.5" /> : <IconTerminal2 className="size-3.5" />}
+        </div>
+        <div className="flex-1 min-w-0">
+          <div className="flex items-center gap-1.5">
+            <span className="text-xs font-medium">{server.name}</span>
+            {server.auth === "oauth" && <span className="text-[9px] px-1 py-0.5 rounded bg-amber-500/10 text-amber-600 dark:text-amber-400">OAuth</span>}
+          </div>
+          <p className="text-[10px] text-muted-foreground truncate font-mono">
+            {isHttp ? server.url : (
+              <>
+                <span>{server.command}</span>
+                {(server.args ?? []).map((arg, index) => <span key={index}> {arg}</span>)}
+              </>
+            )}
+          </p>
+        </div>
+        <div className="flex items-center gap-0.5" onClick={(e) => e.stopPropagation()}>
+          {server.auth === "oauth" && (
+            <>
+              <Button variant="ghost" size="icon" className="size-6" onClick={() => { void handleAuth(); }} disabled={isLoading}>
+                <IconKey className="size-3" />
+              </Button>
+              <Button variant="ghost" size="icon" className="size-6" onClick={() => { void handleResetAuth(); }} disabled={isLoading}>
+                <IconRefresh className="size-3" />
+              </Button>
+            </>
+          )}
+          <Button variant="ghost" size="icon" className="size-6" onClick={() => { void handleTest(); }} disabled={isLoading}>
+            {isLoading ? <IconLoader2 className="size-3 animate-spin" /> : <IconPlugConnected className="size-3" />}
+          </Button>
+          <Button variant="ghost" size="icon" className="size-6 text-muted-foreground hover:text-destructive" onClick={onDelete} disabled={isLoading}>
+            <IconTrash className="size-3" />
+          </Button>
+        </div>
+        <IconChevronDown className={cn("size-3.5 text-muted-foreground transition-transform", expanded && "rotate-180")} />
+      </div>
+
+      {expanded && (
+        <div className="px-2.5 pb-2.5">
+          {testOutput && (
+            <div className="text-[10px] font-mono bg-muted/50 rounded p-2 mb-2 max-h-48 overflow-auto border border-border/50">
+              {testOutput.split("\n").map((line, i) => (
+                <div key={i} className="whitespace-pre-wrap break-all min-h-[1.2em]">
+                  {line}
+                </div>
+              ))}
+            </div>
+          )}
+          <ServerForm data={form} onChange={setForm} onSubmit={() => { void handleUpdate(); }} onCancel={() => setExpanded(false)} submitLabel="Update" />
+        </div>
+      )}
+    </div>
+  );
+}
+
+function RecommendedItem({ server, onInstall, isInstalling }: { server: RecommendedMCPServer; onInstall: () => void; isInstalling: boolean }) {
+  return (
+    <div className="flex items-center gap-2 px-2.5 py-1.5 rounded-md border border-dashed border-border/50">
+      <div className="size-6 rounded flex items-center justify-center bg-violet-500/10 text-violet-500">
+        <IconTerminal2 className="size-3.5" />
+      </div>
+      <div className="flex-1 min-w-0">
+        <div className="flex items-center gap-1.5">
+          <span className="text-xs font-medium">{server.name}</span>
+          {server.github && (
+            <a href={server.github} target="_blank" rel="noopener noreferrer" className="text-muted-foreground hover:text-foreground">
+              <IconBrandGithub className="size-3" />
+            </a>
+          )}
+        </div>
+        <p className="text-[10px] text-muted-foreground truncate">{server.description}</p>
+      </div>
+      <Button variant="outline" size="sm" className="h-6 text-xs" onClick={onInstall} disabled={isInstalling}>
+        {isInstalling ? (
+          <>
+            <IconLoader2 className="size-3 mr-1 animate-spin" />
+            Adding
+          </>
+        ) : (
+          "Add"
+        )}
+      </Button>
+    </div>
+  );
+}
+
+export function MCPServersModal() {
+  const { mcpServers, mcpModalOpen, setMCPServers, setMCPModalOpen } = useSettingsStore();
+  const [showAdd, setShowAdd] = useState(false);
+  const [addForm, setAddForm] = useState<FormData>(() => emptyForm());
+  const [installingRecommended, setInstallingRecommended] = useState<string | null>(null);
+  const [deleteTarget, setDeleteTarget] = useState<string | null>(null);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [actionError, setActionError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (mcpModalOpen) {
+      void bridge.getMCPServers().then(setMCPServers).catch((error: unknown) => {
+        setActionError(error instanceof Error ? error.message : String(error));
+      });
+    }
+  }, [mcpModalOpen, setMCPServers]);
+
+  useEffect(() => {
+    if (!showAdd) setAddForm(emptyForm());
+  }, [showAdd]);
+
+  const installedNames = useMemo(() => new Set(mcpServers.map((s) => s.name)), [mcpServers]);
+
+  const handleAdd = async () => {
+    setActionError(null);
+    try {
+      const servers = await bridge.addMCPServer(formToConfig(addForm));
+      setMCPServers(servers);
+      setShowAdd(false);
+    } catch (error) {
+      setActionError(error instanceof Error ? error.message : String(error));
+    }
+  };
+
+  const handleDelete = async () => {
+    if (!deleteTarget) return;
+    setIsDeleting(true);
+    setActionError(null);
+    try {
+      const servers = await bridge.removeMCPServer(deleteTarget);
+      setMCPServers(servers);
+    } catch (error) {
+      setActionError(error instanceof Error ? error.message : String(error));
+    }
+    setIsDeleting(false);
+    setDeleteTarget(null);
+  };
+
+  const handleInstallRecommended = async (server: RecommendedMCPServer) => {
+    setInstallingRecommended(server.id);
+    setActionError(null);
+    try {
+      const config = recommendedToConfig(server);
+      const servers = await bridge.addMCPServer(config);
+      setMCPServers(servers);
+    } catch (error) {
+      setActionError(error instanceof Error ? error.message : String(error));
+    }
+    setInstallingRecommended(null);
+  };
+
+  if (!mcpModalOpen) return null;
+
+  return (
+    <>
+      <div className="fixed inset-0 z-40 flex flex-col bg-background">
+        <div className="flex items-center justify-between px-3 py-2 border-b">
+          <div className="flex items-center gap-2">
+            <IconServer className="size-4 text-blue-500" />
+            <h2 className="text-xs font-medium">MCP Servers</h2>
+          </div>
+          <div className="flex items-center gap-1">
+            <Button variant="outline" size="sm" className="h-6 text-xs" onClick={() => setShowAdd(true)}>
+              <IconPlus className="size-3 mr-1" />
+              Add
+            </Button>
+            <Button variant="ghost" size="icon" className="size-6" onClick={() => setMCPModalOpen(false)}>
+              <IconX className="size-3.5" />
+            </Button>
+          </div>
+        </div>
+        <div className="flex-1 overflow-y-auto">
+          <div className="max-w-2xl mx-auto px-3 py-3 space-y-4">
+            {actionError && (
+              <div className="rounded border border-destructive/30 bg-destructive/5 px-2.5 py-2 text-xs text-destructive">
+                {actionError}
+              </div>
+            )}
+            {showAdd && (
+              <div className="rounded-md border border-blue-500/5 p-2.5">
+                <div className="flex items-center gap-2 mb-2">
+                  <IconPlus className="size-3.5 text-blue-500" />
+                  <span className="text-xs font-medium">Add MCP Server</span>
+                </div>
+                <ServerForm data={addForm} onChange={setAddForm} onSubmit={() => { void handleAdd(); }} onCancel={() => setShowAdd(false)} submitLabel="Add Server" />
+              </div>
+            )}
+
+            {mcpServers.length > 0 && (
+              <div className="space-y-1.5">
+                {mcpServers.map((server) => (
+                  <ServerItem key={server.name} server={server} onDelete={() => setDeleteTarget(server.name)} />
+                ))}
+              </div>
+            )}
+
+            {mcpServers.length === 0 && !showAdd && (
+              <div className="py-6 text-center">
+                <IconServer className="size-6 mx-auto text-muted-foreground/30 mb-1" />
+                <p className="text-xs text-muted-foreground">No MCP servers configured</p>
+              </div>
+            )}
+
+            <div className="space-y-1.5">
+              <h3 className="text-[10px] font-medium text-muted-foreground uppercase tracking-wider">Recommended</h3>
+              {RECOMMENDED_MCP_SERVERS.filter((s) => !installedNames.has(s.id)).map((server) => (
+                <RecommendedItem key={server.id} server={server} onInstall={() => { void handleInstallRecommended(server); }} isInstalling={installingRecommended === server.id} />
+              ))}
+              {RECOMMENDED_MCP_SERVERS.every((s) => installedNames.has(s.id)) && (
+                <p className="text-[10px] text-muted-foreground text-center py-2">All recommended servers installed</p>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <AlertDialog open={deleteTarget !== null} onOpenChange={(open) => !open && setDeleteTarget(null)}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Delete MCP Server?</AlertDialogTitle>
+            <AlertDialogDescription>This will remove "{deleteTarget}" from your configuration. This action cannot be undone.</AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel disabled={isDeleting}>Cancel</AlertDialogCancel>
+            <AlertDialogAction onClick={() => { void handleDelete(); }} disabled={isDeleting} className="bg-destructive text-destructive-foreground hover:bg-destructive/90">
+              {isDeleting ? "Deleting..." : "Delete"}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/Markdown.tsx b/apps/vscode/webview-ui/src/components/Markdown.tsx
new file mode 100644
index 000000000..f9d04a5a4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/Markdown.tsx
@@ -0,0 +1,276 @@
+import React, { memo, useMemo, useState, useEffect, useCallback } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import rehypeKatex from "rehype-katex";
+import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
+import { oneDark, oneLight } from "react-syntax-highlighter/dist/esm/styles/prism";
+import { useRequest } from "ahooks";
+import { IconVideo } from "@tabler/icons-react";
+import type { Components } from "react-markdown";
+import { parseSegments, parseColorSegments, extractPaths, checkFilesExist, hasColors, isLocalPath } from "@/lib/text-enrichment";
+import { CopyButton } from "@/components/CopyButton";
+import { MediaPreviewModal, StreamImagePreview, ImageLoadFail } from "@/components/MediaPreviewModal";
+import { getMediaTypeFromSrc } from "@/lib/media-utils";
+import { bridge } from "@/services";
+
+interface MarkdownProps {
+  content: string;
+  className?: string;
+  enableEnrichment?: boolean;
+  enableLocalImageRender?: boolean;
+}
+
+function useIsDark(): boolean {
+  const [isDark, setIsDark] = useState(() => typeof document !== "undefined" && document.documentElement.classList.contains("dark"));
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    const el = document.documentElement;
+    const obs = new MutationObserver(() => setIsDark(el.classList.contains("dark")));
+    obs.observe(el, { attributes: true, attributeFilter: ["class"] });
+    return () => obs.disconnect();
+  }, []);
+  return isDark;
+}
+
+function ColorSwatch({ color }: { color: string }) {
+  return <span className="inline-block size-2.75 rounded-sm align-middle mr-0.5 mb-0.5" style={{ backgroundColor: color }} />;
+}
+
+export function FileLink({ path, display }: { path: string; display: string }) {
+  const onClick = useCallback(
+    (e: React.MouseEvent) => {
+      e.preventDefault();
+      void bridge.openFile(path);
+    },
+    [path],
+  );
+  return (
+    <button type="button" className="hover:text-zinc-900 dark:hover:text-white hover:underline cursor-pointer break-all text-left" onClick={onClick}>
+      {display}
+    </button>
+  );
+}
+
+function VideoLink({ src }: { src: string }) {
+  const filename = src.split("/").pop() || src;
+  return (
+    <button
+      type="button"
+      onClick={() => {
+        void bridge.openFile(src);
+      }}
+      className="inline-flex items-center gap-1.5 px-2 py-1 my-1 rounded bg-muted hover:bg-muted/80 text-xs cursor-pointer"
+    >
+      <IconVideo className="size-4 text-muted-foreground" />
+      <span>{filename}</span>
+    </button>
+  );
+}
+
+function EnrichedText({ text, fileMap }: { text: string; fileMap: Record<string, boolean> }) {
+  const segments = useMemo(() => parseSegments(text, fileMap), [text, fileMap]);
+  return (
+    <>
+      {segments.map((seg, i) => {
+        if (seg.type === "color") {
+          return (
+            <span key={i}>
+              <ColorSwatch color={seg.value} />
+              {seg.value}
+            </span>
+          );
+        }
+        if (seg.type === "file") {
+          return <FileLink key={i} path={seg.path} display={seg.value} />;
+        }
+        return <span key={i}>{seg.value}</span>;
+      })}
+    </>
+  );
+}
+
+function enrichChildren(children: React.ReactNode, fileMap: Record<string, boolean>): React.ReactNode {
+  return React.Children.map(children, (child) => {
+    if (typeof child === "string") {
+      return <EnrichedText text={child} fileMap={fileMap} />;
+    }
+    if (!React.isValidElement(child)) {
+      return child;
+    }
+
+    // 跳过链接和代码块（但不跳过行内 code，因为会在 code 组件中单独处理）
+    if (typeof child.type === "string" && ["a", "pre"].includes(child.type)) {
+      return child;
+    }
+    const props = child.props as { children?: React.ReactNode };
+    if (props.children === undefined) {
+      return child;
+    }
+    return React.cloneElement(child, undefined, enrichChildren(props.children, fileMap));
+  });
+}
+
+function LocalImage({ src, alt, onPreview }: { src: string; alt?: string; onPreview: (uri: string) => void }) {
+  const { data } = useRequest(() => bridge.getImageDataUri(src), {
+    cacheKey: `local-image:${src}`,
+    staleTime: 10000,
+  });
+
+  if (!data) return <ImageLoadFail path={src} />;
+  return <StreamImagePreview src={data} alt={alt || src} onPreview={onPreview} />;
+}
+
+function ColorEnrichedText({ text }: { text: string }) {
+  const segments = useMemo(() => parseColorSegments(text), [text]);
+  return (
+    <>
+      {segments.map((seg, i) =>
+        seg.type === "color" ? (
+          <span key={i}>
+            <ColorSwatch color={seg.value} />
+            {seg.value}
+          </span>
+        ) : (
+          <span key={i}>{seg.value}</span>
+        ),
+      )}
+    </>
+  );
+}
+
+const CodeBlock = memo(function CodeBlock({ code, language, enableHighlight, style }: { code: string; language?: string; enableHighlight: boolean; style?: any }) {
+  return (
+    <div className="relative group/code">
+      <CopyButton content={code} className="absolute right-1 top-1 opacity-0 group-hover/code:opacity-100" />
+      {enableHighlight && language ? (
+        <SyntaxHighlighter
+          style={style}
+          language={language}
+          PreTag="div"
+          customStyle={{ padding: "0.5rem", borderRadius: "0.375rem", fontSize: "11px", margin: 0 }}
+          codeTagProps={{ style: { backgroundColor: "transparent", fontFamily: "inherit", padding: 0, color: "inherit", borderRadius: 0 } }}
+        >
+          {code}
+        </SyntaxHighlighter>
+      ) : (
+        <pre className="bg-muted rounded px-2 py-1 overflow-x-auto text-[11px]">
+          <code className="bg-transparent!">{code}</code>
+        </pre>
+      )}
+    </div>
+  );
+});
+
+// FIX: Replaced unwrapSingleParagraph with unwrapParagraphs.
+// The old version only stripped <p> when it was the sole child of <li>.
+// In "loose lists" (items separated by blank lines) with nested sub-lists,
+// ReactMarkdown produces [<p>, <ul>] as children — two elements — so the
+// old single-child check failed and the inner <p mb-2> was kept, adding
+// unwanted vertical spacing inside list items.
+// This version strips <p> wrappers from ALL children, regardless of count.
+function unwrapParagraphs(children: React.ReactNode): React.ReactNode {
+  return React.Children.map(children, (child) => {
+    if (React.isValidElement(child) && child.type === "p") {
+      return (child.props as { children?: React.ReactNode }).children;
+    }
+    return child;
+  });
+}
+
+export const Markdown = memo(function Markdown({ content, className, enableEnrichment = true, enableLocalImageRender = true }: MarkdownProps) {
+  const isDark = useIsDark();
+  const [fileMap, setFileMap] = useState<Record<string, boolean>>({});
+  const [previewSrc, setPreviewSrc] = useState<string | null>(null);
+
+  useEffect(() => {
+    // When enableEnrichment is false, skip enrichment process
+    if (!enableEnrichment || !content) {
+      setFileMap({});
+      return;
+    }
+    const paths = extractPaths(content);
+    if (!paths.length) {
+      setFileMap({});
+      return;
+    }
+    let cancelled = false;
+    void checkFilesExist(paths).then((map) => {
+      if (!cancelled) {
+        setFileMap(map);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [content, enableEnrichment]);
+
+  const codeStyle = isDark ? (oneDark as any) : (oneLight as any);
+
+  const components: Components = useMemo(() => {
+    const enrich = (children: React.ReactNode) => (enableEnrichment ? enrichChildren(children, fileMap) : children);
+    return {
+      p: ({ children }) => <p className="mb-2 last:mb-0">{enrich(children)}</p>,
+      li: ({ children }) => <li>{enrich(unwrapParagraphs(children))}</li>,
+      strong: ({ children }) => <strong>{enrich(children)}</strong>,
+      em: ({ children }) => <em>{enrich(children)}</em>,
+      td: ({ children }) => <td className="border border-border px-2 py-1">{enrich(children)}</td>,
+      th: ({ children }) => <th className="border border-border bg-muted px-2 py-1 text-left font-medium">{enrich(children)}</th>,
+      h1: ({ children }) => <h1 className="text-base font-bold mt-4 mb-2">{children}</h1>,
+      h2: ({ children }) => <h2 className="text-sm font-bold mt-3 mb-2">{children}</h2>,
+      h3: ({ children }) => <h3 className="text-sm font-semibold mt-2 mb-1">{children}</h3>,
+      ul: ({ children }) => <ul className="list-disc list-outside pl-5 mb-2 space-y-1">{children}</ul>,
+      ol: ({ children }) => <ol className="list-decimal list-outside pl-5 mb-2 space-y-1">{children}</ol>,
+      a: ({ href, children }) => (
+        <a href={href} className="text-blue-600 dark:text-blue-400 underline hover:no-underline" target="_blank" rel="noopener noreferrer">
+          {children}
+        </a>
+      ),
+      blockquote: ({ children }) => <blockquote className="border-l-2 border-primary/50 pl-3 my-2 text-muted-foreground italic">{children}</blockquote>,
+      table: ({ children }) => (
+        <div className="overflow-x-auto my-2">
+          <table className="min-w-full text-xs border border-border">{children}</table>
+        </div>
+      ),
+      hr: () => <hr className="my-3 border-border" />,
+      img: ({ src, alt }) => {
+        if (!src) return null;
+        if (!enableLocalImageRender) return <span className="text-muted-foreground">{src}</span>;
+
+        if (getMediaTypeFromSrc(src) === "video") {
+          return isLocalPath(src) ? <VideoLink src={src} /> : null;
+        }
+        if (isLocalPath(src)) {
+          return <LocalImage src={src} alt={alt} onPreview={setPreviewSrc} />;
+        }
+        return <StreamImagePreview src={src} alt={alt} onPreview={setPreviewSrc} />;
+      },
+      code: ({ className: cn, children, ...props }: any) => {
+        const match = /language-(\w+)/.exec(cn || "");
+        const code = String(children ?? "").replace(/\n$/, "");
+        const isInline = !code.includes("\n") && !match;
+
+        if (isInline) {
+          const showColor = enableEnrichment && hasColors(code);
+          return (
+            <code className="bg-muted px-1 py-0.5 rounded text-[11px]" {...props}>
+              {showColor ? <ColorEnrichedText text={code} /> : children}
+            </code>
+          );
+        }
+        return <CodeBlock code={code} language={match?.[1]} enableHighlight={enableEnrichment && !!match} style={codeStyle} />;
+      },
+    };
+  }, [enableEnrichment, enableLocalImageRender, fileMap, codeStyle]);
+
+  if (!content) return null;
+
+  return (
+    <div className={className}>
+      <ReactMarkdown remarkPlugins={[remarkGfm, remarkMath]} rehypePlugins={[rehypeKatex]} components={components}>
+        {content}
+      </ReactMarkdown>
+      <MediaPreviewModal src={previewSrc} onClose={() => setPreviewSrc(null)} />
+    </div>
+  );
+});
diff --git a/apps/vscode/webview-ui/src/components/MediaPreviewModal.tsx b/apps/vscode/webview-ui/src/components/MediaPreviewModal.tsx
new file mode 100644
index 000000000..d056fed8e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/MediaPreviewModal.tsx
@@ -0,0 +1,94 @@
+import { useState, useLayoutEffect, useCallback } from "react";
+import { IconX, IconPhoto } from "@tabler/icons-react";
+import { getMediaTypeFromDataUri } from "@/lib/media-utils";
+
+const IMG_HEIGHT = 128;
+const dimensionCache = new Map<string, number>();
+
+export function ImagePlaceholder() {
+  return (
+    <span className="inline-flex items-center justify-center bg-muted rounded my-2" style={{ width: 192, height: IMG_HEIGHT }}>
+      <IconPhoto className="size-6 text-muted-foreground animate-pulse" />
+    </span>
+  );
+}
+
+export function ImageLoadFail({ path }: { path: string }) {
+  return (
+    <span className="flex flex-col items-center justify-center bg-muted rounded my-2" style={{ width: 192, height: IMG_HEIGHT }}>
+      <IconPhoto className="size-6 text-red-400" />
+      <span className="text-xs">{path}</span>
+    </span>
+  );
+}
+
+export interface StreamImagePreviewProps {
+  src: string;
+  alt?: string;
+  onPreview: (uri: string) => void;
+}
+
+export function StreamImagePreview({ src, alt, onPreview }: StreamImagePreviewProps) {
+  const [width, setWidth] = useState<number | null>(() => dimensionCache.get(src) ?? null);
+
+  useLayoutEffect(() => {
+    if (width !== null) return;
+    const img = new Image();
+    img.onload = () => {
+      const w = Math.round(IMG_HEIGHT * (img.naturalWidth / img.naturalHeight));
+      dimensionCache.set(src, w);
+      setWidth(w);
+    };
+    img.src = src;
+  }, [src, width]);
+
+  if (width === null) return <ImagePlaceholder />;
+
+  return (
+    <img
+      src={src}
+      alt={alt || ""}
+      style={{ width, height: IMG_HEIGHT }}
+      className="rounded my-2 cursor-pointer hover:opacity-90 transition-opacity object-cover"
+      onClick={() => onPreview(src)}
+    />
+  );
+}
+
+interface MediaPreviewModalProps {
+  src: string | null;
+  onClose: () => void;
+}
+
+export function MediaPreviewModal({ src, onClose }: MediaPreviewModalProps) {
+  const handleKeyDown = useCallback(
+    (e: KeyboardEvent) => {
+      if (e.key === "Escape") onClose();
+    },
+    [onClose],
+  );
+
+  useLayoutEffect(() => {
+    if (src) {
+      document.addEventListener("keydown", handleKeyDown);
+      return () => document.removeEventListener("keydown", handleKeyDown);
+    }
+  }, [src, handleKeyDown]);
+
+  if (!src) return null;
+
+  const isVideo = getMediaTypeFromDataUri(src) === "video";
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/80" onClick={onClose}>
+      <button onClick={onClose} className="absolute top-4 right-4 p-2 rounded-full bg-black/50 text-white hover:bg-black/70 transition-colors">
+        <IconX className="size-5" />
+      </button>
+      {isVideo ? (
+        <video src={src} className="max-w-[90vw] max-h-[90vh] rounded-lg" controls autoPlay onClick={(e) => e.stopPropagation()} />
+      ) : (
+        <img src={src} alt="Preview" className="max-w-[90vw] max-h-[90vh] object-contain rounded-lg" onClick={(e) => e.stopPropagation()} />
+      )}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/MediaThumbnail.tsx b/apps/vscode/webview-ui/src/components/MediaThumbnail.tsx
new file mode 100644
index 000000000..ffc7dc56d
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/MediaThumbnail.tsx
@@ -0,0 +1,64 @@
+import { IconX, IconPlayerPlay, IconLoader2 } from "@tabler/icons-react";
+import { cn } from "@/lib/utils";
+import { getMediaTypeFromDataUri } from "@/lib/media-utils";
+
+interface ThumbnailWrapperProps {
+  onClick?: () => void;
+  onRemove?: () => void;
+  sizeClass: string;
+  children: React.ReactNode;
+}
+
+function ThumbnailWrapper({ onClick, onRemove, sizeClass, children }: ThumbnailWrapperProps) {
+  return (
+    <div className="relative group shrink-0">
+      <div className={cn(sizeClass, "rounded-md cursor-pointer border border-border hover:border-primary/50 transition-colors overflow-hidden")} onClick={onClick}>
+        {children}
+      </div>
+      {onRemove && (
+        <button
+          onClick={(e) => {
+            e.stopPropagation();
+            onRemove();
+          }}
+          className="absolute -top-1.5 -right-1.5 size-5 rounded-full text-red-500 bg-white border border-red-500 flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity cursor-pointer"
+        >
+          <IconX className="size-3" />
+        </button>
+      )}
+    </div>
+  );
+}
+
+interface MediaThumbnailProps {
+  src?: string;
+  onClick?: () => void;
+  onRemove?: () => void;
+  size?: "sm" | "md";
+  className?: string;
+}
+
+export function MediaThumbnail({ src, onClick, onRemove, size = "md", className }: MediaThumbnailProps) {
+  const sizeClass = size === "sm" ? "size-12" : "size-16";
+  const isLoading = !src;
+  const isVideo = src && getMediaTypeFromDataUri(src) === "video";
+
+  return (
+    <ThumbnailWrapper onClick={onClick} onRemove={onRemove} sizeClass={cn(sizeClass, className)}>
+      {isLoading ? (
+        <div className="w-full h-full bg-muted flex items-center justify-center">
+          <IconLoader2 className="size-5 text-muted-foreground animate-spin" />
+        </div>
+      ) : isVideo ? (
+        <div className="relative w-full h-full bg-black">
+          <video src={src} className="w-full h-full object-cover" muted preload="metadata" />
+          <div className="absolute inset-0 flex items-center justify-center bg-black/30">
+            <IconPlayerPlay className="size-5 text-white" />
+          </div>
+        </div>
+      ) : (
+        <img src={src} alt="Media" className={cn(sizeClass, "object-cover")} />
+      )}
+    </ThumbnailWrapper>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/PlanCard.tsx b/apps/vscode/webview-ui/src/components/PlanCard.tsx
new file mode 100644
index 000000000..df0decf0a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/PlanCard.tsx
@@ -0,0 +1,30 @@
+import { type ReactNode, useState } from "react";
+import { IconClipboardList, IconChevronDown } from "@tabler/icons-react";
+import { cn } from "@/lib/utils";
+
+interface PlanCardProps {
+  children: ReactNode;
+}
+
+export function PlanCard({ children }: PlanCardProps) {
+  const [collapsed, setCollapsed] = useState(false);
+
+  return (
+    <div className="my-2 rounded-lg border border-amber-300/50 dark:border-amber-700/50 bg-amber-50/30 dark:bg-amber-950/20 overflow-hidden">
+      <button
+        type="button"
+        onClick={() => setCollapsed(!collapsed)}
+        className="flex items-center gap-1.5 w-full px-3 py-1.5 bg-amber-100/50 dark:bg-amber-900/30 border-b border-amber-300/50 dark:border-amber-700/50 cursor-pointer hover:bg-amber-100/80 dark:hover:bg-amber-900/50 transition-colors"
+      >
+        <IconClipboardList className="size-3.5 text-amber-600 dark:text-amber-400" />
+        <span className="text-[11px] font-semibold text-amber-700 dark:text-amber-300 flex-1 text-left">Plan Mode</span>
+        <IconChevronDown className={cn("size-3.5 text-amber-600 dark:text-amber-400 transition-transform", collapsed && "-rotate-90")} />
+      </button>
+      {!collapsed && (
+        <div className="px-1 py-1 [&>*:not(:last-child)]:mb-3">
+          {children}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/PlanModeButton.tsx b/apps/vscode/webview-ui/src/components/PlanModeButton.tsx
new file mode 100644
index 000000000..be2d0c3f8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/PlanModeButton.tsx
@@ -0,0 +1,32 @@
+import { IconClipboardList } from "@tabler/icons-react";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+
+interface PlanModeButtonProps {
+  active: boolean;
+  onToggle: () => void;
+}
+
+export function PlanModeButton({ active, onToggle }: PlanModeButtonProps) {
+  const tooltipText = active ? "Plan mode active (click to exit)" : "Enter plan mode";
+
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <button
+          type="button"
+          onClick={onToggle}
+          className={cn(
+            "flex items-center justify-center size-6 rounded-md transition-all cursor-pointer",
+            active
+              ? "bg-amber-500/15 text-amber-600 dark:text-amber-400 hover:bg-amber-500/25"
+              : "bg-muted/50 text-muted-foreground hover:bg-muted hover:text-foreground",
+          )}
+        >
+          <IconClipboardList className="size-4" />
+        </button>
+      </TooltipTrigger>
+      <TooltipContent>{tooltipText}</TooltipContent>
+    </Tooltip>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/QuestionDialog.tsx b/apps/vscode/webview-ui/src/components/QuestionDialog.tsx
new file mode 100644
index 000000000..03a6da1fb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/QuestionDialog.tsx
@@ -0,0 +1,109 @@
+import { useState, useEffect } from "react";
+import { useChatStore } from "@/stores";
+import { cn } from "@/lib/utils";
+
+export function QuestionDialog() {
+  const { pendingQuestion, respondQuestion } = useChatStore();
+  const [customInput, setCustomInput] = useState("");
+  const [showCustom, setShowCustom] = useState(false);
+  const [selectedIndex, setSelectedIndex] = useState(1);
+
+  // For now, only handle the first question
+  const question = pendingQuestion?.questions?.[0];
+
+  useEffect(() => {
+    if (pendingQuestion) {
+      setShowCustom(false);
+      setCustomInput("");
+      setSelectedIndex(1);
+    }
+  }, [pendingQuestion?.id]);
+
+  if (!pendingQuestion || !question) return null;
+
+  const handleSelect = async (optionLabel: string) => {
+    const answers: Record<string, string> = {
+      [question.question]: optionLabel,
+    };
+    await respondQuestion(answers);
+  };
+
+  const handleCustomSubmit = async () => {
+    if (!customInput.trim()) return;
+    const answers: Record<string, string> = {
+      [question.question]: customInput.trim(),
+    };
+    await respondQuestion(answers);
+  };
+
+  const options = question.options || [];
+  const customIndex = options.length + 1;
+
+  return (
+    <div className={cn("mb-0.5 border border-blue-200 dark:border-blue-800 rounded-lg overflow-hidden bg-background flex flex-col shrink")}>
+      <div className="p-2 space-y-2">
+        {question.header && <div className="text-[10px] text-muted-foreground uppercase tracking-wide">{question.header}</div>}
+        <div className="text-xs font-semibold text-foreground">{question.question}</div>
+        <div className="space-y-1.5">
+          {options.map((option, idx) => (
+            <button
+              key={idx}
+              onClick={() => {
+                void handleSelect(option.label);
+              }}
+              onMouseEnter={() => setSelectedIndex(idx + 1)}
+              className={cn(
+                "w-full text-left px-2 py-1 rounded-md text-xs transition-colors",
+                "border border-border cursor-pointer",
+                selectedIndex === idx + 1 ? "bg-blue-500 text-white border-blue-500" : "bg-background hover:bg-muted/50",
+              )}
+            >
+              <span className={cn("mr-2", selectedIndex === idx + 1 ? "text-blue-200" : "text-muted-foreground")}>{idx + 1}</span>
+              <span className="font-medium">{option.label}</span>
+              {option.description && (
+                <span className={cn("ml-2", selectedIndex === idx + 1 ? "text-blue-200" : "text-muted-foreground")}>- {option.description}</span>
+              )}
+            </button>
+          ))}
+          {showCustom ? (
+            <div className="flex gap-1.5">
+              <input
+                autoFocus
+                value={customInput}
+                onChange={(e) => setCustomInput(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") void handleCustomSubmit();
+                  if (e.key === "Escape") setShowCustom(false);
+                }}
+                placeholder="Enter your response..."
+                className="flex-1 px-2 py-1 rounded-md text-xs border border-border bg-background outline-none focus:border-blue-500"
+              />
+              <button
+                onClick={() => {
+                  void handleCustomSubmit();
+                }}
+                disabled={!customInput.trim()}
+                className="px-2 py-1 rounded-md text-xs bg-blue-500 text-white disabled:opacity-50 cursor-pointer"
+              >
+                Send
+              </button>
+            </div>
+          ) : (
+            <button
+              onClick={() => setShowCustom(true)}
+              onMouseEnter={() => setSelectedIndex(customIndex)}
+              className={cn(
+                "w-full text-left px-2 py-1 rounded-md text-xs transition-colors",
+                "border border-border cursor-pointer",
+                selectedIndex === customIndex ? "bg-blue-500 text-white border-blue-500" : "bg-background hover:bg-muted/50",
+              )}
+            >
+              <span className={cn("mr-2", selectedIndex === customIndex ? "text-blue-200" : "text-muted-foreground")}>{customIndex}</span>
+              <span className="font-medium">Custom response...</span>
+            </button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/QueuedMessagesPanel.tsx b/apps/vscode/webview-ui/src/components/QueuedMessagesPanel.tsx
new file mode 100644
index 000000000..dc6c982b5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/QueuedMessagesPanel.tsx
@@ -0,0 +1,109 @@
+import { useState } from "react";
+import { IconTrash, IconArrowUp, IconPencil, IconCheck, IconX, IconBolt } from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import { useChatStore } from "@/stores";
+import { bridge } from "@/services";
+import { Content } from "@/lib/content";
+
+import type { ContentPart } from "shared/legacy-sdk";
+
+function QueueItem({ id, content, isStreaming, onEdit }: { id: string; content: string | ContentPart[]; isStreaming: boolean; onEdit: (id: string) => void }) {
+  const { removeFromQueue, moveQueueItemUp, queue } = useChatStore();
+  const text = Content.getText(content);
+  const hasMedia = Content.hasMedia(content);
+  const isFirst = queue[0]?.id === id;
+
+  const handleSteer = async () => {
+    const result = await bridge.steerChat(content);
+    if (result.ok) {
+      removeFromQueue(id);
+    }
+  };
+
+  return (
+    <div className="group flex items-start px-2.5 py-0.5 hover:bg-muted/50 transition-colors">
+      <div className="flex-1 min-w-0">
+        <p className="text-xs line-clamp-2 text-foreground">{text || (hasMedia ? "(media)" : "")}</p>
+        {hasMedia && text && <span className="text-[10px] text-muted-foreground">+ media</span>}
+      </div>
+      <div className="flex items-center gap-0.5 shrink-0 opacity-0 group-hover:opacity-100 transition-opacity">
+        {isStreaming && (
+          <Button
+            variant="ghost"
+            size="icon"
+            className="size-5 border-0! text-amber-500 hover:text-amber-600"
+            onClick={() => {
+              void handleSteer();
+            }}
+            title="Insert now (steer)"
+          >
+            <IconBolt className="size-3" />
+          </Button>
+        )}
+        <Button variant="ghost" size="icon" className="size-5 border-0!" onClick={() => onEdit(id)}>
+          <IconPencil className="size-3" />
+        </Button>
+        {!isFirst && (
+          <Button variant="ghost" size="icon" className="size-5 border-0!" onClick={() => moveQueueItemUp(id)}>
+            <IconArrowUp className="size-3" />
+          </Button>
+        )}
+        <Button variant="ghost" size="icon" className="size-5 border-0! text-muted-foreground hover:text-destructive" onClick={() => removeFromQueue(id)}>
+          <IconTrash className="size-3" />
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+function EditingItem({ id, initialContent, onDone }: { id: string; initialContent: string; onDone: () => void }) {
+  const [text, setText] = useState(initialContent);
+  const { editQueueItem } = useChatStore();
+
+  const handleSave = () => {
+    if (text.trim()) {
+      editQueueItem(id, text);
+    }
+    onDone();
+  };
+
+  return (
+    <div className="flex items-center px-2.5 py-0.5">
+      <input
+        autoFocus
+        value={text}
+        onChange={(e) => setText(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter") handleSave();
+          if (e.key === "Escape") onDone();
+        }}
+        className="flex-1 min-w-0 text-xs bg-transparent border-b border-border outline-none py-0.5"
+      />
+      <Button variant="ghost" size="icon" className="size-5 border-0!" onClick={handleSave}>
+        <IconCheck className="size-3" />
+      </Button>
+      <Button variant="ghost" size="icon" className="size-5 border-0!" onClick={onDone}>
+        <IconX className="size-3" />
+      </Button>
+    </div>
+  );
+}
+
+export function QueuedMessagesPanel() {
+  const { queue, isStreaming } = useChatStore();
+  const [editingId, setEditingId] = useState<string | null>(null);
+
+  if (queue.length === 0) return null;
+
+  return (
+    <div className="max-h-48 overflow-y-auto bg-card shrink">
+      {queue.map((item) =>
+        editingId === item.id ? (
+          <EditingItem key={item.id} id={item.id} initialContent={Content.getText(item.content)} onDone={() => setEditingId(null)} />
+        ) : (
+          <QueueItem key={item.id} id={item.id} content={item.content} isStreaming={isStreaming} onEdit={setEditingId} />
+        ),
+      )}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/SessionList.tsx b/apps/vscode/webview-ui/src/components/SessionList.tsx
new file mode 100644
index 000000000..65c1bb445
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/SessionList.tsx
@@ -0,0 +1,229 @@
+import { useMemo, useState } from "react";
+import { useRequest } from "ahooks";
+import { IconSearch, IconDots, IconTrash, IconCheck } from "@tabler/icons-react";
+import { Input } from "@/components/ui/input";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { StreamingConfirmDialog } from "./StreamingConfirmDialog";
+import { bridge } from "@/services";
+import type { SessionInfo } from "shared/legacy-sdk";
+import { cn } from "@/lib/utils";
+import { useChatStore, useSettingsStore } from "@/stores";
+import { cleanSystemTags } from "shared/utils";
+import { toast } from "./ui/sonner";
+
+interface SessionListProps {
+  onClose: () => void;
+}
+
+function formatRelativeDate(timestamp: number): string {
+  const diff = Date.now() - timestamp;
+  const m = Math.floor(diff / 60000);
+  const h = Math.floor(diff / 3600000);
+  const d = Math.floor(diff / 86400000);
+  if (m < 1) return "Just now";
+  if (m < 60) return `${m}m ago`;
+  if (h < 24) return `${h}h ago`;
+  if (d < 7) return `${d}d ago`;
+  return new Date(timestamp).toLocaleDateString();
+}
+
+interface SessionItemProps {
+  session: SessionInfo;
+  isSelected: boolean;
+  onSelect: () => void;
+  onDelete: () => void;
+  dirLabel: string | null; // null = current dir, string = relative path
+}
+
+function SessionItem({ session, isSelected, onSelect, onDelete, dirLabel }: SessionItemProps) {
+  const [isHovered, setIsHovered] = useState(false);
+
+  return (
+    <div
+      className={cn("group relative px-2 py-1 rounded-md cursor-pointer transition-colors", isSelected ? "bg-accent" : "hover:bg-accent/50")}
+      onMouseEnter={() => setIsHovered(true)}
+      onMouseLeave={() => setIsHovered(false)}
+      onClick={onSelect}
+    >
+      <p className="text-xs leading-relaxed line-clamp-3 text-foreground">{cleanSystemTags(session.brief) || "Untitled"}</p>
+      <div className="flex items-center justify-between mt-0.5">
+        <div className="flex items-center gap-1.5 min-w-0 flex-1">
+          {isSelected && <IconCheck className="size-3 text-blue-500 shrink-0" />}
+          <span className="text-[10px] text-muted-foreground shrink-0">{formatRelativeDate(session.updatedAt)}</span>
+          {dirLabel && <span className="text-[10px] text-muted-foreground/70 truncate" title={session.workDir}>· {dirLabel}</span>}
+        </div>
+        <div className={cn("transition-opacity", isHovered ? "opacity-100" : "opacity-0")}>
+          <DropdownMenu>
+            <DropdownMenuTrigger asChild>
+              <button className="p-1 -m-1 rounded hover:bg-muted transition-colors" onClick={(e) => e.stopPropagation()}>
+                <IconDots className="size-3.5 text-muted-foreground" />
+              </button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent align="end" className="w-32">
+              <DropdownMenuItem
+                className="text-xs text-destructive focus:text-destructive cursor-pointer"
+                onClick={(e) => {
+                  e.stopPropagation();
+                  onDelete();
+                }}
+              >
+                <IconTrash className="size-3.5 mr-2" />
+                Delete
+              </DropdownMenuItem>
+            </DropdownMenuContent>
+          </DropdownMenu>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function SessionList({ onClose }: SessionListProps) {
+  const { loadSession, sessionId, startNewConversation, isStreaming } = useChatStore();
+  const { workspaceRoot, currentWorkDir, setCurrentWorkDir } = useSettingsStore();
+  const [searchQuery, setSearchQuery] = useState("");
+  const [deleteTarget, setDeleteTarget] = useState<SessionInfo | null>(null);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [pendingSession, setPendingSession] = useState<SessionInfo | null>(null);
+
+  const { data: kimiSessions = [], loading, mutate } = useRequest(() => bridge.getAllKimiSessions());
+
+  const getWorkDirLabel = (sessionWorkDir: string): string | null => {
+    const activeWorkDir = currentWorkDir || workspaceRoot;
+    if (sessionWorkDir === activeWorkDir) return null;
+    if (!workspaceRoot) return sessionWorkDir;
+    // Show (root) for workspace root, relative path for subdirs
+    if (sessionWorkDir === workspaceRoot) {
+      return "/";
+    }
+    if (sessionWorkDir.startsWith(workspaceRoot)) {
+      return "." + sessionWorkDir.slice(workspaceRoot.length);
+    }
+    return sessionWorkDir;
+  };
+
+  const filteredSessions = useMemo(() => {
+    if (!searchQuery.trim()) return kimiSessions;
+    const q = searchQuery.toLowerCase();
+    return kimiSessions.filter((s) => s.brief.toLowerCase().includes(q));
+  }, [kimiSessions, searchQuery]);
+
+  const handleSelect = async (session: SessionInfo) => {
+    console.log("[SessionList] Loading session:", session.id);
+
+    // If streaming, show confirmation dialog
+    if (isStreaming) {
+      setPendingSession(session);
+      return;
+    }
+
+    await doLoadSession(session);
+  };
+
+  const doLoadSession = async (session: SessionInfo) => {
+    try {
+      // Switch workDir if session is from a different directory
+      const activeWorkDir = currentWorkDir || workspaceRoot;
+      if (session.workDir !== activeWorkDir) {
+        const newWorkDir = session.workDir === workspaceRoot ? null : session.workDir;
+        const result = await bridge.setWorkDir(newWorkDir);
+        if (result.ok) {
+          setCurrentWorkDir(newWorkDir);
+        }
+      }
+      const events = await bridge.loadSessionHistory(session.id);
+      await loadSession(session.id, events);
+      onClose();
+    } catch (error) {
+      console.error("[SessionList] Failed to load session:", error);
+      toast.error(`Unable to open the conversation: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+
+  const handleConfirmSwitch = async () => {
+    if (!pendingSession) return;
+    await doLoadSession(pendingSession);
+    setPendingSession(null);
+  };
+
+  const handleDelete = async () => {
+    if (!deleteTarget) return;
+
+    setIsDeleting(true);
+    try {
+      await bridge.deleteSession(deleteTarget.id);
+
+      if (sessionId === deleteTarget.id) {
+        await startNewConversation();
+      }
+
+      mutate((prev) => prev?.filter((s) => s.id !== deleteTarget.id) || []);
+    } catch (error) {
+      console.error("[SessionList] Failed to delete session:", error);
+      toast.error(`Unable to delete the conversation: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      setIsDeleting(false);
+      setDeleteTarget(null);
+    }
+  };
+
+  return (
+    <>
+      <div className="flex flex-col max-h-[70vh]">
+        <div className="p-2 border-b border-border shrink-0">
+          <div className="relative">
+            <IconSearch className="absolute left-2.5 top-1/2 -translate-y-1/2 size-3.5 text-muted-foreground" />
+            <Input placeholder="Search conversations..." value={searchQuery} onChange={(e) => setSearchQuery(e.target.value)} className="pl-8 h-8 text-xs" />
+          </div>
+        </div>
+        <div className="overflow-y-auto flex-1 min-h-0">
+          <div className="p-1.5 space-y-1">
+            {loading ? (
+              <div className="px-3 py-8 text-center text-xs text-muted-foreground">Loading...</div>
+            ) : filteredSessions.length === 0 ? (
+              <div className="px-3 py-8 text-center text-xs text-muted-foreground">{searchQuery ? "No conversations found" : "No conversations yet"}</div>
+            ) : (
+              filteredSessions.map((session) => (
+                <SessionItem
+                  key={session.id}
+                  session={session}
+                  isSelected={sessionId === session.id}
+                  onSelect={() => {
+                    void handleSelect(session);
+                  }}
+                  onDelete={() => setDeleteTarget(session)}
+                  dirLabel={getWorkDirLabel(session.workDir)}
+                />
+              ))
+            )}
+          </div>
+        </div>
+      </div>
+
+      <StreamingConfirmDialog
+        open={deleteTarget !== null}
+        onOpenChange={(open) => !open && setDeleteTarget(null)}
+        title="Delete Conversation?"
+        description="This will permanently delete this conversation. This action cannot be undone."
+        confirmLabel="Delete"
+        onConfirm={() => {
+          void handleDelete();
+        }}
+        confirmDisabled={isDeleting}
+        cancelDisabled={isDeleting}
+        confirmLoading={isDeleting}
+      />
+
+      <StreamingConfirmDialog
+        open={pendingSession !== null}
+        onOpenChange={(open) => !open && setPendingSession(null)}
+        title="Switch Conversation?"
+        description="The current conversation is still generating a response. Switching will truncate the output. Are you sure you want to continue?"
+        confirmLabel="Switch"
+        onConfirm={() => {
+          void handleConfirmSwitch();
+        }}
+      />
+    </>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/SlashCommandMenu.tsx b/apps/vscode/webview-ui/src/components/SlashCommandMenu.tsx
new file mode 100644
index 000000000..3a7d0028f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/SlashCommandMenu.tsx
@@ -0,0 +1,74 @@
+import { useEffect, useRef } from "react";
+import { cn } from "@/lib/utils";
+import type { SlashCommandInfo } from "shared/legacy-sdk";
+
+interface SlashCommandMenuProps {
+  commands: SlashCommandInfo[];
+  query: string;
+  selectedIndex: number;
+  onSelect: (name: string) => void;
+  onHover: (index: number) => void;
+}
+
+function highlightMatch(text: string, query: string): React.ReactNode {
+  if (!query) {
+    return text;
+  }
+
+  const lowerText = text.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  const parts: React.ReactNode[] = [];
+  let lastIdx = 0;
+  let qi = 0;
+
+  for (let i = 0; i < text.length && qi < lowerQuery.length; i++) {
+    if (lowerText[i] === lowerQuery[qi]) {
+      if (i > lastIdx) {
+        parts.push(text.slice(lastIdx, i));
+      }
+      parts.push(
+        <span key={i} className="text-foreground font-semibold">
+          {text[i]}
+        </span>,
+      );
+      lastIdx = i + 1;
+      qi++;
+    }
+  }
+
+  if (lastIdx < text.length) {
+    parts.push(text.slice(lastIdx));
+  }
+  return parts.length > 0 ? parts : text;
+}
+
+export function SlashCommandMenu({ commands, query, selectedIndex, onSelect, onHover }: SlashCommandMenuProps) {
+  const selectedRef = useRef<HTMLButtonElement>(null);
+
+  useEffect(() => {
+    selectedRef.current?.scrollIntoView({ block: "nearest" });
+  }, [selectedIndex]);
+
+  if (commands.length === 0) {
+    return <div className="rounded-md border bg-popover shadow-md p-3 text-xs text-muted-foreground text-center">No commands found</div>;
+  }
+
+  return (
+    <div className="rounded-md border bg-popover shadow-md overflow-hidden">
+      <div className="max-h-70 overflow-y-auto">
+        {commands.map((cmd, idx) => (
+          <button
+            key={cmd.name}
+            ref={idx === selectedIndex ? selectedRef : null}
+            onClick={() => onSelect(cmd.name)}
+            onMouseEnter={() => onHover(idx)}
+            className={cn("w-full px-2 py-1.5 text-left flex items-center justify-between gap-3", idx === selectedIndex ? "bg-accent" : "hover:bg-accent/50")}
+          >
+            <span className="text-xs shrink-0">{highlightMatch(`/${cmd.name}`, query)}</span>
+            <span className="text-[10px] text-muted-foreground truncate">{cmd.description}</span>
+          </button>
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/StreamingConfirmDialog.tsx b/apps/vscode/webview-ui/src/components/StreamingConfirmDialog.tsx
new file mode 100644
index 000000000..2f39e7785
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/StreamingConfirmDialog.tsx
@@ -0,0 +1,59 @@
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+
+interface StreamingConfirmDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  title: string;
+  description?: string;
+  confirmLabel?: string;
+  cancelLabel?: string;
+  onConfirm: () => void;
+  confirmDisabled?: boolean;
+  cancelDisabled?: boolean;
+  confirmLoading?: boolean;
+}
+
+export function StreamingConfirmDialog({
+  open,
+  onOpenChange,
+  title,
+  description = "The current conversation is still generating a response. This action will truncate the output. Are you sure you want to continue?",
+  confirmLabel = "Continue",
+  cancelLabel = "Cancel",
+  onConfirm,
+  confirmDisabled = false,
+  cancelDisabled = false,
+  confirmLoading = false,
+}: StreamingConfirmDialogProps) {
+  return (
+    <AlertDialog open={open} onOpenChange={onOpenChange}>
+      <AlertDialogContent>
+        <AlertDialogHeader>
+          <AlertDialogTitle>{title}</AlertDialogTitle>
+          <AlertDialogDescription>{description}</AlertDialogDescription>
+        </AlertDialogHeader>
+        <AlertDialogFooter>
+          <AlertDialogCancel onClick={() => onOpenChange(false)} disabled={cancelDisabled}>
+            {cancelLabel}
+          </AlertDialogCancel>
+          <AlertDialogAction
+            onClick={onConfirm}
+            disabled={confirmDisabled}
+            className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+          >
+            {confirmLoading ? `${confirmLabel}...` : confirmLabel}
+          </AlertDialogAction>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ThinkingBlock.tsx b/apps/vscode/webview-ui/src/components/ThinkingBlock.tsx
new file mode 100644
index 000000000..7ff565bdd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ThinkingBlock.tsx
@@ -0,0 +1,65 @@
+import { useState } from "react";
+import { IconChevronDown, IconLoader3, IconBulb } from "@tabler/icons-react";
+import { cn } from "@/lib/utils";
+import { Markdown } from "./Markdown";
+import { useSettingsStore } from "@/stores";
+
+interface ThinkingBlockProps {
+  content: string;
+  finished?: boolean;
+  compact?: boolean;
+}
+
+export function ThinkingBlock({ content, finished, compact }: ThinkingBlockProps) {
+  const { extensionConfig } = useSettingsStore();
+  const showThinkingContent = extensionConfig.showThinkingContent;
+
+  const [expanded, setExpanded] = useState(extensionConfig.showThinkingExpanded);
+  const isStreaming = !finished;
+
+  if (!showThinkingContent) {
+    // Hidden mode: static label, no interaction
+    return (
+      <div className="rounded-lg border border-zinc-200/50 bg-zinc-50/30 dark:border-zinc-800/50 dark:bg-zinc-900/10 overflow-hidden">
+        <div
+          className={cn("w-full flex items-center gap-2", compact ? "px-2 py-1.5" : "px-3 py-2")}
+        >
+          <div className="inline-flex items-center gap-2">
+            <IconBulb className={cn("text-zinc-500", compact ? "size-3" : "size-3.5")} />
+            <span className={cn("font-medium text-zinc-700 dark:text-zinc-300", compact ? "text-[0.75rem]" : "text-xs")}>Thinking</span>
+            {isStreaming && <IconLoader3 className={cn("text-zinc-400 ml-auto animate-spin", compact ? "size-3" : "size-3.5")} />}
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  // Show mode: clickable, expandable/collapsible
+  if (!content && !isStreaming) {
+    return null;
+  }
+
+  return (
+    <div className="rounded-lg border border-zinc-200/50 bg-zinc-50/30 dark:border-zinc-800/50 dark:bg-zinc-900/10 overflow-hidden">
+      <button
+        onClick={() => setExpanded(!expanded)}
+        className={cn("w-full flex items-center gap-2 hover:bg-zinc-100/50 dark:hover:bg-zinc-800/20 transition-colors", compact ? "px-2 py-1.5" : "px-3 py-2")}
+      >
+        <div className="inline-flex items-center gap-2">
+          <IconBulb className={cn("text-zinc-500", compact ? "size-3" : "size-3.5")} />
+          <span className={cn("font-medium text-zinc-700 dark:text-zinc-300", compact ? "text-[0.75rem]" : "text-xs")}>Thinking</span>
+          {isStreaming && <IconLoader3 className={cn("text-zinc-400 ml-auto animate-spin", compact ? "size-3" : "size-3.5")} />}
+        </div>
+        <IconChevronDown className={cn("text-zinc-400 ml-auto transition-transform", compact ? "size-3" : "size-3.5", expanded && "rotate-180")} />
+      </button>
+
+      {expanded && content && (
+        <Markdown
+          content={content}
+          className={cn("border-t border-zinc-200/50 dark:border-zinc-700/50", compact ? "py-2 px-2 text-[0.75rem]" : "py-3 px-2 pl-3.5 text-xs")}
+          enableEnrichment={finished}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ThinkingButton.tsx b/apps/vscode/webview-ui/src/components/ThinkingButton.tsx
new file mode 100644
index 000000000..f71cb59b2
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ThinkingButton.tsx
@@ -0,0 +1,72 @@
+import { IconBulb, IconCheck } from "@tabler/icons-react";
+
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+import type { ThinkingMode } from "shared/legacy-sdk";
+
+interface ThinkingButtonProps {
+  mode: ThinkingMode;
+  effort: string;
+  efforts?: string[];
+  alwaysOn?: boolean;
+  disabled?: boolean;
+  onToggle: () => void;
+  onSelectEffort: (effort: string) => void;
+}
+
+function label(effort: string): string {
+  return effort.charAt(0).toUpperCase() + effort.slice(1);
+}
+
+export function ThinkingButton({ mode, effort, efforts = [], alwaysOn = false, disabled, onToggle, onSelectEffort }: ThinkingButtonProps) {
+  if (mode === "none") return null;
+
+  const active = effort !== "off" || alwaysOn;
+  const button = (
+    <button
+      type="button"
+      onClick={mode === "switch" && !disabled ? onToggle : undefined}
+      disabled={disabled || mode === "always"}
+      className={cn(
+        "flex items-center gap-0.5 justify-center h-6 min-w-6 px-1 rounded-md transition-all",
+        active ? "bg-blue-500/15 text-blue-500" : "bg-muted/50 text-muted-foreground hover:bg-muted hover:text-foreground",
+        !disabled && mode !== "always" && "cursor-pointer hover:bg-blue-500/25",
+        (disabled || mode === "always") && "cursor-default",
+      )}
+    >
+      <IconBulb className="size-4" />
+      {mode === "effort" && <span className="text-[9px] font-medium leading-none">{label(effort)}</span>}
+    </button>
+  );
+
+  if (mode === "effort") {
+    const options = alwaysOn ? efforts : ["off", ...efforts];
+    return (
+      <DropdownMenu>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <DropdownMenuTrigger asChild disabled={disabled}>{button}</DropdownMenuTrigger>
+          </TooltipTrigger>
+          <TooltipContent>Thinking effort: {label(effort)}</TooltipContent>
+        </Tooltip>
+        <DropdownMenuContent align="start">
+          {options.map((option) => (
+            <DropdownMenuItem key={option} onClick={() => onSelectEffort(option)} className="text-xs gap-2">
+              <IconCheck className={cn("size-3", option !== effort && "opacity-0")} />
+              {label(option)}
+            </DropdownMenuItem>
+          ))}
+        </DropdownMenuContent>
+      </DropdownMenu>
+    );
+  }
+
+  const tooltip = mode === "always" ? "Thinking is always enabled for this model" : active ? "Thinking enabled" : "Enable thinking";
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>{button}</TooltipTrigger>
+      <TooltipContent>{tooltip}</TooltipContent>
+    </Tooltip>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/ToolRenderers.tsx b/apps/vscode/webview-ui/src/components/ToolRenderers.tsx
new file mode 100644
index 000000000..16b0b4eb3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ToolRenderers.tsx
@@ -0,0 +1,447 @@
+import { useState } from "react";
+import {
+  IconChevronDown,
+  IconChevronRight,
+  IconFile,
+  IconTerminal2,
+  IconFileText,
+  IconReplace,
+  IconFolderSearch,
+  IconSubtask,
+  IconListCheck,
+  IconSquareCheck,
+  IconSquare,
+  IconSquareChevronRight,
+} from "@tabler/icons-react";
+import { cn } from "@/lib/utils";
+import { FileLink, Markdown } from "./Markdown";
+import { DisplayBlocks } from "./DisplayBlocks";
+import { formatContentOutput } from "shared/legacy-sdk";
+import { cleanSystemTags } from "shared/utils";
+import { ThinkingBlock } from "./ThinkingBlock";
+import type { UIToolCall, UIStep, UIStepItem } from "@/stores/chat.store";
+import type { ToolResult, DisplayBlock, TodoBlock } from "shared/legacy-sdk";
+
+type ToolResultValue = ToolResult["return_value"];
+
+interface ToolRendererProps {
+  call: UIToolCall;
+  result?: ToolResultValue;
+  subagentSteps?: UIStep[];
+}
+
+function parseArgs(args: string | null): Record<string, unknown> {
+  if (!args) {
+    return {};
+  }
+  try {
+    return JSON.parse(args);
+  } catch {
+    return { raw: args };
+  }
+}
+
+function formatOutput(output: string | object | object[]): string {
+  const raw = formatContentOutput(output as string);
+  return cleanSystemTags(raw);
+}
+
+function getTodoBlock(display?: DisplayBlock[]): TodoBlock | null {
+  if (!display) {
+    return null;
+  }
+  return (display.find((b) => b.type === "todo") as TodoBlock) || null;
+}
+
+function getRichDisplayBlocks(display?: DisplayBlock[]): DisplayBlock[] {
+  if (!display) {
+    return [];
+  }
+  return display.filter((b) => b.type === "diff");
+}
+
+function CodeBlock({ content, maxLines = 10 }: { content: string; maxLines?: number }) {
+  const [expanded, setExpanded] = useState(false);
+  const lines = content.split("\n");
+  const shouldCollapse = lines.length > maxLines;
+  const displayContent = shouldCollapse && !expanded ? lines.slice(0, maxLines).join("\n") : content;
+
+  return (
+    <div className="relative group/codeblock">
+      <pre className="text-[11px] bg-zinc-100 dark:bg-zinc-800 text-zinc-700 dark:text-zinc-300 rounded px-3 py-2 overflow-x-auto whitespace-pre-wrap break-all">
+        {displayContent}
+        {shouldCollapse && !expanded && <span className="text-zinc-500">{"\n"}...</span>}
+      </pre>
+      {shouldCollapse && (
+        <button
+          onClick={() => setExpanded(!expanded)}
+          className="absolute bottom-1.5 right-1.5 text-[11px] px-1.5 py-0.5 rounded bg-zinc-200 dark:bg-zinc-700 text-zinc-600 dark:text-zinc-400 hover:text-zinc-900 dark:hover:text-zinc-100 opacity-0 group-hover/codeblock:opacity-100 transition-opacity cursor-pointer"
+        >
+          {expanded ? "Less" : `Expand +${lines.length - maxLines}`}
+        </button>
+      )}
+    </div>
+  );
+}
+
+function StatusIndicator({ status }: { status: "pending" | "success" | "error" }) {
+  if (status === "pending") {
+    return (
+      <span className="relative flex size-2">
+        <span className="animate-ping absolute inline-flex h-full w-full rounded-full bg-amber-400 opacity-75" />
+        <span className="relative inline-flex rounded-full size-2 bg-amber-500" />
+      </span>
+    );
+  }
+  return <span className={cn("inline-flex rounded-full size-2", status === "success" ? "bg-emerald-500" : "bg-red-500")} />;
+}
+
+function ToolIcon({ name }: { name: string }) {
+  const iconClass = "size-3.5 text-muted-foreground";
+  switch (name) {
+    case "Shell":
+      return <IconTerminal2 className={iconClass} />;
+    case "ReadFile":
+      return <IconFile className={iconClass} />;
+    case "WriteFile":
+      return <IconFileText className={iconClass} />;
+    case "StrReplaceFile":
+      return <IconReplace className={iconClass} />;
+    case "Glob":
+      return <IconFolderSearch className={iconClass} />;
+    case "Task":
+      return <IconSubtask className={iconClass} />;
+    case "SetTodoList":
+      return <IconListCheck className={iconClass} />;
+    default:
+      return <IconTerminal2 className={iconClass} />;
+  }
+}
+
+function IORow({ label, children }: { label: "IN" | "OUT"; children: React.ReactNode }) {
+  return (
+    <div className="flex flex-col @[420px]:flex-row gap-1 @[420px]:gap-0.5 py-2">
+      <span className="shrink-0 w-8 text-xs text-muted-foreground font-medium">{label}</span>
+      <div className="flex-1 min-w-0">{children}</div>
+    </div>
+  );
+}
+
+function TodoStatusIcon({ status }: { status: string }) {
+  if (status === "done") {
+    return (
+      <div className="size-4 rounded flex items-center justify-center">
+        <IconSquareCheck className="size-3 text-zinc-600 dark:text-zinc-400" />
+      </div>
+    );
+  }
+  if (status === "in_progress") {
+    return <IconSquareChevronRight className="size-4 text-amber-500" />;
+  }
+  return <IconSquare className="size-4 text-zinc-300 dark:text-zinc-600" />;
+}
+
+function SetTodoListTool({ result }: ToolRendererProps) {
+  const todoBlock = getTodoBlock(result?.display);
+  if (!todoBlock || !todoBlock.items || todoBlock.items.length === 0) {
+    return <div className="py-2 text-xs text-muted-foreground">{!result?.is_error && "Todo list updated"}</div>;
+  }
+  return (
+    <div className="py-1">
+      <div className="space-y-1">
+        {todoBlock.items.map((item, idx) => (
+          <div key={idx} className="flex items-start gap-1 py-0.5">
+            <div className="mt-0.5">
+              <TodoStatusIcon status={item.status} />
+            </div>
+            <span className={cn("text-xs leading-relaxed", item.status === "done" && "line-through text-muted-foreground")}>{item.title}</span>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function ShellTool({ call, result }: ToolRendererProps) {
+  const args = parseArgs(call.arguments);
+  const command = (args.command as string) || "";
+  const output = result ? formatOutput(result.output) : "";
+
+  return (
+    <div className="divide-y divide-border">
+      <IORow label="IN">
+        <span className="text-[11px] text-foreground font-mono">{command}</span>
+      </IORow>
+      {result && output && (
+        <IORow label="OUT">
+          <CodeBlock content={output} />
+        </IORow>
+      )}
+    </div>
+  );
+}
+
+function ReadFileTool({ call, result }: ToolRendererProps) {
+  const args = parseArgs(call.arguments);
+  const filePath = (args.path as string) || "";
+  const lineOffset = args.line_offset as number | undefined;
+  const output = result ? formatOutput(result.output) : "";
+
+  return (
+    <div className="divide-y divide-border">
+      <IORow label="IN">
+        <span className="inline-flex items-center gap-1.5">
+          <FileLink path={filePath} display={filePath} />
+          {lineOffset && lineOffset > 1 && <span className="text-[11px] text-muted-foreground">:L{lineOffset}</span>}
+        </span>
+      </IORow>
+      {result && output && (
+        <IORow label="OUT">
+          <CodeBlock content={output} maxLines={15} />
+        </IORow>
+      )}
+    </div>
+  );
+}
+
+function WriteFileTool({ call, result }: ToolRendererProps) {
+  const args = parseArgs(call.arguments);
+  const filePath = (args.path as string) || "";
+  const mode = (args.mode as string) || "overwrite";
+  const richDisplay = getRichDisplayBlocks(result?.display);
+  const hasRichDisplay = richDisplay.length > 0;
+
+  return (
+    <div className="divide-y divide-border">
+      <IORow label="IN">
+        <span className="inline-flex items-center gap-1.5">
+          <FileLink path={filePath} display={filePath} />
+          <span className="text-[11px] text-muted-foreground">({mode})</span>
+        </span>
+      </IORow>
+      {result && (
+        <IORow label="OUT">
+          {hasRichDisplay ? (
+            <DisplayBlocks blocks={richDisplay} maxHeight="max-h-48" />
+          ) : (
+            <span className={cn("text-xs", !result.is_error ? "text-emerald-500" : "text-red-500")}>{!result.is_error ? "✓ Written" : formatOutput(result.output)}</span>
+          )}
+        </IORow>
+      )}
+    </div>
+  );
+}
+
+function StrReplaceFileTool({ call, result }: ToolRendererProps) {
+  const args = parseArgs(call.arguments);
+  const filePath = (args.path as string) || "";
+  const richDisplay = getRichDisplayBlocks(result?.display);
+  const hasRichDisplay = richDisplay.length > 0;
+
+  return (
+    <div className="divide-y divide-border">
+      <IORow label="IN">
+        <FileLink path={filePath} display={filePath} />
+      </IORow>
+      {result && (
+        <IORow label="OUT">
+          {hasRichDisplay ? (
+            <DisplayBlocks blocks={richDisplay} maxHeight="max-h-48" />
+          ) : (
+            <span className={cn("text-xs font-medium", !result.is_error ? "text-emerald-600 dark:text-emerald-500" : "text-destructive")}>
+              {!result.is_error ? "✓ Replaced successfully" : formatOutput(result.output)}
+            </span>
+          )}
+        </IORow>
+      )}
+    </div>
+  );
+}
+
+function GlobTool({ call, result }: ToolRendererProps) {
+  const args = parseArgs(call.arguments);
+  const pattern = (args.pattern as string) || "";
+  const directory = args.directory as string | undefined;
+  const output = result ? formatOutput(result.output) : "";
+
+  return (
+    <div className="divide-y divide-border">
+      <IORow label="IN">
+        <span className="text-[11px] font-mono">
+          {pattern}
+          {directory && <span className="text-muted-foreground ml-1.5">in {directory}</span>}
+        </span>
+      </IORow>
+      {result && output && (
+        <IORow label="OUT">
+          <CodeBlock content={output} />
+        </IORow>
+      )}
+    </div>
+  );
+}
+
+function GenericTool({ call, result }: ToolRendererProps) {
+  const args = parseArgs(call.arguments);
+  const output = result ? formatOutput(result.output) : "";
+  const richDisplay = getRichDisplayBlocks(result?.display);
+  const hasRichDisplay = richDisplay.length > 0;
+
+  return (
+    <div className="divide-y divide-border">
+      <IORow label="IN">
+        <CodeBlock content={JSON.stringify(args, null, 2)} maxLines={8} />
+      </IORow>
+      {result && (
+        <IORow label="OUT">
+          {hasRichDisplay ? (
+            <DisplayBlocks blocks={richDisplay} maxHeight="max-h-48" />
+          ) : output ? (
+            <CodeBlock content={output} />
+          ) : (
+            <span className={cn("text-xs", !result.is_error ? "text-emerald-500" : "text-red-500")}>{!result.is_error ? "✓ Done" : "✗ Failed"}</span>
+          )}
+        </IORow>
+      )}
+    </div>
+  );
+}
+
+function SubagentStepItemRenderer({ item }: { item: UIStepItem }) {
+  if (item.type === "thinking") {
+    return <ThinkingBlock content={item.content} finished={item.finished} compact />;
+  }
+  if (item.type === "text") {
+    return <Markdown content={item.content} className="text-[0.75rem] leading-relaxed" enableEnrichment={item.finished} />;
+  }
+  if (item.type === "tool_use") {
+    return <ToolCallCard call={item.call} result={item.result} subagentSteps={item.subagent_steps} />;
+  }
+  return null;
+}
+
+function TaskTool({ call, result, subagentSteps }: ToolRendererProps) {
+  const [showProcess, setShowProcess] = useState(false);
+  const args = parseArgs(call.arguments);
+  const description = (args.description as string) || "";
+  const subagentName = (args.subagent_name as string) || (args.subagent_type as string) || "coder";
+  const prompt = (args.prompt as string) || "";
+  const hasSubagentSteps = subagentSteps && subagentSteps.length > 0;
+
+  const finalOutput = (() => {
+    if (!hasSubagentSteps) {
+      return result ? formatOutput(result.output) : "";
+    }
+    const lastStep = subagentSteps[subagentSteps.length - 1];
+    const textItems = lastStep.items.filter((i) => i.type === "text");
+    if (textItems.length > 0) {
+      return textItems.map((i) => (i as { type: "text"; content: string }).content).join("\n");
+    }
+    return result ? formatOutput(result.output) : "";
+  })();
+
+  return (
+    <div className="divide-y divide-border">
+      <div className="py-2">
+        <div className="flex items-center gap-2 mb-1.5">
+          <span className="text-[10px] px-1.5 py-0.5 rounded bg-blue-500/10 text-blue-600 dark:text-blue-400 font-medium">{subagentName}</span>
+          <span className="text-xs font-medium">{description}</span>
+        </div>
+        {prompt && <div className="text-[10px] text-muted-foreground line-clamp-2">{prompt}</div>}
+      </div>
+      {hasSubagentSteps && (
+        <div className="py-2">
+          <button onClick={() => setShowProcess(!showProcess)} className="flex items-center gap-1.5 text-[0.75rem] text-muted-foreground hover:text-foreground transition-colors">
+            {showProcess ? <IconChevronDown className="size-3" /> : <IconChevronRight className="size-3" />}
+            <span>
+              {subagentSteps.length} step{subagentSteps.length > 1 ? "s" : ""}
+            </span>
+          </button>
+          {showProcess && (
+            <div className="mt-2 space-y-3">
+              {subagentSteps.map((step) => (
+                <div key={step.n} className="space-y-2">
+                  <div className="text-[0.75rem] text-muted-foreground uppercase tracking-wider">Step {step.n}</div>
+                  <div className="space-y-2">
+                    {step.items.map((item, idx) => (
+                      <SubagentStepItemRenderer key={`${step.n}-${idx}`} item={item} />
+                    ))}
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      )}
+      {result && finalOutput && (
+        <IORow label="OUT">
+          <CodeBlock content={finalOutput} maxLines={15} />
+        </IORow>
+      )}
+    </div>
+  );
+}
+
+function getToolLabel(call: UIToolCall): string {
+  const args = parseArgs(call.arguments);
+  switch (call.name) {
+    case "Shell":
+      return (args.command as string) || "command";
+    case "ReadFile":
+      return (args.path as string)?.split("/").pop() || "file";
+    case "WriteFile":
+      return (args.path as string)?.split("/").pop() || "file";
+    case "StrReplaceFile":
+      return (args.path as string)?.split("/").pop() || "file";
+    case "Glob":
+      return (args.pattern as string) || "pattern";
+    case "Task":
+      return (args.description as string) || "subagent task";
+    case "SetTodoList":
+      return "Update Todos";
+    default:
+      return "";
+  }
+}
+
+export function ToolCallCard({ call, result, subagentSteps }: ToolRendererProps) {
+  const [expanded, setExpanded] = useState(false);
+  const status = !result ? "pending" : !result.is_error ? "success" : "error";
+
+  const renderContent = () => {
+    const props = { call, result, subagentSteps };
+    switch (call.name) {
+      case "Shell":
+        return <ShellTool {...props} />;
+      case "ReadFile":
+        return <ReadFileTool {...props} />;
+      case "WriteFile":
+        return <WriteFileTool {...props} />;
+      case "StrReplaceFile":
+        return <StrReplaceFileTool {...props} />;
+      case "Glob":
+        return <GlobTool {...props} />;
+      case "Task":
+      case "Agent":
+        return <TaskTool {...props} />;
+      case "SetTodoList":
+        return <SetTodoListTool {...props} />;
+      default:
+        return <GenericTool {...props} />;
+    }
+  };
+
+  return (
+    <div className="rounded-lg border border-border overflow-hidden">
+      <button onClick={() => setExpanded(!expanded)} className="w-full flex items-center gap-2 px-3 py-2 hover:bg-muted/50 transition-colors">
+        <StatusIndicator status={status} />
+        <ToolIcon name={call.name} />
+        <span className="text-xs font-medium">{call.name}</span>
+        <span className="text-xs text-muted-foreground truncate flex-1 text-left">{getToolLabel(call)}</span>
+        {subagentSteps && subagentSteps.length > 0 && <span className="text-[10px] px-1.5 py-0.5 rounded bg-blue-500/10 text-blue-500">{subagentSteps.length} steps</span>}
+        <IconChevronDown className={cn("size-3.5 text-muted-foreground transition-transform", expanded && "rotate-180")} />
+      </button>
+      {expanded && <div className="@container px-3 py-0.5 border-t border-border">{renderContent()}</div>}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/WelcomeScreen.tsx b/apps/vscode/webview-ui/src/components/WelcomeScreen.tsx
new file mode 100644
index 000000000..4ea476e24
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/WelcomeScreen.tsx
@@ -0,0 +1,20 @@
+import { KimiMascot } from "./KimiMascot";
+import { useWelcomeHint } from "@/hooks/useWelcomeHint";
+
+export function WelcomeScreen() {
+  const hint = useWelcomeHint();
+
+  return (
+    <div className="flex flex-col items-center gap-3 px-4">
+      <KimiMascot className="h-12" />
+      {hint.component ? (
+        hint.component
+      ) : (
+        <div className="text-center space-y-0.5">
+          <p className="text-xs font-medium text-foreground">{hint.title}</p>
+          <p className="text-xs text-muted-foreground">{hint.description}</p>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/WorkDirModal.tsx b/apps/vscode/webview-ui/src/components/WorkDirModal.tsx
new file mode 100644
index 000000000..3cba92633
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/WorkDirModal.tsx
@@ -0,0 +1,127 @@
+import { useState, useEffect } from "react";
+import { IconFolder, IconFolderOpen, IconCheck, IconHome } from "@tabler/icons-react";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { useSettingsStore, useChatStore } from "@/stores";
+import { bridge } from "@/services";
+import { cn } from "@/lib/utils";
+
+export function WorkDirModal() {
+  const { workDirModalOpen, setWorkDirModalOpen, currentWorkDir, workspaceRoot, setCurrentWorkDir } = useSettingsStore();
+  const { startNewConversation } = useChatStore();
+  const [workDirs, setWorkDirs] = useState<string[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (workDirModalOpen) {
+      void bridge.getRegisteredWorkDirs().then(setWorkDirs);
+    }
+  }, [workDirModalOpen]);
+
+  const handleSelect = async (dir: string | null) => {
+    setLoading(true);
+    try {
+      const result = await bridge.setWorkDir(dir);
+      if (result.ok) {
+        setCurrentWorkDir(result.workDir === workspaceRoot ? null : result.workDir);
+        await startNewConversation();
+        setWorkDirModalOpen(false);
+      }
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleBrowse = async () => {
+    setLoading(true);
+    try {
+      const result = await bridge.browseWorkDir();
+      if (result.ok && result.workDir) {
+        setCurrentWorkDir(result.workDir === workspaceRoot ? null : result.workDir);
+        await startNewConversation();
+        setWorkDirModalOpen(false);
+      }
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const displayPath = (fullPath: string) => {
+    if (!workspaceRoot) return fullPath;
+    if (fullPath === workspaceRoot) return fullPath.split("/").pop() || fullPath;
+    return fullPath.replace(workspaceRoot, ".");
+  };
+
+  const isSelected = (dir: string) => {
+    if (!currentWorkDir) return dir === workspaceRoot;
+    return dir === currentWorkDir;
+  };
+
+  return (
+    <Dialog open={workDirModalOpen} onOpenChange={setWorkDirModalOpen}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>Select Working Directory</DialogTitle>
+        </DialogHeader>
+
+        <div className="space-y-1 max-h-64 overflow-y-auto -mx-1 px-1">
+          {workDirs.map((dir) => (
+            <button
+              key={dir}
+              onClick={() => {
+                void handleSelect(dir === workspaceRoot ? null : dir);
+              }}
+              disabled={loading}
+              className={cn(
+                "w-full flex items-center gap-2 px-3 py-2 rounded-md text-left text-sm transition-colors",
+                isSelected(dir) ? "bg-accent" : "hover:bg-accent/50",
+                loading && "opacity-50 cursor-not-allowed",
+              )}
+            >
+              {dir === workspaceRoot ? (
+                <IconHome className="size-4 text-muted-foreground shrink-0" />
+              ) : (
+                <IconFolder className="size-4 text-muted-foreground shrink-0" />
+              )}
+              <span className="flex-1 truncate">{displayPath(dir)}</span>
+              {isSelected(dir) && <IconCheck className="size-4 text-blue-500 shrink-0" />}
+              {dir === workspaceRoot && <span className="text-xs text-muted-foreground">(root)</span>}
+            </button>
+          ))}
+        </div>
+
+        <DialogFooter className="sm:justify-between gap-2">
+          <div className="flex gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => {
+                void handleBrowse();
+              }}
+              disabled={loading}
+            >
+              <IconFolderOpen className="size-4 mr-1.5" />
+              Browse...
+            </Button>
+            {currentWorkDir && (
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => {
+                  void handleSelect(null);
+                }}
+                disabled={loading}
+              >
+                <IconHome className="size-4 mr-1.5" />
+                Reset
+              </Button>
+            )}
+          </div>
+          <Button variant="ghost" size="sm" onClick={() => setWorkDirModalOpen(false)}>
+            Cancel
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/hooks/useExtensionImageUrl.ts b/apps/vscode/webview-ui/src/components/hooks/useExtensionImageUrl.ts
new file mode 100644
index 000000000..ca1eafd34
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/hooks/useExtensionImageUrl.ts
@@ -0,0 +1,14 @@
+import { useEffect, useState } from "react";
+
+export function useExtensionImageUrl(imageName: string): string {
+  const [url, setUrl] = useState("");
+
+  useEffect(() => {
+    const baseUri = document.body.getAttribute("data-baseuri");
+    if (baseUri) {
+      setUrl(`${baseUri}/dist/${imageName}`);
+    }
+  }, [imageName]);
+
+  return url;
+}
diff --git a/apps/vscode/webview-ui/src/components/index.ts b/apps/vscode/webview-ui/src/components/index.ts
new file mode 100644
index 000000000..41671569e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/index.ts
@@ -0,0 +1,26 @@
+export { Header } from "./Header";
+export { SessionList } from "./SessionList";
+export { WelcomeScreen } from "./WelcomeScreen";
+export { ChatMessage } from "./ChatMessage";
+export { ChatArea } from "./ChatArea";
+export { ChatStatus } from "./ChatStatus";
+export { InputArea } from "./inputarea/InputArea";
+export { ActionMenu } from "./ActionMenu";
+export { KimiLogo } from "./KimiLogo";
+export { KimiMascot } from "./KimiMascot";
+export { ToolCallCard } from "./ToolRenderers";
+export { ApprovalDialog } from "./ApprovalDialog";
+export { MCPServersModal } from "./MCPServersModal";
+export { WorkDirModal } from "./WorkDirModal";
+export { ThinkingBlock } from "./ThinkingBlock";
+export { ThinkingButton } from "./ThinkingButton";
+export { CompactionCard } from "./CompactionCard";
+export { ConfigErrorScreen } from "./ConfigErrorScreen";
+export { LoginScreen } from "./LoginScreen";
+export { MediaPreviewModal } from "./MediaPreviewModal";
+export { MediaThumbnail } from "./MediaThumbnail";
+export { BottomToolbar } from "./BottomToolbar";
+export { InlineError } from "./InlineError";
+export { QuestionDialog } from "./QuestionDialog";
+export { PlanCard } from "./PlanCard";
+export { PlanModeButton } from "./PlanModeButton";
diff --git a/apps/vscode/webview-ui/src/components/inputarea/InputArea.tsx b/apps/vscode/webview-ui/src/components/inputarea/InputArea.tsx
new file mode 100644
index 000000000..5d1b09cd6
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/inputarea/InputArea.tsx
@@ -0,0 +1,501 @@
+import { Fragment, useRef, useMemo, useState, useEffect, useCallback } from "react";
+import { useMemoizedFn } from "ahooks";
+import { IconSend, IconPlayerStop, IconChevronDown, IconPlus } from "@tabler/icons-react";
+import { Button } from "@/components/ui/button";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { ActionMenu } from "../ActionMenu";
+import { SlashCommandMenu } from "../SlashCommandMenu";
+import { FilePickerMenu } from "../FilePickerMenu";
+import { MediaThumbnail } from "../MediaThumbnail";
+import { MediaPreviewModal } from "../MediaPreviewModal";
+import { BottomToolbar } from "../BottomToolbar";
+import { StreamingConfirmDialog } from "../StreamingConfirmDialog";
+import { ThinkingButton } from "../ThinkingButton";
+import { PlanModeButton } from "../PlanModeButton";
+import {
+  getModelById,
+  getMediaFallbackModel,
+  getModelsForMedia,
+  groupModelsByProvider,
+  providerDisplayName,
+  useChatStore,
+  useSettingsStore,
+} from "@/stores";
+import { bridge, Events } from "@/services";
+import { Content } from "@/lib/content";
+import { cn } from "@/lib/utils";
+import { useSlashMenu, findActiveToken } from "./hooks/useSlashMenu";
+import { useFilePicker } from "./hooks/useFilePicker";
+import { useMediaUpload } from "./hooks/useMediaUpload";
+import { useClickOutside } from "./hooks/useClickOutside";
+import { useInputHistory } from "./hooks/useInputHistory";
+import { computeMentionInsert } from "./utils";
+
+interface InputAreaProps {
+  onAuthAction?: () => void;
+}
+
+export function InputArea({ onAuthAction }: InputAreaProps) {
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const menuRef = useRef<HTMLDivElement>(null);
+  const [text, setText] = useState("");
+  const [cursorPos, setCursorPos] = useState(0);
+  const [previewMedia, setPreviewMedia] = useState<string | null>(null);
+
+  const { isStreaming, sendMessage, abort, draftMedia, removeDraftMedia, hasProcessingMedia, getMediaInConversation, pendingInput, planMode } = useChatStore();
+  const { currentModel, thinkingEffort, updateModel, toggleThinking, selectThinkingEffort, models, extensionConfig, getCurrentThinkingMode } = useSettingsStore();
+
+  const isProcessing = hasProcessingMedia();
+  const thinkingMode = getCurrentThinkingMode();
+
+  const [showPlanModeConfirm, setShowPlanModeConfirm] = useState(false);
+
+  const handleTogglePlanMode = () => {
+    // Turning OFF during streaming needs confirmation — user may want next turn, not current
+    if (planMode && isStreaming) {
+      setShowPlanModeConfirm(true);
+      return;
+    }
+    const newState = !planMode;
+    useChatStore.setState({ planMode: newState }); // optimistic
+    void bridge.setPlanMode(newState);
+  };
+
+  const handleConfirmExitPlanMode = () => {
+    useChatStore.setState({ planMode: false });
+    void bridge.setPlanMode(false);
+    setShowPlanModeConfirm(false);
+  };
+
+  const mediaReq = useMemo(() => {
+    const media = getMediaInConversation();
+    return { image: media.hasImage, video: media.hasVideo };
+  }, [getMediaInConversation, draftMedia]);
+
+  const availableModels = useMemo(() => getModelsForMedia(models, mediaReq), [models, mediaReq]);
+  const currentModelConfig = getModelById(models, currentModel);
+  const modelGroups = useMemo(() => groupModelsByProvider(availableModels), [availableModels]);
+  const showProviderGroups = modelGroups.length > 1;
+  const currentModelLabel = currentModelConfig === undefined
+    ? "No models available"
+    : showProviderGroups
+      ? `${currentModelConfig.name} · ${providerDisplayName(currentModelConfig.provider)}`
+      : currentModelConfig.name;
+
+  // Auto-switch model if current model doesn't support required media
+  useEffect(() => {
+    if (!mediaReq.image && !mediaReq.video) {
+      return;
+    }
+    const isCurrentModelValid = availableModels.some((m) => m.id === currentModel);
+    if (isCurrentModelValid) {
+      return;
+    }
+    const fallbackModel = getMediaFallbackModel(availableModels, currentModelConfig);
+    if (fallbackModel !== undefined) {
+      updateModel(fallbackModel.id);
+    }
+  }, [mediaReq.image, mediaReq.video, currentModel, currentModelConfig, availableModels, updateModel]);
+
+  // Restore pending input
+  useEffect(() => {
+    if (!pendingInput || isStreaming) {
+      return;
+    }
+
+    // 只在输入框为空时恢复
+    if (text.trim()) {
+      return;
+    }
+
+    const textContent = Content.getText(pendingInput.content);
+    if (textContent) {
+      setText(textContent);
+      setTimeout(() => {
+        textareaRef.current?.focus();
+        adjustHeight();
+      }, 0);
+    }
+  }, [pendingInput, isStreaming]);
+
+  const activeToken = useMemo(() => findActiveToken(text, cursorPos), [text, cursorPos]);
+
+  const { handlePaste, handlePickMedia } = useMediaUpload();
+
+  const adjustHeight = useMemoizedFn(() => {
+    const ta = textareaRef.current;
+    if (ta) {
+      ta.style.height = "auto";
+      ta.style.height = `${Math.min(ta.scrollHeight, 140)}px`;
+    }
+  });
+
+  const {
+    handleKey: handleHistoryKey,
+    add: addToHistory,
+    reset: resetHistoryIndex,
+  } = useInputHistory({
+    text,
+    setText,
+    onHeightChange: () => setTimeout(adjustHeight, 0),
+  });
+
+  const clearInput = useMemoizedFn(() => {
+    setText("");
+    setCursorPos(0);
+    setTimeout(adjustHeight, 0);
+  });
+
+  const removeActiveToken = useMemoizedFn(() => {
+    if (!activeToken) return;
+    const newText = text.slice(0, activeToken.start) + text.slice(cursorPos);
+    const newCursorPos = activeToken.start;
+    setText(newText);
+    setCursorPos(newCursorPos);
+    setTimeout(() => {
+      textareaRef.current?.setSelectionRange(newCursorPos, newCursorPos);
+      adjustHeight();
+    }, 0);
+  });
+
+  const handleSend = useMemoizedFn(() => {
+    if (isProcessing || (!text.trim() && draftMedia.length === 0)) {
+      return;
+    }
+
+    addToHistory(text);
+    sendMessage(text);
+    clearInput();
+  });
+
+  const handleSlashCommand = useMemoizedFn((name: string) => {
+    sendMessage(`/${name}`);
+    clearInput();
+  });
+
+  const applyMention = useMemoizedFn((filePath: string) => {
+    const { newText, newCursorPos } = computeMentionInsert({
+      text,
+      cursorPos,
+      filePath,
+      activeToken,
+      isAppend: false,
+    });
+
+    setText(newText);
+    setCursorPos(newCursorPos);
+    setTimeout(() => {
+      textareaRef.current?.setSelectionRange(newCursorPos, newCursorPos);
+      textareaRef.current?.focus();
+      adjustHeight();
+    }, 0);
+  });
+
+  const {
+    showSlashMenu,
+    filteredCommands,
+    selectedIndex: slashSelectedIndex,
+    setSelectedIndex: setSlashSelectedIndex,
+    handleSlashMenuKey,
+    resetSlashMenu,
+  } = useSlashMenu(activeToken, handleSlashCommand, removeActiveToken);
+
+  const {
+    showFileMenu,
+    filePickerMode,
+    folderPath,
+    fileItems,
+    selectedIndex: fileSelectedIndex,
+    isLoading: isFileLoading,
+    showMediaOption,
+    setSelectedIndex: setFileSelectedIndex,
+    setFilePickerMode,
+    setFolderPath,
+    handleFileMenuKey,
+    resetFilePicker,
+  } = useFilePicker(
+    activeToken,
+    applyMention,
+    () => {
+      void handlePickMedia();
+    },
+    removeActiveToken,
+  );
+
+  const closeMenus = useCallback(() => {
+    if (showSlashMenu || showFileMenu) {
+      removeActiveToken();
+    }
+  }, [showSlashMenu, showFileMenu, removeActiveToken]);
+
+  useClickOutside([textareaRef, menuRef], showSlashMenu || showFileMenu, closeMenus);
+
+  useEffect(() => {
+    resetSlashMenu();
+  }, [showSlashMenu, resetSlashMenu]);
+
+  useEffect(() => {
+    if (!showFileMenu) {
+      resetFilePicker();
+    }
+  }, [showFileMenu, resetFilePicker]);
+
+  useEffect(() => {
+    const unsub = bridge.on<{ mention: string }>(Events.InsertMention, ({ mention }) => {
+      setText((prev) => prev + mention + " ");
+
+      setTimeout(() => {
+        textareaRef.current?.focus();
+        adjustHeight();
+      }, 0);
+    });
+
+    return unsub;
+  }, [adjustHeight]);
+
+  const handleKeyDown = useMemoizedFn((e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+    if (e.nativeEvent.isComposing) {
+      return;
+    }
+
+    if (handleSlashMenuKey(e)) {
+      return;
+    }
+
+    if (handleFileMenuKey(e)) {
+      return;
+    }
+
+    if (handleHistoryKey(e)) {
+      return;
+    }
+
+    if (extensionConfig.useCtrlEnterToSend) {
+      if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
+        e.preventDefault();
+        handleSend();
+      }
+    } else {
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        handleSend();
+      }
+    }
+  });
+
+  const handleChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+    setText(e.target.value);
+    setCursorPos(e.target.selectionStart);
+    resetHistoryIndex();
+    setTimeout(adjustHeight, 0);
+  };
+
+  const handleSelect = () => {
+    setCursorPos(textareaRef.current?.selectionStart ?? 0);
+  };
+
+  const handleAddButtonClick = useMemoizedFn(() => {
+    const newText = text + "@";
+    setText(newText);
+    setCursorPos(newText.length);
+    setTimeout(() => {
+      textareaRef.current?.focus();
+      textareaRef.current?.setSelectionRange(newText.length, newText.length);
+      adjustHeight();
+    }, 0);
+  });
+
+  const hasModels = availableModels.length > 0;
+  const canSend = (text.trim() || draftMedia.length > 0) && !isProcessing;
+
+  return (
+    <div className="p-2 pt-0! flex flex-col min-h-0">
+      <BottomToolbar />
+      <div className="relative shrink-0">
+        {showSlashMenu && filteredCommands.length > 0 && (
+          <div ref={menuRef} className="absolute bottom-full left-0 right-0 mb-2 z-10">
+            <SlashCommandMenu
+              commands={filteredCommands}
+              query={activeToken?.query || ""}
+              selectedIndex={slashSelectedIndex}
+              onSelect={handleSlashCommand}
+              onHover={setSlashSelectedIndex}
+            />
+          </div>
+        )}
+
+        {showFileMenu && (
+          <div ref={menuRef} className="absolute bottom-full left-0 right-0 mb-2 z-10">
+            <FilePickerMenu
+              mode={filePickerMode}
+              items={fileItems}
+              currentPath={folderPath}
+              selectedIndex={fileSelectedIndex}
+              isLoading={isFileLoading}
+              showMediaOption={showMediaOption}
+              onSelectMedia={() => {
+                void handlePickMedia();
+              }}
+              onSwitchToFolder={() => {
+                setFilePickerMode("folder");
+                setFolderPath("");
+                setFileSelectedIndex(0);
+              }}
+              onSwitchToSearch={() => {
+                setFilePickerMode("search");
+                setFolderPath("");
+                setFileSelectedIndex(0);
+              }}
+              onSelectItem={(item) => applyMention(item.path)}
+              onNavigateUp={() => {
+                setFolderPath(folderPath.split("/").slice(0, -1).join("/"));
+                setFileSelectedIndex(0);
+              }}
+              onNavigateInto={(item) => {
+                setFilePickerMode("folder");
+                setFolderPath(item.path);
+                setFileSelectedIndex(0);
+              }}
+              onHover={setFileSelectedIndex}
+            />
+          </div>
+        )}
+
+        <div className="border border-input rounded-md overflow-hidden">
+          {draftMedia.length > 0 && (
+            <div className="flex gap-2 p-2 overflow-x-auto">
+              {draftMedia.map((item) => (
+                <MediaThumbnail
+                  key={item.id}
+                  src={item.dataUri}
+                  size="sm"
+                  onClick={item.dataUri ? () => setPreviewMedia(item.dataUri!) : undefined}
+                  onRemove={() => removeDraftMedia(item.id)}
+                />
+              ))}
+            </div>
+          )}
+
+          <textarea
+            ref={textareaRef}
+            value={text}
+            onChange={handleChange}
+            onKeyDown={handleKeyDown}
+            onSelect={handleSelect}
+            onPaste={handlePaste}
+            placeholder={isStreaming ? "Add a follow-up..." : "Ask Kimi Code... (/ commands · @ files · Alt+K code)"}
+            className={cn(
+              "w-full min-h-12 max-h-35 px-2.5 py-1.5 text-xs leading-relaxed",
+              "bg-transparent resize-none outline-none border-none overflow-y-auto",
+              "placeholder:text-muted-foreground",
+            )}
+          />
+
+          <div className="flex items-center justify-between px-1.5 pb-1.5">
+            <div className="flex items-center gap-1.5 min-w-0 flex-1">
+              <DropdownMenu>
+                <Tooltip>
+                  <TooltipTrigger asChild>
+                    <DropdownMenuTrigger asChild>
+                      <Button
+                        variant="ghost"
+                        size="xs"
+                        className="gap-0.5 text-accent-foreground border-0! h-6 px-1.5 min-w-0 max-w-[calc(100%-4rem)]"
+                        disabled={isStreaming || !hasModels}
+                      >
+                        {/* Name stays readable longest: the dimmed provider
+                            suffix carries a higher shrink factor so space
+                            pressure truncates it before the model name, and
+                            below 520px it drops out entirely (still shown in
+                            the tooltip and the dropdown) — a narrow sidebar
+                            has no room for both. */}
+                        <span className="flex min-w-0 items-center text-xs">
+                          <span className="truncate">{currentModelConfig?.name ?? "No models available"}</span>
+                          {currentModelConfig !== undefined && showProviderGroups && (
+                            <span className="shrink-[3] truncate text-muted-foreground max-[520px]:hidden">
+                              {" · "}{providerDisplayName(currentModelConfig.provider)}
+                            </span>
+                          )}
+                        </span>
+                        {hasModels && <IconChevronDown className="size-3.5 shrink-0" />}
+                      </Button>
+                    </DropdownMenuTrigger>
+                  </TooltipTrigger>
+                  <TooltipContent>{currentModelLabel}</TooltipContent>
+                </Tooltip>
+                <DropdownMenuContent className="w-52!" align="start">
+                  {modelGroups.map((group, groupIndex) => (
+                    <Fragment key={group.provider}>
+                      {showProviderGroups && <DropdownMenuLabel>{group.label}</DropdownMenuLabel>}
+                      {group.models.map((model) => (
+                        <DropdownMenuItem
+                          key={model.id}
+                          onClick={() => updateModel(model.id)}
+                          className={cn("text-xs px-3 py-1.5 cursor-pointer", currentModel === model.id && "bg-accent")}
+                        >
+                          {model.name}
+                        </DropdownMenuItem>
+                      ))}
+                      {showProviderGroups && groupIndex < modelGroups.length - 1 && <DropdownMenuSeparator />}
+                    </Fragment>
+                  ))}
+                </DropdownMenuContent>
+              </DropdownMenu>
+
+              <ThinkingButton
+                mode={thinkingMode}
+                effort={thinkingEffort}
+                efforts={currentModelConfig?.support_efforts}
+                alwaysOn={currentModelConfig?.capabilities.includes("always_thinking")}
+                disabled={isStreaming}
+                onToggle={toggleThinking}
+                onSelectEffort={selectThinkingEffort}
+              />
+              <PlanModeButton active={planMode} onToggle={handleTogglePlanMode} />
+            </div>
+
+            <div className="flex items-center gap-2 shrink-0">
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <Button variant="ghost" size="icon-xs" onClick={handleAddButtonClick} className="text-muted-foreground">
+                    <IconPlus className="size-3.5" />
+                  </Button>
+                </TooltipTrigger>
+                <TooltipContent>Add files or media</TooltipContent>
+              </Tooltip>
+
+              <ActionMenu onAuthAction={onAuthAction} />
+
+              {isStreaming ? (
+                <Button variant="destructive" size="icon-xs" onClick={abort}>
+                  <IconPlayerStop className="size-3.5" />
+                </Button>
+              ) : (
+                <Button variant="default" size="icon-xs" onClick={handleSend} disabled={!canSend}>
+                  <IconSend className="size-3.5" />
+                </Button>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+      <MediaPreviewModal src={previewMedia} onClose={() => setPreviewMedia(null)} />
+      <StreamingConfirmDialog
+        open={showPlanModeConfirm}
+        onOpenChange={setShowPlanModeConfirm}
+        title="Exit Plan Mode"
+        description="The agent is still working. Exiting plan mode now will affect the current turn. Are you sure you want to exit plan mode immediately?"
+        confirmLabel="Exit Now"
+        onConfirm={handleConfirmExitPlanMode}
+      />
+    </div>
+  );
+}
diff --git a/apps/vscode/webview-ui/src/components/inputarea/hooks/useClickOutside.ts b/apps/vscode/webview-ui/src/components/inputarea/hooks/useClickOutside.ts
new file mode 100644
index 000000000..fd8843000
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/inputarea/hooks/useClickOutside.ts
@@ -0,0 +1,20 @@
+import { useEffect, RefObject } from "react";
+
+export function useClickOutside(refs: RefObject<HTMLElement | null>[], isActive: boolean, onClickOutside: () => void): void {
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+
+    const handleClick = (e: MouseEvent) => {
+      const target = e.target as Node;
+      const isOutside = refs.every((ref) => ref.current && !ref.current.contains(target));
+      if (isOutside) {
+        onClickOutside();
+      }
+    };
+
+    document.addEventListener("mousedown", handleClick);
+    return () => document.removeEventListener("mousedown", handleClick);
+  }, [refs, isActive, onClickOutside]);
+}
diff --git a/apps/vscode/webview-ui/src/components/inputarea/hooks/useFilePicker.tsx b/apps/vscode/webview-ui/src/components/inputarea/hooks/useFilePicker.tsx
new file mode 100644
index 000000000..550577a7a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/inputarea/hooks/useFilePicker.tsx
@@ -0,0 +1,214 @@
+import { useMemo, useState, useEffect, useCallback } from "react";
+import { useRequest } from "ahooks";
+import { bridge } from "@/services";
+import { useChatStore } from "@/stores";
+import { MEDIA_CONFIG } from "@/services/config";
+
+export type FilePickerMode = "search" | "folder";
+
+export interface FileItem {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+}
+
+interface ActiveToken {
+  trigger: "/" | "@";
+  start: number;
+  query: string;
+}
+
+interface UseFilePickerResult {
+  showFileMenu: boolean;
+  filePickerMode: FilePickerMode;
+  folderPath: string;
+  fileItems: FileItem[];
+  selectedIndex: number;
+  isLoading: boolean;
+  showMediaOption: boolean;
+  fileMenuHeaderCount: number;
+  setSelectedIndex: (index: number) => void;
+  setFilePickerMode: (mode: FilePickerMode) => void;
+  setFolderPath: (path: string) => void;
+  handleFileMenuKey: (e: React.KeyboardEvent) => boolean;
+  resetFilePicker: () => void;
+}
+
+export function useFilePicker(activeToken: ActiveToken | null, onInsertFile: (path: string) => void, onPickMedia: () => void, onCancel: () => void): UseFilePickerResult {
+  const { isStreaming, draftMedia } = useChatStore();
+  const canAddMedia = !isStreaming && draftMedia.length < MEDIA_CONFIG.maxCount;
+
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [filePickerMode, setFilePickerMode] = useState<FilePickerMode>("search");
+  const [folderPath, setFolderPath] = useState("");
+
+  const showFileMenu = activeToken?.trigger === "@";
+  const query = activeToken?.query || "";
+
+  // 搜索文件 - query 变化时重新搜索
+  const { data: searchResults = [], loading: isSearchLoading } = useRequest(() => bridge.getProjectFiles({ query: query || undefined }), {
+    refreshDeps: [query],
+    debounceWait: 100,
+    ready: showFileMenu && filePickerMode === "search",
+  });
+
+  // 文件夹浏览
+  const { data: folderItems = [], loading: isFolderLoading, run: loadFolder } = useRequest((dir: string) => bridge.getProjectFiles({ directory: dir }), { manual: true });
+
+  useEffect(() => {
+    if (showFileMenu && filePickerMode === "folder") {
+      loadFolder(folderPath || ".");
+    }
+  }, [showFileMenu, filePickerMode, folderPath, loadFolder]);
+
+  useEffect(() => {
+    if (!showFileMenu) {
+      setFilePickerMode("search");
+      setFolderPath("");
+    }
+  }, [showFileMenu]);
+
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query, filePickerMode, folderPath]);
+
+  const fileItems = useMemo((): FileItem[] => {
+    if (filePickerMode === "folder") {
+      return folderItems.map((f) => ({
+        name: f.name,
+        path: f.path,
+        isDirectory: f.isDirectory,
+      }));
+    }
+    return searchResults.slice(0, 50).map((f) => ({
+      name: f.name,
+      path: f.path,
+      isDirectory: f.isDirectory,
+    }));
+  }, [filePickerMode, folderItems, searchResults]);
+
+  const isLoading = filePickerMode === "search" ? isSearchLoading : isFolderLoading;
+  const showMediaOption = filePickerMode === "search" && canAddMedia;
+  const fileMenuHeaderCount = filePickerMode === "search" ? (showMediaOption ? 2 : 1) : folderPath ? 2 : 1;
+
+  const resetFilePicker = useCallback(() => {
+    setSelectedIndex(0);
+    setFilePickerMode("search");
+    setFolderPath("");
+  }, []);
+
+  const handleFileMenuConfirm = useCallback(() => {
+    if (filePickerMode === "search") {
+      if (showMediaOption && selectedIndex === 0) {
+        onPickMedia();
+        return;
+      }
+
+      const browseIndex = showMediaOption ? 1 : 0;
+      if (selectedIndex === browseIndex) {
+        setFilePickerMode("folder");
+        setFolderPath("");
+        setSelectedIndex(0);
+        return;
+      }
+    }
+
+    if (filePickerMode === "folder" && selectedIndex === 0) {
+      setFilePickerMode("search");
+      setFolderPath("");
+      setSelectedIndex(0);
+      return;
+    }
+
+    if (filePickerMode === "folder" && selectedIndex === 1 && folderPath) {
+      setFolderPath(folderPath.split("/").slice(0, -1).join("/"));
+      setSelectedIndex(0);
+      return;
+    }
+
+    const itemIndex = selectedIndex - fileMenuHeaderCount;
+    const item = fileItems[itemIndex];
+    if (!item) return;
+
+    if (filePickerMode === "search" && item.isDirectory) {
+      setFilePickerMode("folder");
+      setFolderPath(item.path);
+      setSelectedIndex(0);
+    } else {
+      onInsertFile(item.path);
+    }
+  }, [filePickerMode, selectedIndex, showMediaOption, folderPath, fileMenuHeaderCount, fileItems, onPickMedia, onInsertFile]);
+
+  const handleFileMenuKey = useCallback(
+    (e: React.KeyboardEvent): boolean => {
+      if (!showFileMenu) return false;
+
+      const maxIdx = fileMenuHeaderCount + fileItems.length - 1;
+
+      switch (e.key) {
+        case "ArrowDown":
+          e.preventDefault();
+          setSelectedIndex((i) => Math.min(i + 1, maxIdx));
+          return true;
+        case "ArrowUp":
+          e.preventDefault();
+          setSelectedIndex((i) => Math.max(i - 1, 0));
+          return true;
+        case "ArrowLeft":
+          if (filePickerMode !== "folder") return false;
+          e.preventDefault();
+          if (folderPath) {
+            setFolderPath(folderPath.split("/").slice(0, -1).join("/"));
+          } else {
+            setFilePickerMode("search");
+          }
+          setSelectedIndex(0);
+          return true;
+        case "ArrowRight": {
+          if (filePickerMode !== "folder") return false;
+          e.preventDefault();
+          const itemForRight = fileItems[selectedIndex - fileMenuHeaderCount];
+          if (itemForRight?.isDirectory) {
+            setFolderPath(itemForRight.path);
+            setSelectedIndex(0);
+          }
+          return true;
+        }
+        case "Tab":
+        case "Enter":
+          e.preventDefault();
+          handleFileMenuConfirm();
+          return true;
+        case "Escape":
+          e.preventDefault();
+          if (filePickerMode === "folder") {
+            setFilePickerMode("search");
+            setFolderPath("");
+            setSelectedIndex(0);
+          } else {
+            onCancel();
+          }
+          return true;
+        default:
+          return false;
+      }
+    },
+    [showFileMenu, fileMenuHeaderCount, fileItems, filePickerMode, folderPath, selectedIndex, handleFileMenuConfirm, onCancel],
+  );
+
+  return {
+    showFileMenu,
+    filePickerMode,
+    folderPath,
+    fileItems,
+    selectedIndex,
+    isLoading,
+    showMediaOption,
+    fileMenuHeaderCount,
+    setSelectedIndex,
+    setFilePickerMode,
+    setFolderPath,
+    handleFileMenuKey,
+    resetFilePicker,
+  };
+}
diff --git a/apps/vscode/webview-ui/src/components/inputarea/hooks/useInputHistory.ts b/apps/vscode/webview-ui/src/components/inputarea/hooks/useInputHistory.ts
new file mode 100644
index 000000000..97cd504be
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/inputarea/hooks/useInputHistory.ts
@@ -0,0 +1,64 @@
+import { useState, useEffect, useCallback } from "react";
+import { bridge } from "@/services";
+
+interface UseInputHistoryOptions {
+  text: string;
+  setText: (text: string) => void;
+  onHeightChange?: () => void;
+}
+
+export function useInputHistory({ text, setText, onHeightChange }: UseInputHistoryOptions) {
+  const [history, setHistory] = useState<string[]>([]);
+  const [index, setIndex] = useState(-1);
+
+  useEffect(() => {
+    void bridge.getInputHistory().then(setHistory);
+  }, []);
+
+  const add = useCallback((input: string) => {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return;
+    }
+
+    void bridge.addInputHistory(trimmed);
+    setHistory((prev) => (prev[prev.length - 1] === trimmed ? prev : [...prev, trimmed]));
+    setIndex(-1);
+  }, []);
+
+  const handleKey = useCallback(
+    (e: React.KeyboardEvent): boolean => {
+      // Ignore if any modifier key is pressed
+      if (e.ctrlKey || e.metaKey || e.altKey) {
+        return false;
+      }
+
+      if (e.key === "ArrowUp" && history.length > 0 && (!text || index >= 0)) {
+        const newIndex = Math.min(index + 1, history.length - 1);
+        if (newIndex !== index) {
+          e.preventDefault();
+          setIndex(newIndex);
+          setText(history[history.length - 1 - newIndex]);
+          onHeightChange?.();
+          return true;
+        }
+      }
+
+      if (e.key === "ArrowDown" && index >= 0) {
+        e.preventDefault();
+        const newIndex = index - 1;
+        setIndex(newIndex);
+        setText(newIndex === -1 ? "" : history[history.length - 1 - newIndex]);
+        onHeightChange?.();
+        return true;
+      }
+
+      return false;
+    },
+    [history, index, text, setText, onHeightChange],
+  );
+
+  const reset = useCallback(() => setIndex(-1), []);
+
+  return { handleKey, add, reset };
+}
diff --git a/apps/vscode/webview-ui/src/components/inputarea/hooks/useMediaUpload.ts b/apps/vscode/webview-ui/src/components/inputarea/hooks/useMediaUpload.ts
new file mode 100644
index 000000000..bca84d942
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/inputarea/hooks/useMediaUpload.ts
@@ -0,0 +1,160 @@
+import { useCallback, useEffect } from "react";
+import { toast } from "@/components/ui/sonner";
+import { bridge } from "@/services";
+import { validateMediaFile, validateTotalSize, processMediaFile, getMediaType } from "@/lib/media-utils";
+import { useChatStore } from "@/stores";
+import { MEDIA_CONFIG } from "@/services/config";
+
+interface UseMediaUploadResult {
+  canAddMedia: boolean;
+  handlePaste: (e: React.ClipboardEvent) => void;
+  handlePickMedia: () => Promise<void>;
+  addMediaFiles: (files: File[]) => void;
+}
+
+export function useMediaUpload(): UseMediaUploadResult {
+  const { draftMedia, addDraftMedia, updateDraftMedia, removeDraftMedia } = useChatStore();
+
+  const hasProcessing = draftMedia.some((m) => !m.dataUri);
+  const canAddMedia = draftMedia.length < MEDIA_CONFIG.maxCount;
+
+  const getExistingDataUris = useCallback((): string[] => {
+    return draftMedia.filter((m) => m.dataUri).map((m) => m.dataUri!);
+  }, [draftMedia]);
+
+  const processFile = useCallback(
+    async (file: File) => {
+      const error = validateMediaFile(file, draftMedia.length);
+      if (error) {
+        toast.error(error.message);
+        return;
+      }
+
+      const id = crypto.randomUUID();
+      addDraftMedia(id);
+
+      try {
+        const dataUri = await processMediaFile(file);
+        const totalError = validateTotalSize(getExistingDataUris(), dataUri);
+        if (totalError) {
+          removeDraftMedia(id);
+          toast.error(totalError.message);
+          return;
+        }
+        updateDraftMedia(id, dataUri);
+      } catch {
+        removeDraftMedia(id);
+        toast.error("Failed to process media file");
+      }
+    },
+    [draftMedia.length, addDraftMedia, updateDraftMedia, removeDraftMedia, getExistingDataUris],
+  );
+
+  const addMediaFiles = useCallback(
+    (files: File[]) => {
+      for (const file of files) {
+        void processFile(file);
+      }
+    },
+    [processFile],
+  );
+
+  const handlePaste = useCallback(
+    (e: React.ClipboardEvent) => {
+      const items = e.clipboardData.items;
+      const mediaFiles: File[] = [];
+
+      for (const item of items) {
+        if (item.type.startsWith("image/") || item.type.startsWith("video/")) {
+          const file = item.getAsFile();
+          if (file) {
+            mediaFiles.push(file);
+          }
+        }
+      }
+
+      if (mediaFiles.length === 0) {
+        return;
+      }
+
+      e.preventDefault();
+      addMediaFiles(mediaFiles);
+    },
+    [addMediaFiles],
+  );
+
+  const handlePickMedia = useCallback(async () => {
+    if (hasProcessing || draftMedia.length >= MEDIA_CONFIG.maxCount) {
+      return;
+    }
+    const remaining = MEDIA_CONFIG.maxCount - draftMedia.length;
+    try {
+      const media = await bridge.pickMedia(remaining, true);
+      const existingUris = getExistingDataUris();
+
+      for (const dataUri of media) {
+        const totalError = validateTotalSize(existingUris, dataUri);
+        if (totalError) {
+          toast.error(totalError.message);
+          break;
+        }
+        existingUris.push(dataUri);
+        addDraftMedia(crypto.randomUUID(), dataUri);
+      }
+    } catch {
+      toast.error("Failed to pick media");
+    }
+  }, [hasProcessing, draftMedia.length, addDraftMedia, getExistingDataUris]);
+
+  useEffect(() => {
+    const isMediaFile = (file: File) => getMediaType(file) !== null;
+
+    const handleDocDragEnter = (e: DragEvent) => {
+      e.preventDefault();
+      e.stopPropagation();
+    };
+
+    const handleDocDragOver = (e: DragEvent) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (e.dataTransfer) {
+        e.dataTransfer.dropEffect = "copy";
+      }
+    };
+
+    const handleDocDrop = (e: DragEvent) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (hasProcessing) {
+        return;
+      }
+      if (draftMedia.length >= MEDIA_CONFIG.maxCount) {
+        toast.error(`Maximum ${MEDIA_CONFIG.maxCount} media files allowed`);
+        return;
+      }
+
+      const files = Array.from(e.dataTransfer?.files || []).filter(isMediaFile);
+      if (files.length === 0) {
+        return;
+      }
+      addMediaFiles(files);
+    };
+
+    document.addEventListener("dragenter", handleDocDragEnter);
+    document.addEventListener("dragover", handleDocDragOver);
+    document.addEventListener("drop", handleDocDrop);
+
+    return () => {
+      document.removeEventListener("dragenter", handleDocDragEnter);
+      document.removeEventListener("dragover", handleDocDragOver);
+      document.removeEventListener("drop", handleDocDrop);
+    };
+  }, [hasProcessing, draftMedia.length, addMediaFiles]);
+
+  return {
+    canAddMedia,
+    handlePaste,
+    handlePickMedia,
+    addMediaFiles,
+  };
+}
diff --git a/apps/vscode/webview-ui/src/components/inputarea/hooks/useSlashMenu.ts b/apps/vscode/webview-ui/src/components/inputarea/hooks/useSlashMenu.ts
new file mode 100644
index 000000000..c56619747
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/inputarea/hooks/useSlashMenu.ts
@@ -0,0 +1,113 @@
+import { useMemo, useState, useCallback } from "react";
+import { useSettingsStore } from "@/stores";
+import type { SlashCommandInfo } from "shared/legacy-sdk";
+
+interface ActiveToken {
+  trigger: "/" | "@";
+  start: number;
+  query: string;
+}
+
+function fuzzyMatch(text: string, query: string): boolean {
+  if (!query) {
+    return true;
+  }
+  const lowerText = text.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  let qi = 0;
+  for (let i = 0; i < lowerText.length && qi < lowerQuery.length; i++) {
+    if (lowerText[i] === lowerQuery[qi]) {
+      qi++;
+    }
+  }
+  return qi === lowerQuery.length;
+}
+
+export function findActiveToken(text: string, cursorPos: number): ActiveToken | null {
+  const beforeCursor = text.slice(0, cursorPos);
+  const lastSpace = Math.max(beforeCursor.lastIndexOf(" "), beforeCursor.lastIndexOf("\n"), beforeCursor.lastIndexOf("\t"), -1);
+  const currentWord = beforeCursor.slice(lastSpace + 1);
+
+  if (currentWord.startsWith("@")) {
+    return { trigger: "@", start: lastSpace + 1, query: currentWord.slice(1) };
+  }
+  if (currentWord.startsWith("/")) {
+    return { trigger: "/", start: lastSpace + 1, query: currentWord.slice(1) };
+  }
+  return null;
+}
+
+interface UseSlashMenuResult {
+  showSlashMenu: boolean;
+  filteredCommands: SlashCommandInfo[];
+  selectedIndex: number;
+  setSelectedIndex: (index: number) => void;
+  handleSlashMenuKey: (e: React.KeyboardEvent) => boolean;
+  resetSlashMenu: () => void;
+}
+
+export function useSlashMenu(activeToken: ActiveToken | null, onSelectCommand: (name: string) => void, onCancel: () => void): UseSlashMenuResult {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const { slashCommands } = useSettingsStore();
+
+  const showSlashMenu = activeToken?.trigger === "/";
+
+  const filteredCommands = useMemo(() => {
+    if (!showSlashMenu) {
+      return [];
+    }
+    const q = activeToken.query;
+    if (!q) {
+      return slashCommands;
+    }
+    return slashCommands.filter((cmd) => fuzzyMatch(cmd.name, q) || fuzzyMatch(cmd.description, q));
+  }, [showSlashMenu, activeToken?.query, slashCommands]);
+
+  const resetSlashMenu = useCallback(() => {
+    setSelectedIndex(0);
+  }, []);
+
+  const handleSlashMenuKey = useCallback(
+    (e: React.KeyboardEvent): boolean => {
+      if (!showSlashMenu || filteredCommands.length === 0) {
+        return false;
+      }
+
+      switch (e.key) {
+        case "ArrowDown":
+          e.preventDefault();
+          setSelectedIndex((i) => Math.min(i + 1, filteredCommands.length - 1));
+          return true;
+        case "ArrowUp":
+          e.preventDefault();
+          setSelectedIndex((i) => Math.max(i - 1, 0));
+          return true;
+        case "Tab":
+        case "Enter": {
+          e.preventDefault();
+          const cmd = filteredCommands[selectedIndex];
+          if (cmd) {
+            onSelectCommand(cmd.name);
+          }
+          return true;
+        }
+        case "Escape":
+          e.preventDefault();
+          onCancel();
+          return true;
+        default:
+          return false;
+      }
+    },
+    [showSlashMenu, filteredCommands, selectedIndex, onSelectCommand, onCancel],
+  );
+
+  return {
+    showSlashMenu,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    handleSlashMenuKey,
+    resetSlashMenu,
+  };
+}
diff --git a/apps/vscode/webview-ui/src/components/inputarea/utils.ts b/apps/vscode/webview-ui/src/components/inputarea/utils.ts
new file mode 100644
index 000000000..33e7cf834
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/inputarea/utils.ts
@@ -0,0 +1,28 @@
+interface InsertMentionParams {
+  text: string;
+  cursorPos: number;
+  filePath: string;
+  activeToken: { start: number } | null;
+  isAppend: boolean;
+}
+
+interface InsertMentionResult {
+  newText: string;
+  newCursorPos: number;
+}
+
+export function computeMentionInsert(params: InsertMentionParams): InsertMentionResult {
+  const { text, cursorPos, filePath, activeToken, isAppend } = params;
+
+  if (isAppend || !activeToken) {
+    const newText = text + `@${filePath} `;
+    return { newText, newCursorPos: newText.length };
+  }
+
+  const before = text.slice(0, activeToken.start);
+  const after = text.slice(cursorPos);
+  const newText = `${before}@${filePath} ${after}`;
+  const newCursorPos = activeToken.start + 1 + filePath.length + 1;
+
+  return { newText, newCursorPos };
+}
diff --git a/apps/vscode/webview-ui/src/components/ui/accordion.tsx b/apps/vscode/webview-ui/src/components/ui/accordion.tsx
new file mode 100644
index 000000000..0345ade68
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/accordion.tsx
@@ -0,0 +1,49 @@
+import * as React from "react";
+import { Accordion as AccordionPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+import { IconChevronDown, IconChevronUp } from "@tabler/icons-react";
+
+function Accordion({ className, ...props }: React.ComponentProps<typeof AccordionPrimitive.Root>) {
+  return <AccordionPrimitive.Root data-slot="accordion" className={cn("flex w-full flex-col", className)} {...props} />;
+}
+
+function AccordionItem({ className, ...props }: React.ComponentProps<typeof AccordionPrimitive.Item>) {
+  return <AccordionPrimitive.Item data-slot="accordion-item" className={cn("not-last:border-b", className)} {...props} />;
+}
+
+function AccordionTrigger({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Trigger>) {
+  return (
+    <AccordionPrimitive.Header className="flex">
+      <AccordionPrimitive.Trigger
+        data-slot="accordion-trigger"
+        className={cn(
+          "focus-visible:ring-ring/50 focus-visible:border-ring focus-visible:after:border-ring **:data-[slot=accordion-trigger-icon]:text-muted-foreground rounded-lg py-2.5 text-left text-sm font-medium hover:underline focus-visible:ring-[3px] **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 group/accordion-trigger relative flex flex-1 items-start justify-between border border-transparent transition-all outline-none disabled:pointer-events-none disabled:opacity-50",
+          className,
+        )}
+        {...props}
+      >
+        {children}
+        <IconChevronDown data-slot="accordion-trigger-icon" className="pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden" />
+        <IconChevronUp data-slot="accordion-trigger-icon" className="pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline" />
+      </AccordionPrimitive.Trigger>
+    </AccordionPrimitive.Header>
+  );
+}
+
+function AccordionContent({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Content>) {
+  return (
+    <AccordionPrimitive.Content data-slot="accordion-content" className="data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden" {...props}>
+      <div
+        className={cn(
+          "pt-0 pb-2.5 [&_a]:hover:text-foreground h-(--radix-accordion-content-height) [&_a]:underline [&_a]:underline-offset-3 [&_p:not(:last-child)]:mb-4",
+          className,
+        )}
+      >
+        {children}
+      </div>
+    </AccordionPrimitive.Content>
+  );
+}
+
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };
diff --git a/apps/vscode/webview-ui/src/components/ui/alert-dialog.tsx b/apps/vscode/webview-ui/src/components/ui/alert-dialog.tsx
new file mode 100644
index 000000000..42c0aea5f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/alert-dialog.tsx
@@ -0,0 +1,153 @@
+import * as React from "react";
+import { AlertDialog as AlertDialogPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+
+function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>) {
+  return <AlertDialogPrimitive.Root data-slot="alert-dialog" {...props} />;
+}
+
+function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>) {
+  return <AlertDialogPrimitive.Trigger data-slot="alert-dialog-trigger" {...props} />;
+}
+
+function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>) {
+  return <AlertDialogPrimitive.Portal data-slot="alert-dialog-portal" {...props} />;
+}
+
+function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>) {
+  return (
+    <AlertDialogPrimitive.Overlay
+      data-slot="alert-dialog-overlay"
+      className={cn(
+        "data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs fixed inset-0 z-50",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AlertDialogContent({
+  className,
+  size = "default",
+  ...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Content> & {
+  size?: "default" | "sm";
+}) {
+  return (
+    <AlertDialogPortal>
+      <AlertDialogOverlay />
+      <AlertDialogPrimitive.Content
+        data-slot="alert-dialog-content"
+        data-size={size}
+        className={cn(
+          "data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 bg-background ring-foreground/10 gap-4 rounded-xl p-4 ring-1 duration-100 data-[size=default]:max-w-xs data-[size=sm]:max-w-xs data-[size=default]:sm:max-w-sm group/alert-dialog-content fixed top-1/2 left-1/2 z-50 grid w-full -translate-x-1/2 -translate-y-1/2 outline-none",
+          className,
+        )}
+        {...props}
+      />
+    </AlertDialogPortal>
+  );
+}
+
+function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="alert-dialog-header"
+      className={cn(
+        "grid grid-rows-[auto_1fr] place-items-center gap-1.5 text-center has-data-[slot=alert-dialog-media]:grid-rows-[auto_auto_1fr] has-data-[slot=alert-dialog-media]:gap-x-4 sm:group-data-[size=default]/alert-dialog-content:place-items-start sm:group-data-[size=default]/alert-dialog-content:text-left sm:group-data-[size=default]/alert-dialog-content:has-data-[slot=alert-dialog-media]:grid-rows-[auto_1fr]",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="alert-dialog-footer"
+      className={cn(
+        "bg-muted/50 -mx-4 -mb-4 rounded-b-xl border-t p-4 flex flex-col-reverse gap-2 group-data-[size=sm]/alert-dialog-content:grid group-data-[size=sm]/alert-dialog-content:grid-cols-2 sm:flex-row sm:justify-end",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AlertDialogMedia({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="alert-dialog-media"
+      className={cn(
+        "bg-muted mb-2 inline-flex size-10 items-center justify-center rounded-md sm:group-data-[size=default]/alert-dialog-content:row-span-2 *:[svg:not([class*='size-'])]:size-6",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>) {
+  return (
+    <AlertDialogPrimitive.Title
+      data-slot="alert-dialog-title"
+      className={cn("text-sm font-medium sm:group-data-[size=default]/alert-dialog-content:group-has-data-[slot=alert-dialog-media]/alert-dialog-content:col-start-2", className)}
+      {...props}
+    />
+  );
+}
+
+function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>) {
+  return (
+    <AlertDialogPrimitive.Description
+      data-slot="alert-dialog-description"
+      className={cn("text-muted-foreground *:[a]:hover:text-foreground text-sm text-balance md:text-pretty *:[a]:underline *:[a]:underline-offset-3", className)}
+      {...props}
+    />
+  );
+}
+
+function AlertDialogAction({
+  className,
+  variant = "default",
+  size = "default",
+  ...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Action> & Pick<React.ComponentProps<typeof Button>, "variant" | "size">) {
+  return (
+    <Button variant={variant} size={size} asChild>
+      <AlertDialogPrimitive.Action data-slot="alert-dialog-action" className={cn(className)} {...props} />
+    </Button>
+  );
+}
+
+function AlertDialogCancel({
+  className,
+  variant = "outline",
+  size = "default",
+  ...props
+}: React.ComponentProps<typeof AlertDialogPrimitive.Cancel> & Pick<React.ComponentProps<typeof Button>, "variant" | "size">) {
+  return (
+    <Button variant={variant} size={size} asChild>
+      <AlertDialogPrimitive.Cancel data-slot="alert-dialog-cancel" className={cn(className)} {...props} />
+    </Button>
+  );
+}
+
+export {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogMedia,
+  AlertDialogOverlay,
+  AlertDialogPortal,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+};
diff --git a/apps/vscode/webview-ui/src/components/ui/badge.tsx b/apps/vscode/webview-ui/src/components/ui/badge.tsx
new file mode 100644
index 000000000..484b0254e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/badge.tsx
@@ -0,0 +1,33 @@
+import * as React from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+import { Slot } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+const badgeVariants = cva(
+  "h-5 gap-1 rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium transition-all has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&>svg]:size-3! inline-flex items-center justify-center w-fit whitespace-nowrap shrink-0 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-colors overflow-hidden group/badge",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        secondary: "bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80",
+        destructive:
+          "bg-destructive/10 [a]:hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 text-destructive dark:bg-destructive/20",
+        outline: "border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground",
+        ghost: "hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+function Badge({ className, variant = "default", asChild = false, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & { asChild?: boolean }) {
+  const Comp = asChild ? Slot.Root : "span";
+
+  return <Comp data-slot="badge" data-variant={variant} className={cn(badgeVariants({ variant }), className)} {...props} />;
+}
+
+export { Badge, badgeVariants };
diff --git a/apps/vscode/webview-ui/src/components/ui/button.tsx b/apps/vscode/webview-ui/src/components/ui/button.tsx
new file mode 100644
index 000000000..d3782a34b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/button.tsx
@@ -0,0 +1,54 @@
+import * as React from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+import { Slot } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+const buttonVariants = cva(
+  "focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 rounded-lg border border-transparent bg-clip-padding text-sm font-medium focus-visible:ring-[3px] aria-invalid:ring-[3px] [&_svg:not([class*='size-'])]:size-4 inline-flex items-center justify-center whitespace-nowrap transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none shrink-0 [&_svg]:shrink-0 outline-none group/button select-none",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        outline:
+          "border-border bg-background hover:bg-muted hover:text-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 aria-expanded:bg-muted aria-expanded:text-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+        ghost: "hover:bg-muted hover:text-foreground dark:hover:bg-muted/50 aria-expanded:bg-muted aria-expanded:text-foreground",
+        destructive:
+          "bg-destructive/10 hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/20 text-destructive focus-visible:border-destructive/40 dark:hover:bg-destructive/30",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default: "h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+        lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-3 has-data-[icon=inline-start]:pl-3",
+        icon: "size-8",
+        "icon-xs": "size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm": "size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+        "icon-lg": "size-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  },
+);
+
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  asChild = false,
+  ...props
+}: React.ComponentProps<"button"> &
+  VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+  }) {
+  const Comp = asChild ? Slot.Root : "button";
+
+  return <Comp data-slot="button" data-variant={variant} data-size={size} className={cn(buttonVariants({ variant, size, className }))} {...props} />;
+}
+
+export { Button, buttonVariants };
diff --git a/apps/vscode/webview-ui/src/components/ui/card.tsx b/apps/vscode/webview-ui/src/components/ui/card.tsx
new file mode 100644
index 000000000..b82b584fc
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/card.tsx
@@ -0,0 +1,52 @@
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Card({ className, size = "default", ...props }: React.ComponentProps<"div"> & { size?: "default" | "sm" }) {
+  return (
+    <div
+      data-slot="card"
+      data-size={size}
+      className={cn(
+        "ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-xl py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl group/card flex flex-col",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-header"
+      className={cn(
+        "gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="card-title" className={cn("text-base leading-snug font-medium group-data-[size=sm]/card:text-sm", className)} {...props} />;
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="card-description" className={cn("text-muted-foreground text-sm", className)} {...props} />;
+}
+
+function CardAction({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="card-action" className={cn("col-start-2 row-span-2 row-start-1 self-start justify-self-end", className)} {...props} />;
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="card-content" className={cn("px-4 group-data-[size=sm]/card:px-3", className)} {...props} />;
+}
+
+function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="card-footer" className={cn("bg-muted/50 rounded-b-xl border-t p-4 group-data-[size=sm]/card:p-3 flex items-center", className)} {...props} />;
+}
+
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent };
diff --git a/apps/vscode/webview-ui/src/components/ui/checkbox.tsx b/apps/vscode/webview-ui/src/components/ui/checkbox.tsx
new file mode 100644
index 000000000..e1d7411ee
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/checkbox.tsx
@@ -0,0 +1,24 @@
+import * as React from "react";
+import { Checkbox as CheckboxPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+import { IconCheck } from "@tabler/icons-react";
+
+function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>) {
+  return (
+    <CheckboxPrimitive.Root
+      data-slot="checkbox"
+      className={cn(
+        "border-input dark:bg-input/30 data-checked:bg-primary data-checked:text-primary-foreground dark:data-checked:bg-primary data-checked:border-primary aria-invalid:aria-checked:border-primary aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 flex size-4 items-center justify-center rounded-[4px] border transition-colors group-has-disabled/field:opacity-50 focus-visible:ring-[3px] aria-invalid:ring-[3px] peer relative shrink-0 outline-none after:absolute after:-inset-x-3 after:-inset-y-2 disabled:cursor-not-allowed disabled:opacity-50",
+        className,
+      )}
+      {...props}
+    >
+      <CheckboxPrimitive.Indicator data-slot="checkbox-indicator" className="[&>svg]:size-3.5 grid place-content-center text-current transition-none">
+        <IconCheck />
+      </CheckboxPrimitive.Indicator>
+    </CheckboxPrimitive.Root>
+  );
+}
+
+export { Checkbox };
diff --git a/apps/vscode/webview-ui/src/components/ui/combobox.tsx b/apps/vscode/webview-ui/src/components/ui/combobox.tsx
new file mode 100644
index 000000000..a29330bc4
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/combobox.tsx
@@ -0,0 +1,216 @@
+"use client";
+
+import * as React from "react";
+import { Combobox as ComboboxPrimitive } from "@base-ui/react";
+
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput } from "@/components/ui/input-group";
+import { IconChevronDown, IconX, IconCheck } from "@tabler/icons-react";
+
+const Combobox = ComboboxPrimitive.Root;
+
+function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props) {
+  return <ComboboxPrimitive.Value data-slot="combobox-value" {...props} />;
+}
+
+function ComboboxTrigger({ className, children, ...props }: ComboboxPrimitive.Trigger.Props) {
+  return (
+    <ComboboxPrimitive.Trigger data-slot="combobox-trigger" className={cn("[&_svg:not([class*='size-'])]:size-4", className)} {...props}>
+      {children}
+      <IconChevronDown className="text-muted-foreground size-4 pointer-events-none" />
+    </ComboboxPrimitive.Trigger>
+  );
+}
+
+function ComboboxClear({ className, ...props }: ComboboxPrimitive.Clear.Props) {
+  return (
+    <ComboboxPrimitive.Clear data-slot="combobox-clear" render={<InputGroupButton variant="ghost" size="icon-xs" />} className={cn(className)} {...props}>
+      <IconX className="pointer-events-none" />
+    </ComboboxPrimitive.Clear>
+  );
+}
+
+function ComboboxInput({
+  className,
+  children,
+  disabled = false,
+  showTrigger = true,
+  showClear = false,
+  ...props
+}: ComboboxPrimitive.Input.Props & {
+  showTrigger?: boolean;
+  showClear?: boolean;
+}) {
+  return (
+    <InputGroup className={cn("w-auto", className)}>
+      <ComboboxPrimitive.Input render={<InputGroupInput disabled={disabled} />} {...props} />
+      <InputGroupAddon align="inline-end">
+        {showTrigger && (
+          <InputGroupButton
+            size="icon-xs"
+            variant="ghost"
+            asChild
+            data-slot="input-group-button"
+            className="group-has-data-[slot=combobox-clear]/input-group:hidden data-pressed:bg-transparent"
+            disabled={disabled}
+          >
+            <ComboboxTrigger />
+          </InputGroupButton>
+        )}
+        {showClear && <ComboboxClear disabled={disabled} />}
+      </InputGroupAddon>
+      {children}
+    </InputGroup>
+  );
+}
+
+function ComboboxContent({
+  className,
+  side = "bottom",
+  sideOffset = 6,
+  align = "start",
+  alignOffset = 0,
+  anchor,
+  ...props
+}: ComboboxPrimitive.Popup.Props & Pick<ComboboxPrimitive.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor">) {
+  return (
+    <ComboboxPrimitive.Portal>
+      <ComboboxPrimitive.Positioner side={side} sideOffset={sideOffset} align={align} alignOffset={alignOffset} anchor={anchor} className="isolate z-50">
+        <ComboboxPrimitive.Popup
+          data-slot="combobox-content"
+          data-chips={!!anchor}
+          className={cn(
+            "bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 *:data-[slot=input-group]:bg-input/30 *:data-[slot=input-group]:border-input/30 max-h-72 min-w-36 overflow-hidden rounded-lg shadow-md ring-1 duration-100 *:data-[slot=input-group]:m-1 *:data-[slot=input-group]:mb-0 *:data-[slot=input-group]:h-8 *:data-[slot=input-group]:shadow-none group/combobox-content relative max-h-(--available-height) w-(--anchor-width) max-w-(--available-width) min-w-[calc(var(--anchor-width)+--spacing(7))] origin-(--transform-origin) data-[chips=true]:min-w-(--anchor-width)",
+            className,
+          )}
+          {...props}
+        />
+      </ComboboxPrimitive.Positioner>
+    </ComboboxPrimitive.Portal>
+  );
+}
+
+function ComboboxList({ className, ...props }: ComboboxPrimitive.List.Props) {
+  return (
+    <ComboboxPrimitive.List
+      data-slot="combobox-list"
+      className={cn(
+        "no-scrollbar max-h-[min(calc(--spacing(72)---spacing(9)),calc(var(--available-height)---spacing(9)))] scroll-py-1 overflow-y-auto p-1 data-empty:p-0 overflow-y-auto overscroll-contain",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function ComboboxItem({ className, children, ...props }: ComboboxPrimitive.Item.Props) {
+  return (
+    <ComboboxPrimitive.Item
+      data-slot="combobox-item"
+      className={cn(
+        "data-highlighted:bg-accent data-highlighted:text-accent-foreground not-data-[variant=destructive]:data-highlighted:**:text-accent-foreground gap-2 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 relative flex w-full cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <ComboboxPrimitive.ItemIndicator render={<span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />}>
+        <IconCheck className="pointer-events-none" />
+      </ComboboxPrimitive.ItemIndicator>
+    </ComboboxPrimitive.Item>
+  );
+}
+
+function ComboboxGroup({ className, ...props }: ComboboxPrimitive.Group.Props) {
+  return <ComboboxPrimitive.Group data-slot="combobox-group" className={cn(className)} {...props} />;
+}
+
+function ComboboxLabel({ className, ...props }: ComboboxPrimitive.GroupLabel.Props) {
+  return <ComboboxPrimitive.GroupLabel data-slot="combobox-label" className={cn("text-muted-foreground px-2 py-1.5 text-xs", className)} {...props} />;
+}
+
+function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props) {
+  return <ComboboxPrimitive.Collection data-slot="combobox-collection" {...props} />;
+}
+
+function ComboboxEmpty({ className, ...props }: ComboboxPrimitive.Empty.Props) {
+  return (
+    <ComboboxPrimitive.Empty
+      data-slot="combobox-empty"
+      className={cn("text-muted-foreground hidden w-full justify-center py-2 text-center text-sm group-data-empty/combobox-content:flex", className)}
+      {...props}
+    />
+  );
+}
+
+function ComboboxSeparator({ className, ...props }: ComboboxPrimitive.Separator.Props) {
+  return <ComboboxPrimitive.Separator data-slot="combobox-separator" className={cn("bg-border -mx-1 my-1 h-px", className)} {...props} />;
+}
+
+function ComboboxChips({ className, ...props }: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> & ComboboxPrimitive.Chips.Props) {
+  return (
+    <ComboboxPrimitive.Chips
+      data-slot="combobox-chips"
+      className={cn(
+        "dark:bg-input/30 border-input focus-within:border-ring focus-within:ring-ring/50 has-aria-invalid:ring-destructive/20 dark:has-aria-invalid:ring-destructive/40 has-aria-invalid:border-destructive dark:has-aria-invalid:border-destructive/50 flex min-h-8 flex-wrap items-center gap-1 rounded-lg border bg-transparent bg-clip-padding px-2.5 py-1 text-sm transition-colors focus-within:ring-[3px] has-aria-invalid:ring-[3px] has-data-[slot=combobox-chip]:px-1",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function ComboboxChip({
+  className,
+  children,
+  showRemove = true,
+  ...props
+}: ComboboxPrimitive.Chip.Props & {
+  showRemove?: boolean;
+}) {
+  return (
+    <ComboboxPrimitive.Chip
+      data-slot="combobox-chip"
+      className={cn(
+        "bg-muted text-foreground flex h-[calc(--spacing(5.25))] w-fit items-center justify-center gap-1 rounded-sm px-1.5 text-xs font-medium whitespace-nowrap has-data-[slot=combobox-chip-remove]:pr-0 has-disabled:pointer-events-none has-disabled:cursor-not-allowed has-disabled:opacity-50",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      {showRemove && (
+        <ComboboxPrimitive.ChipRemove render={<Button variant="ghost" size="icon-xs" />} className="-ml-1 opacity-50 hover:opacity-100" data-slot="combobox-chip-remove">
+          <IconX className="pointer-events-none" />
+        </ComboboxPrimitive.ChipRemove>
+      )}
+    </ComboboxPrimitive.Chip>
+  );
+}
+
+function ComboboxChipsInput({ className, ...props }: ComboboxPrimitive.Input.Props) {
+  return <ComboboxPrimitive.Input data-slot="combobox-chip-input" className={cn("min-w-16 flex-1 outline-none", className)} {...props} />;
+}
+
+function useComboboxAnchor() {
+  return React.useRef<HTMLDivElement | null>(null);
+}
+
+export {
+  Combobox,
+  ComboboxInput,
+  ComboboxContent,
+  ComboboxList,
+  ComboboxItem,
+  ComboboxGroup,
+  ComboboxLabel,
+  ComboboxCollection,
+  ComboboxEmpty,
+  ComboboxSeparator,
+  ComboboxChips,
+  ComboboxChip,
+  ComboboxChipsInput,
+  ComboboxTrigger,
+  ComboboxValue,
+  useComboboxAnchor,
+};
diff --git a/apps/vscode/webview-ui/src/components/ui/command.tsx b/apps/vscode/webview-ui/src/components/ui/command.tsx
new file mode 100644
index 000000000..c4af18bcb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/command.tsx
@@ -0,0 +1,109 @@
+"use client";
+
+import * as React from "react";
+import { Command as CommandPrimitive } from "cmdk";
+
+import { cn } from "@/lib/utils";
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { InputGroup, InputGroupAddon } from "@/components/ui/input-group";
+import { IconSearch, IconCheck } from "@tabler/icons-react";
+
+function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>) {
+  return (
+    <CommandPrimitive data-slot="command" className={cn("bg-popover text-popover-foreground rounded-xl! p-1 flex size-full flex-col overflow-hidden", className)} {...props} />
+  );
+}
+
+function CommandDialog({
+  title = "Command Palette",
+  description = "Search for a command to run...",
+  children,
+  className,
+  showCloseButton = false,
+  ...props
+}: React.ComponentProps<typeof Dialog> & {
+  title?: string;
+  description?: string;
+  className?: string;
+  showCloseButton?: boolean;
+}) {
+  return (
+    <Dialog {...props}>
+      <DialogHeader className="sr-only">
+        <DialogTitle>{title}</DialogTitle>
+        <DialogDescription>{description}</DialogDescription>
+      </DialogHeader>
+      <DialogContent className={cn("rounded-xl! overflow-hidden p-0", className)} showCloseButton={showCloseButton}>
+        {children}
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function CommandInput({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Input>) {
+  return (
+    <div data-slot="command-input-wrapper" className="p-1 pb-0">
+      <InputGroup className="bg-input/30 border-input/30 h-8! rounded-lg! shadow-none! *:data-[slot=input-group-addon]:pl-2!">
+        <CommandPrimitive.Input data-slot="command-input" className={cn("w-full text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50", className)} {...props} />
+        <InputGroupAddon>
+          <IconSearch className="size-4 shrink-0 opacity-50" />
+        </InputGroupAddon>
+      </InputGroup>
+    </div>
+  );
+}
+
+function CommandList({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.List>) {
+  return (
+    <CommandPrimitive.List data-slot="command-list" className={cn("no-scrollbar max-h-72 scroll-py-1 outline-none overflow-x-hidden overflow-y-auto", className)} {...props} />
+  );
+}
+
+function CommandEmpty({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Empty>) {
+  return <CommandPrimitive.Empty data-slot="command-empty" className={cn("py-6 text-center text-sm", className)} {...props} />;
+}
+
+function CommandGroup({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Group>) {
+  return (
+    <CommandPrimitive.Group
+      data-slot="command-group"
+      className={cn(
+        "text-foreground [&_[cmdk-group-heading]]:text-muted-foreground overflow-hidden p-1 [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function CommandSeparator({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Separator>) {
+  return <CommandPrimitive.Separator data-slot="command-separator" className={cn("bg-border -mx-1 h-px", className)} {...props} />;
+}
+
+function CommandItem({ className, children, ...props }: React.ComponentProps<typeof CommandPrimitive.Item>) {
+  return (
+    <CommandPrimitive.Item
+      data-slot="command-item"
+      className={cn(
+        "data-selected:bg-muted data-selected:text-foreground data-selected:*:[svg]:text-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none [&_svg:not([class*='size-'])]:size-4 [[data-slot=dialog-content]_&]:rounded-lg! group/command-item data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <IconCheck className="ml-auto opacity-0 group-has-[[data-slot=command-shortcut]]/command-item:hidden group-data-[checked=true]/command-item:opacity-100" />
+    </CommandPrimitive.Item>
+  );
+}
+
+function CommandShortcut({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      data-slot="command-shortcut"
+      className={cn("text-muted-foreground group-data-selected/command-item:text-foreground ml-auto text-xs tracking-widest", className)}
+      {...props}
+    />
+  );
+}
+
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator };
diff --git a/apps/vscode/webview-ui/src/components/ui/context-menu.tsx b/apps/vscode/webview-ui/src/components/ui/context-menu.tsx
new file mode 100644
index 000000000..79c389574
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/context-menu.tsx
@@ -0,0 +1,201 @@
+"use client";
+
+import * as React from "react";
+import { ContextMenu as ContextMenuPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+import { IconChevronRight, IconCheck } from "@tabler/icons-react";
+
+function ContextMenu({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Root>) {
+  return <ContextMenuPrimitive.Root data-slot="context-menu" {...props} />;
+}
+
+function ContextMenuTrigger({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Trigger>) {
+  return <ContextMenuPrimitive.Trigger data-slot="context-menu-trigger" className={cn("select-none", className)} {...props} />;
+}
+
+function ContextMenuGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Group>) {
+  return <ContextMenuPrimitive.Group data-slot="context-menu-group" {...props} />;
+}
+
+function ContextMenuPortal({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Portal>) {
+  return <ContextMenuPrimitive.Portal data-slot="context-menu-portal" {...props} />;
+}
+
+function ContextMenuSub({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Sub>) {
+  return <ContextMenuPrimitive.Sub data-slot="context-menu-sub" {...props} />;
+}
+
+function ContextMenuRadioGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>) {
+  return <ContextMenuPrimitive.RadioGroup data-slot="context-menu-radio-group" {...props} />;
+}
+
+function ContextMenuContent({
+  className,
+  ...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Content> & {
+  side?: "top" | "right" | "bottom" | "left";
+}) {
+  return (
+    <ContextMenuPrimitive.Portal>
+      <ContextMenuPrimitive.Content
+        data-slot="context-menu-content"
+        className={cn(
+          "data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 bg-popover text-popover-foreground min-w-36 rounded-lg p-1 shadow-md ring-1 duration-100 z-50 max-h-(--radix-context-menu-content-available-height) origin-(--radix-context-menu-content-transform-origin) overflow-x-hidden overflow-y-auto",
+          className,
+        )}
+        {...props}
+      />
+    </ContextMenuPrimitive.Portal>
+  );
+}
+
+function ContextMenuItem({
+  className,
+  inset,
+  variant = "default",
+  ...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Item> & {
+  inset?: boolean;
+  variant?: "default" | "destructive";
+}) {
+  return (
+    <ContextMenuPrimitive.Item
+      data-slot="context-menu-item"
+      data-inset={inset}
+      data-variant={variant}
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:text-destructive focus:*:[svg]:text-accent-foreground gap-1.5 rounded-md px-1.5 py-1 text-sm [&_svg:not([class*='size-'])]:size-4 group/context-menu-item relative flex cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function ContextMenuSubTrigger({
+  className,
+  inset,
+  children,
+  ...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
+  inset?: boolean;
+}) {
+  return (
+    <ContextMenuPrimitive.SubTrigger
+      data-slot="context-menu-sub-trigger"
+      data-inset={inset}
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground gap-1.5 rounded-md px-1.5 py-1 text-sm [&_svg:not([class*='size-'])]:size-4 flex cursor-default items-center outline-hidden select-none data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <IconChevronRight className="ml-auto" />
+    </ContextMenuPrimitive.SubTrigger>
+  );
+}
+
+function ContextMenuSubContent({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.SubContent>) {
+  return (
+    <ContextMenuPrimitive.SubContent
+      data-slot="context-menu-sub-content"
+      className={cn(
+        "data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 bg-popover text-popover-foreground min-w-32 rounded-lg border p-1 shadow-lg duration-100 z-50 origin-(--radix-context-menu-content-transform-origin) overflow-hidden",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function ContextMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>) {
+  return (
+    <ContextMenuPrimitive.CheckboxItem
+      data-slot="context-menu-checkbox-item"
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      checked={checked}
+      {...props}
+    >
+      <span className="absolute right-2 pointer-events-none">
+        <ContextMenuPrimitive.ItemIndicator>
+          <IconCheck />
+        </ContextMenuPrimitive.ItemIndicator>
+      </span>
+      {children}
+    </ContextMenuPrimitive.CheckboxItem>
+  );
+}
+
+function ContextMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioItem>) {
+  return (
+    <ContextMenuPrimitive.RadioItem
+      data-slot="context-menu-radio-item"
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      <span className="absolute right-2 pointer-events-none">
+        <ContextMenuPrimitive.ItemIndicator>
+          <IconCheck />
+        </ContextMenuPrimitive.ItemIndicator>
+      </span>
+      {children}
+    </ContextMenuPrimitive.RadioItem>
+  );
+}
+
+function ContextMenuLabel({
+  className,
+  inset,
+  ...props
+}: React.ComponentProps<typeof ContextMenuPrimitive.Label> & {
+  inset?: boolean;
+}) {
+  return (
+    <ContextMenuPrimitive.Label
+      data-slot="context-menu-label"
+      data-inset={inset}
+      className={cn("text-muted-foreground px-1.5 py-1 text-xs font-medium data-[inset]:pl-8", className)}
+      {...props}
+    />
+  );
+}
+
+function ContextMenuSeparator({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Separator>) {
+  return <ContextMenuPrimitive.Separator data-slot="context-menu-separator" className={cn("bg-border -mx-1 my-1 h-px", className)} {...props} />;
+}
+
+function ContextMenuShortcut({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      data-slot="context-menu-shortcut"
+      className={cn("text-muted-foreground group-focus/context-menu-item:text-accent-foreground ml-auto text-xs tracking-widest", className)}
+      {...props}
+    />
+  );
+}
+
+export {
+  ContextMenu,
+  ContextMenuTrigger,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuCheckboxItem,
+  ContextMenuRadioItem,
+  ContextMenuLabel,
+  ContextMenuSeparator,
+  ContextMenuShortcut,
+  ContextMenuGroup,
+  ContextMenuPortal,
+  ContextMenuSub,
+  ContextMenuSubContent,
+  ContextMenuSubTrigger,
+  ContextMenuRadioGroup,
+};
diff --git a/apps/vscode/webview-ui/src/components/ui/dialog.tsx b/apps/vscode/webview-ui/src/components/ui/dialog.tsx
new file mode 100644
index 000000000..66f00a5a1
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/dialog.tsx
@@ -0,0 +1,110 @@
+"use client";
+
+import * as React from "react";
+import { Dialog as DialogPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { IconX } from "@tabler/icons-react";
+
+function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>) {
+  return <DialogPrimitive.Root data-slot="dialog" {...props} />;
+}
+
+function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
+  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
+}
+
+function DialogPortal({ ...props }: React.ComponentProps<typeof DialogPrimitive.Portal>) {
+  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
+}
+
+function DialogClose({ ...props }: React.ComponentProps<typeof DialogPrimitive.Close>) {
+  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
+}
+
+function DialogOverlay({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
+  return (
+    <DialogPrimitive.Overlay
+      data-slot="dialog-overlay"
+      className={cn(
+        "data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs fixed inset-0 isolate z-50",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function DialogContent({
+  className,
+  children,
+  showCloseButton = true,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Content> & {
+  showCloseButton?: boolean;
+}) {
+  return (
+    <DialogPortal>
+      <DialogOverlay />
+      <DialogPrimitive.Content
+        data-slot="dialog-content"
+        className={cn(
+          "bg-background data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 ring-foreground/10 grid max-w-[calc(100%-2rem)] gap-4 rounded-xl p-4 text-sm ring-1 duration-100 sm:max-w-sm fixed top-1/2 left-1/2 z-50 w-full -translate-x-1/2 -translate-y-1/2",
+          className,
+        )}
+        {...props}
+      >
+        {children}
+        {showCloseButton && (
+          <DialogPrimitive.Close data-slot="dialog-close" asChild>
+            <Button variant="ghost" className="absolute top-2 right-2" size="icon-sm">
+              <IconX />
+              <span className="sr-only">Close</span>
+            </Button>
+          </DialogPrimitive.Close>
+        )}
+      </DialogPrimitive.Content>
+    </DialogPortal>
+  );
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="dialog-header" className={cn("gap-2 flex flex-col", className)} {...props} />;
+}
+
+function DialogFooter({
+  className,
+  showCloseButton = false,
+  children,
+  ...props
+}: React.ComponentProps<"div"> & {
+  showCloseButton?: boolean;
+}) {
+  return (
+    <div data-slot="dialog-footer" className={cn("bg-muted/50 -mx-4 -mb-4 rounded-b-xl border-t p-4 flex flex-col-reverse gap-2 sm:flex-row sm:justify-end", className)} {...props}>
+      {children}
+      {showCloseButton && (
+        <DialogPrimitive.Close asChild>
+          <Button variant="outline">Close</Button>
+        </DialogPrimitive.Close>
+      )}
+    </div>
+  );
+}
+
+function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>) {
+  return <DialogPrimitive.Title data-slot="dialog-title" className={cn("text-sm leading-none font-medium", className)} {...props} />;
+}
+
+function DialogDescription({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Description>) {
+  return (
+    <DialogPrimitive.Description
+      data-slot="dialog-description"
+      className={cn("text-muted-foreground *:[a]:hover:text-foreground text-sm *:[a]:underline *:[a]:underline-offset-3", className)}
+      {...props}
+    />
+  );
+}
+
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger };
diff --git a/apps/vscode/webview-ui/src/components/ui/dropdown-menu.tsx b/apps/vscode/webview-ui/src/components/ui/dropdown-menu.tsx
new file mode 100644
index 000000000..1831e4690
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/dropdown-menu.tsx
@@ -0,0 +1,196 @@
+import * as React from "react";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+import { IconCheck, IconChevronRight } from "@tabler/icons-react";
+
+function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>) {
+  return <DropdownMenuPrimitive.Root data-slot="dropdown-menu" {...props} />;
+}
+
+function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>) {
+  return <DropdownMenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />;
+}
+
+function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>) {
+  return <DropdownMenuPrimitive.Trigger data-slot="dropdown-menu-trigger" {...props} />;
+}
+
+function DropdownMenuContent({ className, align = "start", sideOffset = 4, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>) {
+  return (
+    <DropdownMenuPrimitive.Portal>
+      <DropdownMenuPrimitive.Content
+        data-slot="dropdown-menu-content"
+        sideOffset={sideOffset}
+        align={align}
+        className={cn(
+          "data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 bg-popover text-popover-foreground min-w-32 rounded-lg p-1 shadow-md ring-1 duration-100 z-50 max-h-(--radix-dropdown-menu-content-available-height) w-(--radix-dropdown-menu-trigger-width) origin-(--radix-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto data-[state=closed]:overflow-hidden",
+          className,
+        )}
+        {...props}
+      />
+    </DropdownMenuPrimitive.Portal>
+  );
+}
+
+function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>) {
+  return <DropdownMenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />;
+}
+
+function DropdownMenuItem({
+  className,
+  inset,
+  variant = "default",
+  ...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+  inset?: boolean;
+  variant?: "default" | "destructive";
+}) {
+  return (
+    <DropdownMenuPrimitive.Item
+      data-slot="dropdown-menu-item"
+      data-inset={inset}
+      data-variant={variant}
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:text-destructive not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md px-1.5 py-1 text-sm [&_svg:not([class*='size-'])]:size-4 group/dropdown-menu-item relative flex cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>) {
+  return (
+    <DropdownMenuPrimitive.CheckboxItem
+      data-slot="dropdown-menu-checkbox-item"
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      checked={checked}
+      {...props}
+    >
+      <span className="pointer-events-none absolute right-2 flex items-center justify-center pointer-events-none" data-slot="dropdown-menu-checkbox-item-indicator">
+        <DropdownMenuPrimitive.ItemIndicator>
+          <IconCheck />
+        </DropdownMenuPrimitive.ItemIndicator>
+      </span>
+      {children}
+    </DropdownMenuPrimitive.CheckboxItem>
+  );
+}
+
+function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>) {
+  return <DropdownMenuPrimitive.RadioGroup data-slot="dropdown-menu-radio-group" {...props} />;
+}
+
+function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>) {
+  return (
+    <DropdownMenuPrimitive.RadioItem
+      data-slot="dropdown-menu-radio-item"
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      <span className="pointer-events-none absolute right-2 flex items-center justify-center pointer-events-none" data-slot="dropdown-menu-radio-item-indicator">
+        <DropdownMenuPrimitive.ItemIndicator>
+          <IconCheck />
+        </DropdownMenuPrimitive.ItemIndicator>
+      </span>
+      {children}
+    </DropdownMenuPrimitive.RadioItem>
+  );
+}
+
+function DropdownMenuLabel({
+  className,
+  inset,
+  ...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+  inset?: boolean;
+}) {
+  return (
+    <DropdownMenuPrimitive.Label
+      data-slot="dropdown-menu-label"
+      data-inset={inset}
+      className={cn("text-muted-foreground px-1.5 py-1 text-xs font-medium data-[inset]:pl-8", className)}
+      {...props}
+    />
+  );
+}
+
+function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>) {
+  return <DropdownMenuPrimitive.Separator data-slot="dropdown-menu-separator" className={cn("bg-border -mx-1 my-1 h-px", className)} {...props} />;
+}
+
+function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      data-slot="dropdown-menu-shortcut"
+      className={cn("text-muted-foreground group-focus/dropdown-menu-item:text-accent-foreground ml-auto text-xs tracking-widest", className)}
+      {...props}
+    />
+  );
+}
+
+function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>) {
+  return <DropdownMenuPrimitive.Sub data-slot="dropdown-menu-sub" {...props} />;
+}
+
+function DropdownMenuSubTrigger({
+  className,
+  inset,
+  children,
+  ...props
+}: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+  inset?: boolean;
+}) {
+  return (
+    <DropdownMenuPrimitive.SubTrigger
+      data-slot="dropdown-menu-sub-trigger"
+      data-inset={inset}
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md px-1.5 py-1 text-sm [&_svg:not([class*='size-'])]:size-4 flex cursor-default items-center outline-hidden select-none data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <IconChevronRight className="ml-auto" />
+    </DropdownMenuPrimitive.SubTrigger>
+  );
+}
+
+function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>) {
+  return (
+    <DropdownMenuPrimitive.SubContent
+      data-slot="dropdown-menu-sub-content"
+      className={cn(
+        "data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 bg-popover text-popover-foreground min-w-24 rounded-md p-1 shadow-lg ring-1 duration-100 z-50 origin-(--radix-dropdown-menu-content-transform-origin) overflow-hidden",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export {
+  DropdownMenu,
+  DropdownMenuPortal,
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuGroup,
+  DropdownMenuLabel,
+  DropdownMenuItem,
+  DropdownMenuCheckboxItem,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuSub,
+  DropdownMenuSubTrigger,
+  DropdownMenuSubContent,
+};
diff --git a/apps/vscode/webview-ui/src/components/ui/field.tsx b/apps/vscode/webview-ui/src/components/ui/field.tsx
new file mode 100644
index 000000000..c0f75afc3
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/field.tsx
@@ -0,0 +1,153 @@
+import { useMemo } from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+import { Label } from "@/components/ui/label";
+import { Separator } from "@/components/ui/separator";
+
+function FieldSet({ className, ...props }: React.ComponentProps<"fieldset">) {
+  return (
+    <fieldset data-slot="field-set" className={cn("gap-4 has-[>[data-slot=checkbox-group]]:gap-3 has-[>[data-slot=radio-group]]:gap-3 flex flex-col", className)} {...props} />
+  );
+}
+
+function FieldLegend({ className, variant = "legend", ...props }: React.ComponentProps<"legend"> & { variant?: "legend" | "label" }) {
+  return (
+    <legend
+      data-slot="field-legend"
+      data-variant={variant}
+      className={cn("mb-1.5 font-medium data-[variant=label]:text-sm data-[variant=legend]:text-base", className)}
+      {...props}
+    />
+  );
+}
+
+function FieldGroup({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="field-group"
+      className={cn("gap-5 data-[slot=checkbox-group]:gap-3 [&>[data-slot=field-group]]:gap-4 group/field-group @container/field-group flex w-full flex-col", className)}
+      {...props}
+    />
+  );
+}
+
+const fieldVariants = cva("data-[invalid=true]:text-destructive gap-2 group/field flex w-full", {
+  variants: {
+    orientation: {
+      vertical: "flex-col [&>*]:w-full [&>.sr-only]:w-auto",
+      horizontal:
+        "flex-row items-center [&>[data-slot=field-label]]:flex-auto has-[>[data-slot=field-content]]:items-start has-[>[data-slot=field-content]]:[&>[role=checkbox],[role=radio]]:mt-px",
+      responsive:
+        "flex-col [&>*]:w-full [&>.sr-only]:w-auto @md/field-group:flex-row @md/field-group:items-center @md/field-group:[&>*]:w-auto @md/field-group:[&>[data-slot=field-label]]:flex-auto @md/field-group:has-[>[data-slot=field-content]]:items-start @md/field-group:has-[>[data-slot=field-content]]:[&>[role=checkbox],[role=radio]]:mt-px",
+    },
+  },
+  defaultVariants: {
+    orientation: "vertical",
+  },
+});
+
+function Field({ className, orientation = "vertical", ...props }: React.ComponentProps<"div"> & VariantProps<typeof fieldVariants>) {
+  return <div role="group" data-slot="field" data-orientation={orientation} className={cn(fieldVariants({ orientation }), className)} {...props} />;
+}
+
+function FieldContent({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="field-content" className={cn("gap-0.5 group/field-content flex flex-1 flex-col leading-snug", className)} {...props} />;
+}
+
+function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>) {
+  return (
+    <Label
+      data-slot="field-label"
+      className={cn(
+        "has-data-checked:bg-primary/5 has-data-checked:border-primary dark:has-data-checked:bg-primary/10 gap-2 group-data-[disabled=true]/field:opacity-50 has-[>[data-slot=field]]:rounded-lg has-[>[data-slot=field]]:border [&>*]:data-[slot=field]:p-2.5 group/field-label peer/field-label flex w-fit leading-snug",
+        "has-[>[data-slot=field]]:w-full has-[>[data-slot=field]]:flex-col",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function FieldTitle({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="field-label"
+      className={cn("gap-2 text-sm font-medium group-data-[disabled=true]/field:opacity-50 flex w-fit items-center leading-snug", className)}
+      {...props}
+    />
+  );
+}
+
+function FieldDescription({ className, ...props }: React.ComponentProps<"p">) {
+  return (
+    <p
+      data-slot="field-description"
+      className={cn(
+        "text-muted-foreground text-left text-sm [[data-variant=legend]+&]:-mt-1.5 leading-normal font-normal group-has-[[data-orientation=horizontal]]/field:text-balance",
+        "last:mt-0 nth-last-2:-mt-1",
+        "[&>a:hover]:text-primary [&>a]:underline [&>a]:underline-offset-4",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function FieldSeparator({
+  children,
+  className,
+  ...props
+}: React.ComponentProps<"div"> & {
+  children?: React.ReactNode;
+}) {
+  return (
+    <div data-slot="field-separator" data-content={!!children} className={cn("-my-2 h-5 text-sm group-data-[variant=outline]/field-group:-mb-2 relative", className)} {...props}>
+      <Separator className="absolute inset-0 top-1/2" />
+      {children && (
+        <span className="text-muted-foreground px-2 bg-background relative mx-auto block w-fit" data-slot="field-separator-content">
+          {children}
+        </span>
+      )}
+    </div>
+  );
+}
+
+function FieldError({
+  className,
+  children,
+  errors,
+  ...props
+}: React.ComponentProps<"div"> & {
+  errors?: Array<{ message?: string } | undefined>;
+}) {
+  const content = useMemo(() => {
+    if (children) {
+      return children;
+    }
+
+    if (!errors?.length) {
+      return null;
+    }
+
+    const uniqueErrors = [...new Map(errors.map((error) => [error?.message, error])).values()];
+
+    if (uniqueErrors?.length === 1) {
+      return uniqueErrors[0]?.message;
+    }
+
+    return <ul className="ml-4 flex list-disc flex-col gap-1">{uniqueErrors.map((error, index) => error?.message && <li key={index}>{error.message}</li>)}</ul>;
+  }, [children, errors]);
+
+  if (!content) {
+    return null;
+  }
+
+  return (
+    <div role="alert" data-slot="field-error" className={cn("text-destructive text-sm font-normal", className)} {...props}>
+      {content}
+    </div>
+  );
+}
+
+export { Field, FieldLabel, FieldDescription, FieldError, FieldGroup, FieldLegend, FieldSeparator, FieldSet, FieldContent, FieldTitle };
diff --git a/apps/vscode/webview-ui/src/components/ui/input-group.tsx b/apps/vscode/webview-ui/src/components/ui/input-group.tsx
new file mode 100644
index 000000000..0fe2975a8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/input-group.tsx
@@ -0,0 +1,114 @@
+"use client";
+
+import * as React from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+
+function InputGroup({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="input-group"
+      role="group"
+      className={cn(
+        "border-input dark:bg-input/30 has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[[data-slot][aria-invalid=true]]:border-destructive dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40 has-disabled:bg-input/50 dark:has-disabled:bg-input/80 h-8 rounded-lg border transition-colors has-disabled:opacity-50 has-[[data-slot=input-group-control]:focus-visible]:ring-[3px] has-[[data-slot][aria-invalid=true]]:ring-[3px] has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>[data-align=block-end]]:[&>input]:pt-3 has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=inline-end]]:[&>input]:pr-1.5 has-[>[data-align=inline-start]]:[&>input]:pl-1.5 [[data-slot=combobox-content]_&]:focus-within:border-inherit [[data-slot=combobox-content]_&]:focus-within:ring-0 group/input-group relative flex w-full min-w-0 items-center outline-none has-[>textarea]:h-auto",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+const inputGroupAddonVariants = cva(
+  "text-muted-foreground h-auto gap-2 py-1.5 text-sm font-medium group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4 flex cursor-text items-center justify-center select-none",
+  {
+    variants: {
+      align: {
+        "inline-start": "pl-2 has-[>button]:ml-[-0.3rem] has-[>kbd]:ml-[-0.15rem] order-first",
+        "inline-end": "pr-2 has-[>button]:mr-[-0.3rem] has-[>kbd]:mr-[-0.15rem] order-last",
+        "block-start": "px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2 order-first w-full justify-start",
+        "block-end": "px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2 order-last w-full justify-start",
+      },
+    },
+    defaultVariants: {
+      align: "inline-start",
+    },
+  },
+);
+
+function InputGroupAddon({ className, align = "inline-start", ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
+  return (
+    <div
+      role="group"
+      data-slot="input-group-addon"
+      data-align={align}
+      className={cn(inputGroupAddonVariants({ align }), className)}
+      onClick={(e) => {
+        if ((e.target as HTMLElement).closest("button")) {
+          return;
+        }
+        e.currentTarget.parentElement?.querySelector("input")?.focus();
+      }}
+      {...props}
+    />
+  );
+}
+
+const inputGroupButtonVariants = cva("gap-2 text-sm shadow-none flex items-center", {
+  variants: {
+    size: {
+      xs: "h-6 gap-1 rounded-[calc(var(--radius)-3px)] px-1.5 [&>svg:not([class*='size-'])]:size-3.5",
+      sm: "",
+      "icon-xs": "size-6 rounded-[calc(var(--radius)-3px)] p-0 has-[>svg]:p-0",
+      "icon-sm": "size-8 p-0 has-[>svg]:p-0",
+    },
+  },
+  defaultVariants: {
+    size: "xs",
+  },
+});
+
+function InputGroupButton({
+  className,
+  type = "button",
+  variant = "ghost",
+  size = "xs",
+  ...props
+}: Omit<React.ComponentProps<typeof Button>, "size"> & VariantProps<typeof inputGroupButtonVariants>) {
+  return <Button type={type} data-size={size} variant={variant} className={cn(inputGroupButtonVariants({ size }), className)} {...props} />;
+}
+
+function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
+  return <span className={cn("text-muted-foreground gap-2 text-sm [&_svg:not([class*='size-'])]:size-4 flex items-center [&_svg]:pointer-events-none", className)} {...props} />;
+}
+
+function InputGroupInput({ className, ...props }: React.ComponentProps<"input">) {
+  return (
+    <Input
+      data-slot="input-group-control"
+      className={cn(
+        "rounded-none border-0 bg-transparent shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent flex-1",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">) {
+  return (
+    <Textarea
+      data-slot="input-group-control"
+      className={cn(
+        "rounded-none border-0 bg-transparent py-2 shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent flex-1 resize-none",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea };
diff --git a/apps/vscode/webview-ui/src/components/ui/input.tsx b/apps/vscode/webview-ui/src/components/ui/input.tsx
new file mode 100644
index 000000000..bcc9491ae
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/input.tsx
@@ -0,0 +1,19 @@
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+  return (
+    <input
+      type={type}
+      data-slot="input"
+      className={cn(
+        "dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-[3px] aria-invalid:ring-[3px] md:text-sm file:text-foreground placeholder:text-muted-foreground w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Input };
diff --git a/apps/vscode/webview-ui/src/components/ui/label.tsx b/apps/vscode/webview-ui/src/components/ui/label.tsx
new file mode 100644
index 000000000..5c66c69d0
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/label.tsx
@@ -0,0 +1,21 @@
+"use client";
+
+import * as React from "react";
+import { Label as LabelPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>) {
+  return (
+    <LabelPrimitive.Root
+      data-slot="label"
+      className={cn(
+        "gap-2 text-sm leading-none font-medium group-data-[disabled=true]:opacity-50 peer-disabled:opacity-50 flex items-center select-none group-data-[disabled=true]:pointer-events-none peer-disabled:cursor-not-allowed",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Label };
diff --git a/apps/vscode/webview-ui/src/components/ui/popover.tsx b/apps/vscode/webview-ui/src/components/ui/popover.tsx
new file mode 100644
index 000000000..b2f24521b
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/popover.tsx
@@ -0,0 +1,47 @@
+import * as React from "react";
+import { Popover as PopoverPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>) {
+  return <PopoverPrimitive.Root data-slot="popover" {...props} />;
+}
+
+function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>) {
+  return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />;
+}
+
+function PopoverContent({ className, align = "center", sideOffset = 4, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>) {
+  return (
+    <PopoverPrimitive.Portal>
+      <PopoverPrimitive.Content
+        data-slot="popover-content"
+        align={align}
+        sideOffset={sideOffset}
+        className={cn(
+          "bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 flex flex-col gap-2.5 rounded-lg p-2.5 text-sm shadow-md ring-1 duration-100 z-50 w-72 origin-(--radix-popover-content-transform-origin) outline-hidden",
+          className,
+        )}
+        {...props}
+      />
+    </PopoverPrimitive.Portal>
+  );
+}
+
+function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>) {
+  return <PopoverPrimitive.Anchor data-slot="popover-anchor" {...props} />;
+}
+
+function PopoverHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return <div data-slot="popover-header" className={cn("flex flex-col gap-0.5 text-sm", className)} {...props} />;
+}
+
+function PopoverTitle({ className, ...props }: React.ComponentProps<"h2">) {
+  return <div data-slot="popover-title" className={cn("font-medium", className)} {...props} />;
+}
+
+function PopoverDescription({ className, ...props }: React.ComponentProps<"p">) {
+  return <p data-slot="popover-description" className={cn("text-muted-foreground", className)} {...props} />;
+}
+
+export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger };
diff --git a/apps/vscode/webview-ui/src/components/ui/scroll-area.tsx b/apps/vscode/webview-ui/src/components/ui/scroll-area.tsx
new file mode 100644
index 000000000..33a559ad0
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/scroll-area.tsx
@@ -0,0 +1,40 @@
+"use client";
+
+import * as React from "react";
+import { ScrollArea as ScrollAreaPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+function ScrollArea({ className, children, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.Root>) {
+  return (
+    <ScrollAreaPrimitive.Root data-slot="scroll-area" className={cn("relative", className)} {...props}>
+      <ScrollAreaPrimitive.Viewport
+        data-slot="scroll-area-viewport"
+        className="focus-visible:ring-ring/50 size-full rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:outline-1"
+      >
+        {children}
+      </ScrollAreaPrimitive.Viewport>
+      <ScrollBar />
+      <ScrollAreaPrimitive.Corner />
+    </ScrollAreaPrimitive.Root>
+  );
+}
+
+function ScrollBar({ className, orientation = "vertical", ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>) {
+  return (
+    <ScrollAreaPrimitive.ScrollAreaScrollbar
+      data-slot="scroll-area-scrollbar"
+      data-orientation={orientation}
+      orientation={orientation}
+      className={cn(
+        "data-horizontal:h-2.5 data-horizontal:flex-col data-horizontal:border-t data-horizontal:border-t-transparent data-vertical:h-full data-vertical:w-2.5 data-vertical:border-l data-vertical:border-l-transparent flex touch-none p-px transition-colors select-none",
+        className,
+      )}
+      {...props}
+    >
+      <ScrollAreaPrimitive.ScrollAreaThumb data-slot="scroll-area-thumb" className="rounded-full bg-border relative flex-1" />
+    </ScrollAreaPrimitive.ScrollAreaScrollbar>
+  );
+}
+
+export { ScrollArea, ScrollBar };
diff --git a/apps/vscode/webview-ui/src/components/ui/select.tsx b/apps/vscode/webview-ui/src/components/ui/select.tsx
new file mode 100644
index 000000000..a5769f7de
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/select.tsx
@@ -0,0 +1,129 @@
+"use client";
+
+import * as React from "react";
+import { Select as SelectPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+import { IconSelector, IconCheck, IconChevronUp, IconChevronDown } from "@tabler/icons-react";
+
+function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>) {
+  return <SelectPrimitive.Root data-slot="select" {...props} />;
+}
+
+function SelectGroup({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Group>) {
+  return <SelectPrimitive.Group data-slot="select-group" className={cn("scroll-my-1 p-1", className)} {...props} />;
+}
+
+function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>) {
+  return <SelectPrimitive.Value data-slot="select-value" {...props} />;
+}
+
+function SelectTrigger({
+  className,
+  size = "default",
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+  size?: "sm" | "default";
+}) {
+  return (
+    <SelectPrimitive.Trigger
+      data-slot="select-trigger"
+      data-size={size}
+      className={cn(
+        "border-input data-[placeholder]:text-muted-foreground dark:bg-input/30 dark:hover:bg-input/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 gap-1.5 rounded-lg border bg-transparent py-2 pr-2 pl-2.5 text-sm transition-colors select-none focus-visible:ring-[3px] aria-invalid:ring-[3px] data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:flex *:data-[slot=select-value]:gap-1.5 [&_svg:not([class*='size-'])]:size-4 flex w-fit items-center justify-between whitespace-nowrap outline-none disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <SelectPrimitive.Icon asChild>
+        <IconSelector className="text-muted-foreground size-4 pointer-events-none" />
+      </SelectPrimitive.Icon>
+    </SelectPrimitive.Trigger>
+  );
+}
+
+function SelectContent({ className, children, position = "item-aligned", align = "center", ...props }: React.ComponentProps<typeof SelectPrimitive.Content>) {
+  return (
+    <SelectPrimitive.Portal>
+      <SelectPrimitive.Content
+        data-slot="select-content"
+        className={cn(
+          "bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 relative z-50 max-h-(--radix-select-content-available-height) origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto",
+          position === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+          className,
+        )}
+        position={position}
+        align={align}
+        {...props}
+      >
+        <SelectScrollUpButton />
+        <SelectPrimitive.Viewport
+          data-position={position}
+          className={cn(
+            "data-[position=popper]:h-[var(--radix-select-trigger-height)] data-[position=popper]:w-full data-[position=popper]:min-w-[var(--radix-select-trigger-width)]",
+            position === "popper" && "",
+          )}
+        >
+          {children}
+        </SelectPrimitive.Viewport>
+        <SelectScrollDownButton />
+      </SelectPrimitive.Content>
+    </SelectPrimitive.Portal>
+  );
+}
+
+function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>) {
+  return <SelectPrimitive.Label data-slot="select-label" className={cn("text-muted-foreground px-1.5 py-1 text-xs", className)} {...props} />;
+}
+
+function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>) {
+  return (
+    <SelectPrimitive.Item
+      data-slot="select-item"
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2 relative flex w-full cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        className,
+      )}
+      {...props}
+    >
+      <span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center">
+        <SelectPrimitive.ItemIndicator>
+          <IconCheck className="pointer-events-none" />
+        </SelectPrimitive.ItemIndicator>
+      </span>
+      <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+    </SelectPrimitive.Item>
+  );
+}
+
+function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>) {
+  return <SelectPrimitive.Separator data-slot="select-separator" className={cn("bg-border -mx-1 my-1 h-px pointer-events-none", className)} {...props} />;
+}
+
+function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>) {
+  return (
+    <SelectPrimitive.ScrollUpButton
+      data-slot="select-scroll-up-button"
+      className={cn("bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*='size-'])]:size-4", className)}
+      {...props}
+    >
+      <IconChevronUp />
+    </SelectPrimitive.ScrollUpButton>
+  );
+}
+
+function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>) {
+  return (
+    <SelectPrimitive.ScrollDownButton
+      data-slot="select-scroll-down-button"
+      className={cn("bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*='size-'])]:size-4", className)}
+      {...props}
+    >
+      <IconChevronDown />
+    </SelectPrimitive.ScrollDownButton>
+  );
+}
+
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue };
diff --git a/apps/vscode/webview-ui/src/components/ui/separator.tsx b/apps/vscode/webview-ui/src/components/ui/separator.tsx
new file mode 100644
index 000000000..8f6691c73
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/separator.tsx
@@ -0,0 +1,21 @@
+import * as React from "react";
+import { Separator as SeparatorPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+function Separator({ className, orientation = "horizontal", decorative = true, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
+  return (
+    <SeparatorPrimitive.Root
+      data-slot="separator"
+      decorative={decorative}
+      orientation={orientation}
+      className={cn(
+        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:w-px data-[orientation=vertical]:self-stretch",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Separator };
diff --git a/apps/vscode/webview-ui/src/components/ui/sonner.tsx b/apps/vscode/webview-ui/src/components/ui/sonner.tsx
new file mode 100644
index 000000000..2591ccfeb
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/sonner.tsx
@@ -0,0 +1,23 @@
+import { Toaster as Sonner, toast } from "sonner";
+
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+
+function Toaster({ ...props }: ToasterProps) {
+  return (
+    <Sonner
+      className="toaster group"
+      toastOptions={{
+        classNames: {
+          toast: "group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg",
+          description: "group-[.toast]:text-muted-foreground",
+          actionButton: "group-[.toast]:bg-primary group-[.toast]:text-primary-foreground",
+          cancelButton: "group-[.toast]:bg-muted group-[.toast]:text-muted-foreground",
+          error: "group-[.toaster]:bg-destructive group-[.toaster]:text-white group-[.toaster]:border-destructive",
+        },
+      }}
+      {...props}
+    />
+  );
+}
+
+export { Toaster, toast };
diff --git a/apps/vscode/webview-ui/src/components/ui/switch.tsx b/apps/vscode/webview-ui/src/components/ui/switch.tsx
new file mode 100644
index 000000000..788cb0523
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/switch.tsx
@@ -0,0 +1,38 @@
+import * as React from "react";
+import { Switch as SwitchPrimitive } from "radix-ui";
+import { cn } from "@/lib/utils";
+
+function Switch({
+  className,
+  size = "default",
+  variant = "default",
+  ...props
+}: React.ComponentProps<typeof SwitchPrimitive.Root> & {
+  size?: "sm" | "default";
+  variant?: "default" | "blue";
+}) {
+  return (
+    <SwitchPrimitive.Root
+      data-slot="switch"
+      data-size={size}
+      className={cn(
+        // base
+        "data-unchecked:bg-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 dark:data-unchecked:bg-input/80 shrink-0 rounded-full border border-transparent focus-visible:ring-[3px] aria-invalid:ring-[3px] data-[size=default]:h-[18.4px] data-[size=default]:w-[32px] data-[size=sm]:h-[14px] data-[size=sm]:w-[24px] peer group/switch relative inline-flex items-center transition-all outline-none after:absolute after:-inset-x-3 after:-inset-y-2 data-disabled:cursor-not-allowed data-disabled:opacity-50",
+
+        // variants
+        variant === "default" && "data-checked:bg-primary",
+        variant === "blue" && "data-checked:bg-blue-400",
+
+        className,
+      )}
+      {...props}
+    >
+      <SwitchPrimitive.Thumb
+        data-slot="switch-thumb"
+        className="bg-background dark:data-unchecked:bg-foreground dark:data-checked:bg-primary-foreground rounded-full group-data-[size=default]/switch:size-4 group-data-[size=sm]/switch:size-3 group-data-[size=default]/switch:data-checked:translate-x-[calc(100%-2px)] group-data-[size=sm]/switch:data-checked:translate-x-[calc(100%-2px)] group-data-[size=default]/switch:data-unchecked:translate-x-0 group-data-[size=sm]/switch:data-unchecked:translate-x-0 pointer-events-none block ring-0 transition-transform"
+      />
+    </SwitchPrimitive.Root>
+  );
+}
+
+export { Switch };
diff --git a/apps/vscode/webview-ui/src/components/ui/tabs.tsx b/apps/vscode/webview-ui/src/components/ui/tabs.tsx
new file mode 100644
index 000000000..21e6f6343
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/tabs.tsx
@@ -0,0 +1,54 @@
+"use client";
+
+import * as React from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+import { Tabs as TabsPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+function Tabs({ className, orientation = "horizontal", ...props }: React.ComponentProps<typeof TabsPrimitive.Root>) {
+  return (
+    <TabsPrimitive.Root data-slot="tabs" data-orientation={orientation} className={cn("gap-2 group/tabs flex data-[orientation=horizontal]:flex-col", className)} {...props} />
+  );
+}
+
+const tabsListVariants = cva(
+  "rounded-lg p-[3px] group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list text-muted-foreground inline-flex w-fit items-center justify-center group-data-[orientation=vertical]/tabs:h-fit group-data-[orientation=vertical]/tabs:flex-col",
+  {
+    variants: {
+      variant: {
+        default: "bg-muted",
+        line: "gap-1 bg-transparent",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+function TabsList({ className, variant = "default", ...props }: React.ComponentProps<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>) {
+  return <TabsPrimitive.List data-slot="tabs-list" data-variant={variant} className={cn(tabsListVariants({ variant }), className)} {...props} />;
+}
+
+function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>) {
+  return (
+    <TabsPrimitive.Trigger
+      data-slot="tabs-trigger"
+      className={cn(
+        "gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*='size-'])]:size-4 focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:outline-ring text-foreground/60 hover:text-foreground dark:text-muted-foreground dark:hover:text-foreground relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap transition-all group-data-[orientation=vertical]/tabs:w-full group-data-[orientation=vertical]/tabs:justify-start focus-visible:ring-[3px] focus-visible:outline-1 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        "group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent",
+        "data-active:bg-background dark:data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 data-active:text-foreground",
+        "after:bg-foreground after:absolute after:opacity-0 after:transition-opacity group-data-[orientation=horizontal]/tabs:after:inset-x-0 group-data-[orientation=horizontal]/tabs:after:bottom-[-5px] group-data-[orientation=horizontal]/tabs:after:h-0.5 group-data-[orientation=vertical]/tabs:after:inset-y-0 group-data-[orientation=vertical]/tabs:after:-right-1 group-data-[orientation=vertical]/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>) {
+  return <TabsPrimitive.Content data-slot="tabs-content" className={cn("text-sm flex-1 outline-none", className)} {...props} />;
+}
+
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };
diff --git a/apps/vscode/webview-ui/src/components/ui/textarea.tsx b/apps/vscode/webview-ui/src/components/ui/textarea.tsx
new file mode 100644
index 000000000..85af792c9
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/textarea.tsx
@@ -0,0 +1,18 @@
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
+  return (
+    <textarea
+      data-slot="textarea"
+      className={cn(
+        "border-input dark:bg-input/30 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 rounded-lg border bg-transparent px-2.5 py-2 text-base transition-colors focus-visible:ring-[1px] aria-invalid:ring-[1px] md:text-sm placeholder:text-muted-foreground flex field-sizing-content min-h-16 w-full outline-none disabled:cursor-not-allowed disabled:opacity-50",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Textarea };
diff --git a/apps/vscode/webview-ui/src/components/ui/tooltip.tsx b/apps/vscode/webview-ui/src/components/ui/tooltip.tsx
new file mode 100644
index 000000000..60bfc572a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/components/ui/tooltip.tsx
@@ -0,0 +1,41 @@
+import * as React from "react";
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+
+import { cn } from "@/lib/utils";
+
+function TooltipProvider({ delayDuration = 0, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>) {
+  return <TooltipPrimitive.Provider data-slot="tooltip-provider" delayDuration={delayDuration} {...props} />;
+}
+
+function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>) {
+  return (
+    <TooltipProvider>
+      <TooltipPrimitive.Root data-slot="tooltip" {...props} />
+    </TooltipProvider>
+  );
+}
+
+function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
+  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
+}
+
+function TooltipContent({ className, sideOffset = 0, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>) {
+  return (
+    <TooltipPrimitive.Portal>
+      <TooltipPrimitive.Content
+        data-slot="tooltip-content"
+        sideOffset={sideOffset}
+        className={cn(
+          "data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 rounded-md px-3 py-1.5 text-xs bg-foreground text-background z-50 w-fit max-w-xs origin-(--radix-tooltip-content-transform-origin)",
+          className,
+        )}
+        {...props}
+      >
+        {children}
+        <TooltipPrimitive.Arrow className="size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground z-50 translate-y-[calc(-50%_-_2px)]" />
+      </TooltipPrimitive.Content>
+    </TooltipPrimitive.Portal>
+  );
+}
+
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };
diff --git a/apps/vscode/webview-ui/src/hooks/useAppInit.ts b/apps/vscode/webview-ui/src/hooks/useAppInit.ts
new file mode 100644
index 000000000..f23f2d530
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useAppInit.ts
@@ -0,0 +1,111 @@
+import { useState, useEffect, useCallback } from "react";
+import { bridge, Events } from "@/services";
+import { requiresManagedProviderLogin, useSettingsStore } from "@/stores";
+import type { ExtensionConfig } from "shared/types";
+
+export type AppStatus = "loading" | "no-workspace" | "runtime-error" | "not-logged-in" | "no-models" | "ready";
+
+export interface AppInitState {
+  status: AppStatus;
+  errorMessage: string | null;
+  modelsCount: number;
+  refresh: () => void;
+}
+
+export function useAppInit(): AppInitState {
+  const [state, setState] = useState<Omit<AppInitState, "refresh">>({
+    status: "loading",
+    errorMessage: null,
+    modelsCount: 0,
+  });
+  const [initKey, setInitKey] = useState(0);
+  const { initModels, setExtensionConfig, setMCPServers, setWireSlashCommands, setIsLoggedIn, setWorkspaceRoot } = useSettingsStore();
+
+  const refresh = useCallback(() => {
+    setState({ status: "loading", errorMessage: null, modelsCount: 0 });
+    setInitKey((k) => k + 1);
+  }, []);
+
+  useEffect(() => {
+    return bridge.on<{ config: ExtensionConfig; changedKeys: string[] }>(Events.ExtensionConfigChanged, ({ config }) => {
+      setExtensionConfig(config);
+    });
+  }, [setExtensionConfig, refresh]);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function init() {
+      try {
+        const workspace = await bridge.checkWorkspace();
+        if (cancelled) {
+          return;
+        }
+
+        if (!workspace.hasWorkspace) {
+          setState({ status: "no-workspace", errorMessage: null, modelsCount: 0 });
+          return;
+        }
+
+        setWorkspaceRoot(workspace.workspaceRoot ?? workspace.path ?? null);
+
+        const [extensionConfig, mcpServers, slashCommands] = await Promise.all([
+          bridge.getExtensionConfig(),
+          bridge.getMCPServers(),
+          bridge.getSlashCommands(),
+        ]);
+        if (cancelled) {
+          return;
+        }
+
+        setExtensionConfig(extensionConfig);
+        setMCPServers(mcpServers);
+        setWireSlashCommands(slashCommands);
+
+        const [loginStatus, kimiConfig] = await Promise.all([bridge.checkLoginStatus(), bridge.getModels()]);
+        if (cancelled) {
+          return;
+        }
+
+        console.log("[AppInit] Login status:", loginStatus, "kimiConfig:", kimiConfig);
+
+        setIsLoggedIn(loginStatus.loggedIn);
+        initModels(kimiConfig.models, kimiConfig.defaultModel, kimiConfig.defaultThinking, kimiConfig.defaultThinkingEffort);
+
+        const modelsCount = kimiConfig.models?.length ?? 0;
+
+        if (modelsCount === 0 && !loginStatus.loggedIn) {
+          setState({ status: "not-logged-in", errorMessage: null, modelsCount });
+          return;
+        }
+
+        if (modelsCount === 0) {
+          setState({ status: "no-models", errorMessage: null, modelsCount: 0 });
+          return;
+        }
+
+        if (requiresManagedProviderLogin(kimiConfig.models, kimiConfig.defaultModel, loginStatus.loggedIn)) {
+          setState({ status: "not-logged-in", errorMessage: null, modelsCount });
+          return;
+        }
+
+        setState({ status: "ready", errorMessage: null, modelsCount });
+      } catch (err) {
+        if (!cancelled) {
+          setState({
+            status: "runtime-error",
+            errorMessage: err instanceof Error ? err.message : "Failed to initialize",
+            modelsCount: 0,
+          });
+        }
+      }
+    }
+
+    void init();
+    return () => {
+      cancelled = true;
+    };
+  }, [initKey, initModels, setExtensionConfig, setMCPServers, setWireSlashCommands, setIsLoggedIn]);
+
+  return { ...state, refresh };
+}
diff --git a/apps/vscode/webview-ui/src/hooks/useWelcomeHint.tsx b/apps/vscode/webview-ui/src/hooks/useWelcomeHint.tsx
new file mode 100644
index 000000000..a75631282
--- /dev/null
+++ b/apps/vscode/webview-ui/src/hooks/useWelcomeHint.tsx
@@ -0,0 +1,131 @@
+import { useState, useEffect, useMemo } from "react";
+import { bridge } from "@/services";
+
+export interface WelcomeHint {
+  title: string;
+  description: string;
+  slashCommand?: string;
+  component?: React.ReactNode;
+}
+
+function ShortcutRow({ kbd, children }: { kbd: string; children: React.ReactNode }) {
+  return (
+    <div className="flex justify-between items-start gap-3">
+      <kbd className="kbd shrink-0">{kbd}</kbd>
+      <span className="text-right">{children}</span>
+    </div>
+  );
+}
+
+function ShortcutGuide() {
+  return (
+    <div className="text-left text-xs mt-2 space-y-5 w-full max-w-96">
+      <div>
+        <div className="font-medium text-foreground mb-1.5">⚡ Commands</div>
+        <div className="text-muted-foreground space-y-1">
+          <ShortcutRow kbd="/">View all commands</ShortcutRow>
+          <ShortcutRow kbd="/init">Scan project and generate AGENTS.md file</ShortcutRow>
+          <ShortcutRow kbd="/compact">Trim context so that I focus on the essentials</ShortcutRow>
+        </div>
+      </div>
+      <div>
+        <div className="font-medium text-foreground mb-1.5">💡 Tips</div>
+        <div className="text-muted-foreground space-y-1">
+          <ShortcutRow kbd="↑">Browse input history</ShortcutRow>
+          <ShortcutRow kbd="@">Add/Search files to reference</ShortcutRow>
+          <ShortcutRow kbd="Alt+K">Add selected code directly from editor</ShortcutRow>
+        </div>
+      </div>
+      <div>
+        <div className="font-medium text-foreground mb-1.5">🚀 Pro Tips</div>
+        <div className="text-muted-foreground space-y-1">
+          <div>• Use YOLO mode to auto-approve tool calls</div>
+          <div>• AGENTS.md helps me understand your codebase</div>
+          <div>• Enable Thinking for complex tasks</div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+const HINT_FIRST_TIME: WelcomeHint = {
+  title: "Quick Start Guide",
+  description: "",
+  component: <ShortcutGuide />,
+};
+
+const HINT_AGENT_MD: WelcomeHint = {
+  title: "Let me map your codebase",
+  description: "Run /init to scan the project and generate docs",
+  slashCommand: "/init",
+};
+
+const HINTS_POOL: WelcomeHint[] = [
+  HINT_FIRST_TIME,
+  HINT_AGENT_MD,
+  {
+    title: "Reference specific code",
+    description: "Type @ to select files, or press Alt+K with code highlighted",
+  },
+  {
+    title: "See what I can do",
+    description: "Type / for all commands—like /compact to trim context",
+  },
+  {
+    title: "Need deeper analysis?",
+    description: "Enable thinking mode for complex architecture or debugging",
+  },
+  {
+    title: "More than code",
+    description: "Paste a screenshot or design and I'll help implement it",
+  },
+  {
+    title: "Add more tools",
+    description: "Connect external services via MCP servers in settings",
+  },
+  {
+    title: "Prefer fewer interruptions?",
+    description: "Enable YOLO mode to auto-approve",
+  },
+  {
+    title: "Context getting long?",
+    description: "Type /compact to keep only the essentials",
+    slashCommand: "/compact",
+  },
+];
+
+function pickRandom<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function withProbability(p: number): boolean {
+  return Math.random() < p;
+}
+
+export function useWelcomeHint(): WelcomeHint {
+  const [hasAgentMd, setHasAgentMd] = useState<boolean | null>(null);
+  const [hasHistory, setHasHistory] = useState<boolean | null>(null);
+
+  useEffect(() => {
+    bridge
+      .checkFileExists("AGENT.md")
+      .then(setHasAgentMd)
+      .catch(() => setHasAgentMd(false));
+    bridge
+      .getKimiSessions()
+      .then((s) => setHasHistory(s.length > 0))
+      .catch(() => setHasHistory(false));
+  }, []);
+
+  return useMemo(() => {
+    // First time user: show shortcut guide
+    if (hasHistory === false) {
+      return HINT_FIRST_TIME;
+    }
+    // 30% chance to show AGENT.md hint if missing
+    if (hasAgentMd === false && withProbability(0.3)) {
+      return HINT_AGENT_MD;
+    }
+    return pickRandom(HINTS_POOL);
+  }, [hasAgentMd, hasHistory]);
+}
diff --git a/apps/vscode/webview-ui/src/lib/content.ts b/apps/vscode/webview-ui/src/lib/content.ts
new file mode 100644
index 000000000..bf63eab04
--- /dev/null
+++ b/apps/vscode/webview-ui/src/lib/content.ts
@@ -0,0 +1,59 @@
+import type { ContentPart } from "shared/legacy-sdk";
+import { cleanSystemTags } from "shared/utils";
+import { getMediaTypeFromDataUri } from "./media-utils";
+
+export const Content = {
+  getText(input: string | ContentPart[]): string {
+    if (typeof input === "string") {
+      return cleanSystemTags(input);
+    }
+    const texts = input.filter((p): p is ContentPart & { type: "text" } => p.type === "text").map((p) => p.text);
+    return cleanSystemTags(texts.join("\n"));
+  },
+
+  getImages(input: string | ContentPart[]): string[] {
+    if (typeof input === "string") {
+      return [];
+    }
+    return input.filter((p): p is ContentPart & { type: "image_url" } => p.type === "image_url").map((p) => p.image_url.url);
+  },
+
+  getVideos(input: string | ContentPart[]): string[] {
+    if (typeof input === "string") {
+      return [];
+    }
+    return input.filter((p): p is ContentPart & { type: "video_url" } => p.type === "video_url").map((p) => p.video_url.url);
+  },
+
+  hasImages(input: string | ContentPart[]): boolean {
+    return Content.getImages(input).length > 0;
+  },
+
+  hasVideos(input: string | ContentPart[]): boolean {
+    return Content.getVideos(input).length > 0;
+  },
+
+  hasMedia(input: string | ContentPart[]): boolean {
+    return Content.hasImages(input) || Content.hasVideos(input);
+  },
+
+  build(text: string, mediaUrls: string[]): ContentPart[] {
+    const parts: ContentPart[] = [];
+    if (text.trim()) {
+      parts.push({ type: "text", text });
+    }
+    for (const url of mediaUrls) {
+      const mediaType = getMediaTypeFromDataUri(url);
+      if (mediaType === "video") {
+        parts.push({ type: "video_url", video_url: { url } });
+      } else {
+        parts.push({ type: "image_url", image_url: { url } });
+      }
+    }
+    return parts;
+  },
+
+  isEmpty(input: string | ContentPart[]): boolean {
+    return !Content.getText(input).trim() && !Content.hasMedia(input);
+  },
+};
diff --git a/apps/vscode/webview-ui/src/lib/media-utils.ts b/apps/vscode/webview-ui/src/lib/media-utils.ts
new file mode 100644
index 000000000..e58bfa1e7
--- /dev/null
+++ b/apps/vscode/webview-ui/src/lib/media-utils.ts
@@ -0,0 +1,186 @@
+import { heicTo } from "heic-to/csp";
+
+import { IMAGE_CONFIG, VIDEO_CONFIG, MEDIA_CONFIG, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS } from "@/services/config";
+
+export type MediaType = "image" | "video";
+
+const IMAGE_TYPES = new Set<string>(IMAGE_CONFIG.allowedTypes);
+const VIDEO_TYPES = new Set<string>(VIDEO_CONFIG.allowedTypes);
+
+function getExtension(filename: string): string {
+  return filename.split(".").pop()?.toLowerCase() ?? "";
+}
+
+function isHeicFile(file: File): boolean {
+  if (file.type === "image/heic" || file.type === "image/heif") {
+    return true;
+  }
+  const ext = getExtension(file.name);
+  return ext === "heic" || ext === "heif";
+}
+
+export function getMediaType(file: File): MediaType | null {
+  if (IMAGE_TYPES.has(file.type)) {
+    return "image";
+  }
+  if (VIDEO_TYPES.has(file.type)) {
+    return "video";
+  }
+  if (isHeicFile(file)) {
+    return "image";
+  }
+  return null;
+}
+
+export function getMediaTypeFromSrc(src: string): MediaType | null {
+  if (src.startsWith("data:image/")) {
+    return "image";
+  }
+  if (src.startsWith("data:video/")) {
+    return "video";
+  }
+  const ext = src.split(".").pop()?.toLowerCase().split("?")[0];
+  if (ext && IMAGE_EXTENSIONS.has(ext)) {
+    return "image";
+  }
+  if (ext && VIDEO_EXTENSIONS.has(ext)) {
+    return "video";
+  }
+  return null;
+}
+
+export function getMediaTypeFromDataUri(dataUri: string): MediaType | null {
+  if (dataUri.startsWith("data:image/")) {
+    return "image";
+  }
+  if (dataUri.startsWith("data:video/")) {
+    return "video";
+  }
+  return null;
+}
+
+export function getDataUriByteSize(dataUri: string): number {
+  const commaIndex = dataUri.indexOf(",");
+  if (commaIndex === -1) {
+    return 0;
+  }
+  const base64 = dataUri.slice(commaIndex + 1);
+  return Math.ceil((base64.length * 3) / 4);
+}
+
+export interface MediaValidationError {
+  type: "format" | "size" | "count" | "total_size";
+  message: string;
+}
+
+export function validateMediaFile(file: File, currentCount: number): MediaValidationError | null {
+  if (currentCount >= MEDIA_CONFIG.maxCount) {
+    return { type: "count", message: `Maximum ${MEDIA_CONFIG.maxCount} media files allowed` };
+  }
+
+  const mediaType = getMediaType(file);
+  if (!mediaType) {
+    return { type: "format", message: "Unsupported format. Use PNG, JPEG, GIF, WebP, HEIC, MP4, WebM or MOV" };
+  }
+
+  const maxSize = mediaType === "image" ? IMAGE_CONFIG.maxSizeBytes : VIDEO_CONFIG.maxSizeBytes;
+  if (file.size > maxSize) {
+    return { type: "size", message: `File exceeds ${maxSize / (1024 * 1024)}MB limit` };
+  }
+
+  return null;
+}
+
+// ============ Processing Helpers ============
+export function validateTotalSize(existingDataUris: string[], newDataUri: string): MediaValidationError | null {
+  const existingSize = existingDataUris.reduce((sum, uri) => sum + getDataUriByteSize(uri), 0);
+  const newSize = getDataUriByteSize(newDataUri);
+  const totalSize = existingSize + newSize;
+  if (totalSize > MEDIA_CONFIG.maxTotalBytes) {
+    const maxMB = MEDIA_CONFIG.maxTotalBytes / (1024 * 1024);
+    return { type: "total_size", message: `Total media size exceeds ${maxMB}MB limit` };
+  }
+  return null;
+}
+
+function blobToDataUri(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+
+function loadImage(src: string): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = reject;
+    img.src = src;
+  });
+}
+
+function getScaledDimensions(w: number, h: number, max: number): { width: number; height: number } {
+  if (w <= max && h <= max) {
+    return { width: w, height: h };
+  }
+  const ratio = Math.min(max / w, max / h);
+  return { width: Math.round(w * ratio), height: Math.round(h * ratio) };
+}
+
+function canvasToDataUri(img: HTMLImageElement, mime: string, w: number, h: number, quality: number): string {
+  const canvas = document.createElement("canvas");
+  canvas.width = w;
+  canvas.height = h;
+  canvas.getContext("2d")!.drawImage(img, 0, 0, w, h);
+  return canvas.toDataURL(mime, quality);
+}
+
+function dataUriSize(dataUri: string): number {
+  const base64 = dataUri.split(",")[1];
+  return Math.round((base64.length * 3) / 4);
+}
+
+// ============ Processing ============
+
+async function processImage(file: File): Promise<string> {
+  let blob: Blob = file;
+  let mime = file.type;
+
+  // Convert HEIC to JPEG
+  if (isHeicFile(file)) {
+    blob = await heicTo({ blob: file, type: "image/jpeg", quality: 0.92 });
+    mime = "image/jpeg";
+  }
+
+  const dataUri = await blobToDataUri(blob);
+  const img = await loadImage(dataUri);
+  const { width, height } = getScaledDimensions(img.width, img.height, IMAGE_CONFIG.maxDimension);
+  const needsResize = width !== img.width || height !== img.height;
+  const isCompressible = mime === "image/jpeg" || mime === "image/webp";
+
+  // No processing needed
+  if (!needsResize && blob.size <= IMAGE_CONFIG.compressThresholdBytes) {
+    return dataUri;
+  }
+
+  // Resize if needed
+  let result = needsResize ? canvasToDataUri(img, mime, width, height, 1) : dataUri;
+
+  // Compress if still too large
+  if (isCompressible && dataUriSize(result) > IMAGE_CONFIG.compressThresholdBytes) {
+    for (let q = 0.85; q >= 0.5; q -= 0.1) {
+      result = canvasToDataUri(img, mime, width, height, q);
+      if (dataUriSize(result) <= IMAGE_CONFIG.targetCompressedBytes) {
+        break;
+      }
+    }
+  }
+
+  return result;
+}
+
+export async function processMediaFile(file: File): Promise<string> {
+  return getMediaType(file) === "video" ? blobToDataUri(file) : processImage(file);
+}
diff --git a/apps/vscode/webview-ui/src/lib/text-enrichment.ts b/apps/vscode/webview-ui/src/lib/text-enrichment.ts
new file mode 100644
index 000000000..c3a8d7808
--- /dev/null
+++ b/apps/vscode/webview-ui/src/lib/text-enrichment.ts
@@ -0,0 +1,148 @@
+import { bridge } from "@/services";
+
+// Color Regex
+const HEX_COLOR = /#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})(?![0-9a-fA-F\w])/;
+const RGB_COLOR = /rgba?\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}(?:\s*,\s*[\d.]+)?\s*\)/;
+const HSL_COLOR = /hsla?\(\s*\d{1,3}\s*,\s*[\d.]+%\s*,\s*[\d.]+%(?:\s*,\s*[\d.]+)?\s*\)/;
+
+// File Path Regex
+const FILE_PATH = /(?:@|\.\/)?(?:[a-zA-Z_][\w-]*\/)*[a-zA-Z_][\w-]*\.[a-zA-Z0-9]+/;
+
+// Combined Regex
+const ENRICHMENT_PATTERN = new RegExp(`(${HEX_COLOR.source}|${RGB_COLOR.source}|${HSL_COLOR.source})|(${FILE_PATH.source})`, "g");
+
+// Color Regex for recognizing colors only within code tags
+const COLOR_ONLY_PATTERN = new RegExp(`(${HEX_COLOR.source}|${RGB_COLOR.source}|${HSL_COLOR.source})`, "g");
+
+export type Segment = { type: "text"; value: string } | { type: "color"; value: string } | { type: "file"; value: string; path: string };
+
+function normalizePath(raw: string): string {
+  let p = raw;
+  if (p.startsWith("@")) {
+    p = p.slice(1);
+  }
+  if (p.startsWith("./")) {
+    p = p.slice(2);
+  }
+  return p;
+}
+
+export function extractPaths(text: string): string[] {
+  if (!text) {
+    return [];
+  }
+  const seen = new Set<string>();
+  const regex = new RegExp(FILE_PATH.source, "g");
+  let m: RegExpExecArray | null;
+  while ((m = regex.exec(text))) {
+    seen.add(normalizePath(m[0]));
+  }
+  return [...seen];
+}
+
+export function parseSegments(text: string, fileExistsMap: Record<string, boolean>): Segment[] {
+  if (!text) {
+    return [];
+  }
+
+  const segments: Segment[] = [];
+  const regex = new RegExp(ENRICHMENT_PATTERN.source, "g");
+  let lastIndex = 0;
+  let m: RegExpExecArray | null;
+
+  while ((m = regex.exec(text))) {
+    const [full, colorMatch, fileMatch] = m;
+
+    if (m.index > lastIndex) {
+      segments.push({ type: "text", value: text.slice(lastIndex, m.index) });
+    }
+
+    if (colorMatch) {
+      segments.push({ type: "color", value: colorMatch });
+    } else if (fileMatch) {
+      const path = normalizePath(fileMatch);
+      segments.push(fileExistsMap[path] ? { type: "file", value: fileMatch, path } : { type: "text", value: fileMatch });
+    }
+
+    lastIndex = m.index + full.length;
+  }
+
+  if (lastIndex < text.length) {
+    segments.push({ type: "text", value: text.slice(lastIndex) });
+  }
+
+  return segments.length ? segments : [{ type: "text", value: text }];
+}
+
+export function parseColorSegments(text: string): Segment[] {
+  if (!text) {
+    return [];
+  }
+
+  const segments: Segment[] = [];
+  const regex = new RegExp(COLOR_ONLY_PATTERN.source, "g");
+  let lastIndex = 0;
+  let m: RegExpExecArray | null;
+
+  while ((m = regex.exec(text))) {
+    if (m.index > lastIndex) {
+      segments.push({ type: "text", value: text.slice(lastIndex, m.index) });
+    }
+    segments.push({ type: "color", value: m[0] });
+    lastIndex = m.index + m[0].length;
+  }
+
+  if (lastIndex < text.length) {
+    segments.push({ type: "text", value: text.slice(lastIndex) });
+  }
+
+  return segments.length ? segments : [{ type: "text", value: text }];
+}
+
+export function hasColors(text: string): boolean {
+  return COLOR_ONLY_PATTERN.test(text);
+}
+
+// File Existence Cache
+const CACHE_TTL = 10_000;
+const fileExistsCache = new Map<string, { exists: boolean; ts: number }>();
+
+export async function checkFilesExist(paths: string[]): Promise<Record<string, boolean>> {
+  if (!paths.length) {
+    return {};
+  }
+
+  const result: Record<string, boolean> = {};
+  const uncached: string[] = [];
+  const now = Date.now();
+
+  for (const p of new Set(paths)) {
+    const entry = fileExistsCache.get(p);
+    if (entry && now - entry.ts < CACHE_TTL) {
+      result[p] = entry.exists;
+    } else {
+      uncached.push(p);
+    }
+  }
+
+  if (uncached.length) {
+    try {
+      const fetched = await bridge.checkFilesExist(uncached);
+      for (const p of uncached) {
+        const exists = fetched[p] ?? false;
+        fileExistsCache.set(p, { exists, ts: now });
+        result[p] = exists;
+      }
+    } catch {
+      for (const p of uncached) {
+        result[p] = false;
+      }
+    }
+  }
+
+  return result;
+}
+
+export function isLocalPath(src: string): boolean {
+  return !!src && !src.startsWith("data:") && !src.startsWith("http://") && !src.startsWith("https://") && !src.startsWith("blob:");
+}
diff --git a/apps/vscode/webview-ui/src/lib/utils.ts b/apps/vscode/webview-ui/src/lib/utils.ts
new file mode 100644
index 000000000..a5ef19350
--- /dev/null
+++ b/apps/vscode/webview-ui/src/lib/utils.ts
@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
diff --git a/apps/vscode/webview-ui/src/main.tsx b/apps/vscode/webview-ui/src/main.tsx
new file mode 100644
index 000000000..ae4b4ea15
--- /dev/null
+++ b/apps/vscode/webview-ui/src/main.tsx
@@ -0,0 +1,26 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App";
+
+function syncTheme() {
+  const isDark = document.body.classList.contains("vscode-dark");
+  document.documentElement.classList.toggle("dark", isDark);
+}
+
+syncTheme();
+
+const observer = new MutationObserver(syncTheme);
+observer.observe(document.body, {
+  attributes: true,
+  attributeFilter: ["class"],
+});
+
+const container = document.getElementById("root");
+
+if (container) {
+  createRoot(container).render(
+    <StrictMode>
+      <App />
+    </StrictMode>,
+  );
+}
diff --git a/apps/vscode/webview-ui/src/services/bridge.ts b/apps/vscode/webview-ui/src/services/bridge.ts
new file mode 100644
index 000000000..04f90f274
--- /dev/null
+++ b/apps/vscode/webview-ui/src/services/bridge.ts
@@ -0,0 +1,300 @@
+import { Methods, Events } from "shared/bridge";
+import type {
+  ApprovalResponse,
+  ContentPart,
+  MCPServerConfig,
+  SessionInfo,
+  KimiConfig,
+  MCPTestResult,
+  LoginResult,
+  UpdateMCPServerRequest,
+} from "shared/legacy-sdk";
+import type {
+  FileChange,
+  SessionConfig,
+  ExtensionConfig,
+  WorkspaceStatus,
+  LoginStatus,
+  UIStreamEvent,
+} from "shared/types";
+
+interface PendingRequest {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  timeout: ReturnType<typeof setTimeout>;
+}
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
+const OAUTH_REQUEST_TIMEOUT_MS = 16 * 60 * 1000;
+
+interface VSCodeAPI {
+  postMessage(message: unknown): void;
+  getState(): unknown;
+  setState(state: unknown): void;
+}
+
+declare function acquireVsCodeApi(): VSCodeAPI;
+
+class Bridge {
+  private vscode: VSCodeAPI;
+  private pending = new Map<string, PendingRequest>();
+  private eventHandlers = new Map<string, Set<(data: unknown) => void>>();
+  private requestId = 0;
+  private webviewId: string;
+
+  constructor() {
+    this.webviewId = document.body.getAttribute("data-webviewid") || `unknown_${Date.now()}`;
+
+    if (typeof acquireVsCodeApi === "function") {
+      this.vscode = acquireVsCodeApi();
+    } else {
+      console.warn("[Kimi Bridge] Running outside VS Code, using mock");
+      this.vscode = {
+        postMessage: (msg) => console.log("[Kimi Mock]", msg),
+        getState: () => undefined,
+        setState: () => {},
+      };
+    }
+
+    window.addEventListener("message", this.handleMessage);
+  }
+
+  private handleMessage = (event: MessageEvent) => {
+    const msg = event.data;
+
+    if (msg.id && this.pending.has(msg.id)) {
+      const { resolve, reject, timeout } = this.pending.get(msg.id)!;
+      clearTimeout(timeout);
+      this.pending.delete(msg.id);
+
+      if (msg.error) {
+        reject(new Error(msg.error));
+      } else {
+        resolve(msg.result);
+      }
+      return;
+    }
+
+    if (msg.event) {
+      const handlers = this.eventHandlers.get(msg.event);
+      handlers?.forEach((h) => h(msg.data));
+    }
+  };
+
+  private call<T>(method: string, params?: unknown, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS): Promise<T> {
+    const id = `${++this.requestId}_${Date.now()}`;
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Bridge ${method} timed out`));
+      }, timeoutMs);
+
+      this.pending.set(id, { resolve: resolve as (v: unknown) => void, reject, timeout });
+      this.vscode.postMessage({ id, method, params, webviewId: this.webviewId });
+    });
+  }
+
+  on<T>(event: string, handler: (data: T) => void): () => void {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, new Set());
+    }
+    this.eventHandlers.get(event)!.add(handler as (data: unknown) => void);
+
+    return () => {
+      this.eventHandlers.get(event)?.delete(handler as (data: unknown) => void);
+    };
+  }
+
+  checkWorkspace() {
+    return this.call<WorkspaceStatus>(Methods.CheckWorkspace);
+  }
+
+  getInputHistory() {
+    return this.call<string[]>(Methods.GetInputHistory);
+  }
+
+  addInputHistory(text: string) {
+    return this.call<{ ok: boolean }>(Methods.AddInputHistory, { text });
+  }
+
+  getSlashCommands() {
+    return this.call<import("shared/legacy-sdk").SlashCommandInfo[]>(Methods.GetSlashCommands);
+  }
+
+  checkLoginStatus() {
+    return this.call<LoginStatus>(Methods.CheckLoginStatus);
+  }
+
+  login() {
+    return this.call<LoginResult>(Methods.Login, undefined, OAUTH_REQUEST_TIMEOUT_MS);
+  }
+
+  logout() {
+    return this.call<LoginResult>(Methods.Logout);
+  }
+
+  saveConfig(sessionConfig: SessionConfig) {
+    return this.call<{ ok: boolean }>(Methods.SaveConfig, sessionConfig);
+  }
+
+  getExtensionConfig() {
+    return this.call<ExtensionConfig>(Methods.GetExtensionConfig);
+  }
+
+  openSettings() {
+    return this.call<{ ok: boolean }>(Methods.OpenSettings);
+  }
+
+  openFolder() {
+    return this.call<{ ok: boolean }>(Methods.OpenFolder);
+  }
+
+  getModels() {
+    return this.call<KimiConfig>(Methods.GetModels);
+  }
+
+  getMCPServers() {
+    return this.call<MCPServerConfig[]>(Methods.GetMCPServers);
+  }
+
+  addMCPServer(serverConfig: MCPServerConfig) {
+    return this.call<MCPServerConfig[]>(Methods.AddMCPServer, serverConfig);
+  }
+
+  updateMCPServer(originalName: string, serverConfig: MCPServerConfig) {
+    const request: UpdateMCPServerRequest = { originalName, server: serverConfig };
+    return this.call<MCPServerConfig[]>(Methods.UpdateMCPServer, request);
+  }
+
+  removeMCPServer(name: string) {
+    return this.call<MCPServerConfig[]>(Methods.RemoveMCPServer, { name });
+  }
+
+  authMCP(name: string) {
+    return this.call<{ ok: boolean }>(Methods.AuthMCP, { name }, OAUTH_REQUEST_TIMEOUT_MS);
+  }
+
+  resetAuthMCP(name: string) {
+    return this.call<{ ok: boolean }>(Methods.ResetAuthMCP, { name });
+  }
+
+  testMCP(name: string) {
+    return this.call<MCPTestResult>(Methods.TestMCP, { name });
+  }
+
+  streamChat(content: string | ContentPart[], model: string, effort: string, planMode: boolean, sessionId?: string) {
+    return this.call<{ done: boolean }>(Methods.StreamChat, { content, model, effort, planMode, sessionId });
+  }
+
+  abortChat() {
+    return this.call<{ aborted: boolean }>(Methods.AbortChat);
+  }
+
+  resetSession() {
+    return this.call<{ ok: boolean }>(Methods.ResetSession);
+  }
+
+  getProjectFiles(params?: { query?: string; directory?: string }) {
+    return this.call<import("shared/types").ProjectFile[]>(Methods.GetProjectFiles, params);
+  }
+
+  respondApproval(requestId: string, response: ApprovalResponse) {
+    return this.call<{ ok: boolean }>(Methods.RespondApproval, { requestId, response });
+  }
+
+  respondQuestion(rpcRequestId: string, questionRequestId: string, answers: Record<string, string>) {
+    return this.call<{ ok: boolean }>(Methods.RespondQuestion, { rpcRequestId, questionRequestId, answers });
+  }
+
+  getKimiSessions() {
+    return this.call<SessionInfo[]>(Methods.GetKimiSessions);
+  }
+
+  getAllKimiSessions() {
+    return this.call<SessionInfo[]>(Methods.GetAllKimiSessions);
+  }
+
+  getRegisteredWorkDirs() {
+    return this.call<string[]>(Methods.GetRegisteredWorkDirs);
+  }
+
+  setWorkDir(workDir: string | null) {
+    return this.call<{ ok: boolean; workDir: string }>(Methods.SetWorkDir, { workDir });
+  }
+
+  browseWorkDir() {
+    return this.call<{ ok: boolean; workDir: string | null }>(Methods.BrowseWorkDir);
+  }
+
+  loadSessionHistory(sessionId: string) {
+    return this.call<UIStreamEvent[]>(Methods.LoadKimiSessionHistory, { kimiSessionId: sessionId });
+  }
+
+  deleteSession(sessionId: string) {
+    return this.call<{ ok: boolean }>(Methods.DeleteKimiSession, { sessionId });
+  }
+
+  forkSession(sessionId: string, turnIndex: number) {
+    return this.call<{ sessionId: string } | null>(Methods.ForkKimiSession, { sessionId, turnIndex });
+  }
+
+  pickMedia(maxCount: number, includeVideo = true) {
+    return this.call<string[]>(Methods.PickMedia, { maxCount, includeVideo });
+  }
+
+  checkFileExists(filePath: string) {
+    return this.call<boolean>(Methods.CheckFileExists, { filePath });
+  }
+
+  checkFilesExist(paths: string[]) {
+    return this.call<Record<string, boolean>>(Methods.CheckFilesExist, { paths });
+  }
+
+  openFile(filePath: string) {
+    return this.call<{ ok: boolean }>(Methods.OpenFile, { filePath });
+  }
+
+  openFileDiff(filePath: string) {
+    return this.call<{ ok: boolean }>(Methods.OpenFileDiff, { filePath });
+  }
+
+  trackFiles(paths: string[]) {
+    return this.call<FileChange[]>(Methods.TrackFiles, { paths });
+  }
+
+  clearTrackedFiles() {
+    return this.call<{ ok: boolean }>(Methods.ClearTrackedFiles);
+  }
+
+  revertFiles(filePath?: string) {
+    return this.call<{ ok: boolean }>(Methods.RevertFiles, { filePath });
+  }
+
+  keepChanges(filePath?: string) {
+    return this.call<{ ok: boolean }>(Methods.KeepChanges, { filePath });
+  }
+
+  getImageDataUri(filePath: string) {
+    return this.call<string | null>(Methods.GetImageDataUri, { filePath });
+  }
+
+  setPlanMode(enabled: boolean) {
+    return this.call<{ ok: boolean; planMode: boolean }>(Methods.SetPlanMode, { enabled });
+  }
+
+  steerChat(content: string | ContentPart[]) {
+    return this.call<{ ok: boolean }>(Methods.SteerChat, { content });
+  }
+
+  showLogs() {
+    return this.call<{ ok: boolean }>(Methods.ShowLogs);
+  }
+
+  reloadWebview() {
+    return this.call<{ ok: boolean }>(Methods.ReloadWebview);
+  }
+}
+
+export const bridge = new Bridge();
+export { Events };
diff --git a/apps/vscode/webview-ui/src/services/config.ts b/apps/vscode/webview-ui/src/services/config.ts
new file mode 100644
index 000000000..f0b89b5e5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/services/config.ts
@@ -0,0 +1,26 @@
+export const IMAGE_CONFIG = {
+  maxSizeBytes: 5 * 1024 * 1024,
+  maxDimension: 4096,
+  compressThresholdBytes: 5 * 1024 * 1024,
+  targetCompressedBytes: 2 * 1024 * 1024,
+  allowedTypes: ["image/png", "image/jpeg", "image/gif", "image/webp", "image/heic", "image/heif"] as const,
+} as const;
+
+export const IMAGE_EXTENSIONS = new Set(["png", "jpg", "jpeg", "gif", "webp", "heic", "heif", "svg", "bmp"]);
+
+export const VIDEO_CONFIG = {
+  maxSizeBytes: 40 * 1024 * 1024,
+  allowedTypes: ["video/mp4", "video/webm", "video/quicktime"] as const,
+} as const;
+
+export const VIDEO_EXTENSIONS = new Set(["mp4", "webm", "mov"]);
+
+export const MEDIA_CONFIG = {
+  maxCount: 9,
+  maxTotalBytes: 80 * 1024 * 1024,
+} as const;
+
+export const FILE_PICKER_CONFIG = {
+  maxSearchResults: 30,
+  maxDisplayLength: 25,
+} as const;
diff --git a/apps/vscode/webview-ui/src/services/index.ts b/apps/vscode/webview-ui/src/services/index.ts
new file mode 100644
index 000000000..4d4f0d28f
--- /dev/null
+++ b/apps/vscode/webview-ui/src/services/index.ts
@@ -0,0 +1,3 @@
+export { bridge, Events } from "./bridge";
+export { RECOMMENDED_MCP_SERVERS, recommendedToConfig } from "./recommended-mcp";
+export type { RecommendedMCPServer } from "./recommended-mcp";
diff --git a/apps/vscode/webview-ui/src/services/recommended-mcp.ts b/apps/vscode/webview-ui/src/services/recommended-mcp.ts
new file mode 100644
index 000000000..e259ab8b8
--- /dev/null
+++ b/apps/vscode/webview-ui/src/services/recommended-mcp.ts
@@ -0,0 +1,46 @@
+import type { MCPServerConfig } from "shared/legacy-sdk";
+
+export interface RecommendedMCPServer {
+  id: string;
+  name: string;
+  description: string;
+  command: string;
+  args: string[];
+  github?: string;
+}
+
+export const RECOMMENDED_MCP_SERVERS: RecommendedMCPServer[] = [
+  {
+    id: "playwright",
+    name: "Playwright",
+    description: "Browser automation and web scraping with headless Chrome",
+    command: "npx",
+    args: ["-y", "@playwright/mcp@latest", "--allow-unrestricted-file-access"],
+    github: "https://github.com/microsoft/playwright-mcp",
+  },
+  {
+    id: "context7",
+    name: "Context7",
+    description: "Up-to-date documentation for any library directly in your prompt",
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp@latest"],
+    github: "https://github.com/upstash/context7",
+  },
+  {
+    id: "github",
+    name: "GitHub",
+    description: "Repository management, file operations, and GitHub API integration",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-github@latest"],
+    github: "https://github.com/modelcontextprotocol/servers",
+  },
+];
+
+export function recommendedToConfig(server: RecommendedMCPServer): MCPServerConfig {
+  return {
+    name: server.id,
+    transport: "stdio",
+    command: server.command,
+    args: server.args,
+  };
+}
diff --git a/apps/vscode/webview-ui/src/stores/approval.store.ts b/apps/vscode/webview-ui/src/stores/approval.store.ts
new file mode 100644
index 000000000..7125c3c18
--- /dev/null
+++ b/apps/vscode/webview-ui/src/stores/approval.store.ts
@@ -0,0 +1,41 @@
+import { create } from "zustand";
+import type { DisplayBlock, ApprovalResponse } from "shared/legacy-sdk";
+import { bridge } from "@/services";
+
+export interface ApprovalRequest {
+  id: string;
+  tool_call_id: string;
+  sender: string;
+  action: string;
+  description: string;
+  display: DisplayBlock[];
+}
+
+interface ApprovalState {
+  pending: ApprovalRequest[];
+  addRequest: (request: ApprovalRequest) => void;
+  removeRequest: (id: string) => void;
+  respondToRequest: (id: string, response: ApprovalResponse) => Promise<void>;
+  clearRequests: () => void;
+}
+
+export const useApprovalStore = create<ApprovalState>((set, get) => ({
+  pending: [],
+
+  addRequest: (request) => {
+    set((s) => ({ pending: [...s.pending, request] }));
+  },
+
+  removeRequest: (id) => {
+    set((s) => ({ pending: s.pending.filter((r) => r.id !== id) }));
+  },
+
+  respondToRequest: async (id, response) => {
+    await bridge.respondApproval(id, response);
+    get().removeRequest(id);
+  },
+
+  clearRequests: () => {
+    set({ pending: [] });
+  },
+}));
diff --git a/apps/vscode/webview-ui/src/stores/chat.store.ts b/apps/vscode/webview-ui/src/stores/chat.store.ts
new file mode 100644
index 000000000..19f125ca5
--- /dev/null
+++ b/apps/vscode/webview-ui/src/stores/chat.store.ts
@@ -0,0 +1,478 @@
+import { create } from "zustand";
+import { produce } from "immer";
+import { bridge } from "@/services";
+import { Content } from "@/lib/content";
+import { useApprovalStore } from "./approval.store";
+
+import { useSettingsStore } from "./settings.store";
+import { processEvent } from "./event-handlers";
+import type { StatusUpdate, ContentPart, QuestionRequest, ToolResult } from "shared/legacy-sdk";
+import type { UIStreamEvent } from "shared/types";
+
+const HANDSHAKE_TIMEOUT_MS = 30_000;
+
+export interface UIToolCall {
+  id: string;
+  name: string;
+  arguments: string | null;
+}
+
+export interface UIStep {
+  n: number;
+  items: UIStepItem[];
+  planMode?: boolean;
+}
+
+export interface InlineError {
+  code: string;
+  message: string;
+  detail?: string; // 服务器原始错误信息
+}
+
+export type UIStepItem =
+  | { type: "thinking"; content: string; finished?: boolean }
+  | { type: "text"; content: string; finished?: boolean }
+  | { type: "compaction" }
+  | { type: "steer"; content: string | ContentPart[] }
+  | {
+      type: "tool_use";
+      id: string;
+      call: UIToolCall;
+      result?: ToolResult["return_value"];
+      subagent_steps?: UIStep[];
+    };
+
+export interface ChatMessage {
+  id: string;
+  role: "user" | "assistant";
+  content: string | ContentPart[];
+  timestamp: number;
+  steps?: UIStep[];
+  status?: StatusUpdate;
+  inlineError?: InlineError;
+  /** False for host-only commands that do not create a forkable core turn. */
+  forkable?: boolean;
+}
+
+export interface TokenUsage {
+  input_other: number;
+  output: number;
+  input_cache_read: number;
+  input_cache_creation: number;
+}
+
+function createEmptyTokenUsage(): TokenUsage {
+  return { input_other: 0, output: 0, input_cache_read: 0, input_cache_creation: 0 };
+}
+
+export interface MediaInConversation {
+  hasImage: boolean;
+  hasVideo: boolean;
+}
+
+export interface DraftMediaItem {
+  id: string;
+  dataUri?: string;
+}
+
+export interface PendingInput {
+  content: string | ContentPart[];
+  model: string;
+}
+
+export interface QueuedItem {
+  id: string;
+  content: string | ContentPart[];
+  model: string;
+}
+
+export interface ChatState {
+  sessionId: string | null;
+  messages: ChatMessage[];
+  isStreaming: boolean;
+  isCompacting: boolean;
+  handshakeReceived: boolean;
+  draftMedia: DraftMediaItem[];
+  lastStatus: StatusUpdate | null;
+  tokenUsage: TokenUsage;
+  activeTokenUsage: TokenUsage;
+  pendingInput: PendingInput | null;
+  queue: QueuedItem[];
+  pendingQuestion: QuestionRequest | null;
+  planMode: boolean;
+
+  sendMessage: (text: string) => void;
+  retryLastMessage: () => void;
+  processEvent: (event: UIStreamEvent) => void;
+  loadSession: (sessionId: string, events: UIStreamEvent[]) => Promise<void>;
+  startNewConversation: () => Promise<void>;
+  abort: () => void;
+  addDraftMedia: (id: string, dataUri?: string) => void;
+  updateDraftMedia: (id: string, dataUri: string) => void;
+  removeDraftMedia: (id: string) => void;
+  clearDraftMedia: () => void;
+  getMediaInConversation: () => MediaInConversation;
+  hasProcessingMedia: () => boolean;
+  rollbackInput: (content: string | ContentPart[]) => void;
+  respondQuestion: (answers: Record<string, string>) => Promise<void>;
+
+  enqueue: (content: string | ContentPart[], model: string) => void;
+  removeFromQueue: (id: string) => void;
+  editQueueItem: (id: string, content: string | ContentPart[]) => void;
+  moveQueueItemUp: (id: string) => void;
+  sendNextQueued: () => void;
+}
+
+let handshakeTimer: ReturnType<typeof setTimeout> | null = null;
+
+function clearHandshakeTimer() {
+  if (handshakeTimer) {
+    clearTimeout(handshakeTimer);
+    handshakeTimer = null;
+  }
+}
+
+function clearAllInlineErrors(draft: ChatState): void {
+  for (const msg of draft.messages) {
+    if (msg.inlineError) {
+      msg.inlineError = undefined;
+    }
+  }
+}
+
+function doSend(state: ChatState, content: string | ContentPart[], model: string) {
+  const { sessionId, planMode } = state;
+  const { thinkingEffort } = useSettingsStore.getState();
+
+  clearHandshakeTimer();
+  handshakeTimer = setTimeout(() => {
+    const s = useChatStore.getState();
+    if (s.isStreaming && !s.handshakeReceived) {
+      void bridge.abortChat().catch(() => undefined);
+      s.processEvent({
+        type: "error",
+        code: "HANDSHAKE_TIMEOUT",
+        message: "Connection timed out.",
+        phase: "runtime",
+      });
+    }
+  }, HANDSHAKE_TIMEOUT_MS);
+
+  void bridge
+    .streamChat(content, model, thinkingEffort, planMode, sessionId ?? undefined)
+    .catch((error: unknown) => {
+      const detail = error instanceof Error ? error.message : String(error);
+      useChatStore.getState().processEvent({
+        type: "error",
+        code: "internal",
+        message: "Unable to send the message.",
+        detail,
+        phase: "preflight",
+      });
+    });
+}
+
+export const useChatStore = create<ChatState>((set, get) => ({
+  sessionId: null,
+  messages: [],
+  isStreaming: false,
+  isCompacting: false,
+  handshakeReceived: false,
+  draftMedia: [],
+  lastStatus: null,
+  tokenUsage: createEmptyTokenUsage(),
+  activeTokenUsage: createEmptyTokenUsage(),
+  pendingInput: null,
+  queue: [],
+  pendingQuestion: null,
+  planMode: false,
+
+  sendMessage: (text) => {
+    const { draftMedia, isStreaming } = get();
+    const { currentModel } = useSettingsStore.getState();
+
+    const readyMedia = draftMedia.filter((m) => m.dataUri).map((m) => m.dataUri!);
+    const content = readyMedia.length > 0 ? Content.build(text, readyMedia) : text;
+
+    if (Content.isEmpty(content)) {
+      return;
+    }
+
+    // If streaming, enqueue instead of sending
+    if (isStreaming) {
+      get().enqueue(content, currentModel);
+      set({ draftMedia: [] });
+      return;
+    }
+
+    // Clear draft and set streaming state
+    set(
+      produce((draft: ChatState) => {
+        clearAllInlineErrors(draft);
+        draft.draftMedia = [];
+        draft.isStreaming = true;
+        draft.handshakeReceived = false;
+        draft.pendingInput = { content, model: currentModel };
+      }),
+    );
+    useApprovalStore.getState().clearRequests();
+
+    doSend(get(), content, currentModel);
+  },
+
+  retryLastMessage: () => {
+    const { pendingInput, isStreaming } = get();
+
+    if (isStreaming || !pendingInput) {
+      return;
+    }
+
+    // Remove failed assistant message and user message
+    set(
+      produce((draft: ChatState) => {
+        clearAllInlineErrors(draft);
+        draft.isStreaming = true;
+        draft.handshakeReceived = false;
+        const lastAssistant = draft.messages.at(-1);
+        if (lastAssistant?.role === "assistant" && lastAssistant.inlineError) {
+          draft.messages.pop();
+          if (draft.messages.at(-1)?.role === "user") {
+            draft.messages.pop();
+          }
+        }
+      }),
+    );
+    useApprovalStore.getState().clearRequests();
+
+    doSend(get(), pendingInput.content, pendingInput.model);
+  },
+
+  processEvent: (event) => {
+    // Clear handshake timeout on receiving valid response
+    if (event.type === "TurnBegin" || event.type === "StepBegin" || event.type === "ContentPart") {
+      clearHandshakeTimer();
+      set({ handshakeReceived: true });
+    } else if (event.type === "stream_complete" || event.type === "error") {
+      clearHandshakeTimer();
+    }
+
+    set(
+      produce((draft: ChatState) => {
+        processEvent(draft, event);
+      }),
+    );
+
+    // Auto-send next queued item when streaming ends (complete or error)
+    if (event.type === "stream_complete" || event.type === "error") {
+      const { queue, isStreaming: stillStreaming } = get();
+      if (!stillStreaming && queue.length > 0) {
+        setTimeout(() => get().sendNextQueued(), 50);
+      }
+    }
+  },
+
+  loadSession: async (sessionId, events) => {
+    clearHandshakeTimer();
+
+    // Abort any ongoing stream when switching sessions
+    const { isStreaming: wasStreaming } = get();
+    if (wasStreaming) {
+      await bridge.abortChat();
+    }
+
+    set({
+      sessionId,
+      messages: [],
+      isStreaming: false,
+      isCompacting: false,
+      handshakeReceived: false,
+      draftMedia: [],
+      lastStatus: null,
+      tokenUsage: createEmptyTokenUsage(),
+      activeTokenUsage: createEmptyTokenUsage(),
+      pendingInput: null,
+      queue: [],
+      pendingQuestion: null,
+      planMode: false,
+    });
+    useApprovalStore.getState().clearRequests();
+
+    for (const event of events) {
+      get().processEvent(event);
+    }
+
+    // All steps are finished when loading from history
+    set(
+      produce((draft: ChatState) => {
+        for (const msg of draft.messages) {
+          if (msg.steps) {
+            for (const step of msg.steps) {
+              for (const item of step.items) {
+                if (item.type === "text" || item.type === "thinking") {
+                  item.finished = true;
+                }
+              }
+            }
+          }
+        }
+        draft.isStreaming = false;
+        draft.isCompacting = false;
+        draft.pendingQuestion = null;
+      }),
+    );
+    useApprovalStore.getState().clearRequests();
+  },
+
+  startNewConversation: async () => {
+    clearHandshakeTimer();
+
+    // Abort any ongoing stream before starting new conversation
+    const { isStreaming: wasStreaming } = get();
+    if (wasStreaming) {
+      await bridge.abortChat();
+    }
+
+    await bridge.resetSession();
+    await bridge.clearTrackedFiles();
+    set({
+      sessionId: null,
+      messages: [],
+      isStreaming: false,
+      isCompacting: false,
+      handshakeReceived: false,
+      draftMedia: [],
+      lastStatus: null,
+      tokenUsage: createEmptyTokenUsage(),
+      activeTokenUsage: createEmptyTokenUsage(),
+      pendingInput: null,
+      queue: [],
+      pendingQuestion: null,
+      planMode: false,
+    });
+    useApprovalStore.getState().clearRequests();
+  },
+
+  abort: () => {
+    clearHandshakeTimer();
+    void bridge.abortChat().catch(() => undefined);
+    set({ pendingQuestion: null });
+    useApprovalStore.getState().clearRequests();
+  },
+
+  addDraftMedia: (id, dataUri) => {
+    set((s) => ({ draftMedia: [...s.draftMedia, { id, dataUri }] }));
+  },
+
+  updateDraftMedia: (id, dataUri) => {
+    set((s) => ({
+      draftMedia: s.draftMedia.map((m) => (m.id === id ? { ...m, dataUri } : m)),
+    }));
+  },
+
+  removeDraftMedia: (id) => {
+    set((s) => ({ draftMedia: s.draftMedia.filter((m) => m.id !== id) }));
+  },
+
+  clearDraftMedia: () => {
+    set({ draftMedia: [] });
+  },
+
+  getMediaInConversation: () => {
+    const { messages, draftMedia } = get();
+
+    let hasImage = false;
+    let hasVideo = false;
+
+    for (const item of draftMedia) {
+      if (!item.dataUri) {
+        continue;
+      }
+      if (item.dataUri.startsWith("data:image/")) {
+        hasImage = true;
+      } else if (item.dataUri.startsWith("data:video/")) {
+        hasVideo = true;
+      }
+    }
+
+    for (const msg of messages) {
+      if (Content.hasImages(msg.content)) {
+        hasImage = true;
+      }
+      if (Content.hasVideos(msg.content)) {
+        hasVideo = true;
+      }
+      if (hasImage && hasVideo) {
+        break;
+      }
+    }
+
+    return { hasImage, hasVideo };
+  },
+
+  hasProcessingMedia: () => {
+    return get().draftMedia.some((m) => !m.dataUri);
+  },
+
+  rollbackInput: (content) => {
+    const { currentModel } = useSettingsStore.getState();
+    set({ pendingInput: { content, model: currentModel } });
+  },
+
+  respondQuestion: async (answers) => {
+    const { pendingQuestion } = get();
+    if (!pendingQuestion) return;
+    await bridge.respondQuestion(pendingQuestion.id, pendingQuestion.id, answers);
+    set({ pendingQuestion: null });
+  },
+
+  enqueue: (content, model) => {
+    set((s) => ({
+      queue: [...s.queue, { id: crypto.randomUUID(), content, model }],
+    }));
+  },
+
+  removeFromQueue: (id) => {
+    set((s) => ({ queue: s.queue.filter((q) => q.id !== id) }));
+  },
+
+  editQueueItem: (id, content) => {
+    set((s) => ({
+      queue: s.queue.map((q) => (q.id === id ? { ...q, content } : q)),
+    }));
+  },
+
+  moveQueueItemUp: (id) => {
+    set((s) => {
+      const idx = s.queue.findIndex((q) => q.id === id);
+      if (idx <= 0) {
+        return s;
+      }
+      const next = [...s.queue];
+      [next[idx - 1], next[idx]] = [next[idx], next[idx - 1]];
+      return { queue: next };
+    });
+  },
+
+  sendNextQueued: () => {
+    const { queue, isStreaming } = get();
+    if (isStreaming || queue.length === 0) {
+      return;
+    }
+
+    const [next, ...rest] = queue;
+
+    set(
+      produce((draft: ChatState) => {
+        clearAllInlineErrors(draft);
+        draft.queue = rest;
+        draft.isStreaming = true;
+        draft.handshakeReceived = false;
+        draft.pendingInput = { content: next.content, model: next.model };
+        draft.draftMedia = [];
+      }),
+    );
+    useApprovalStore.getState().clearRequests();
+
+    doSend(get(), next.content, next.model);
+  },
+}));
diff --git a/apps/vscode/webview-ui/src/stores/event-handlers.ts b/apps/vscode/webview-ui/src/stores/event-handlers.ts
new file mode 100644
index 000000000..dc66b857e
--- /dev/null
+++ b/apps/vscode/webview-ui/src/stores/event-handlers.ts
@@ -0,0 +1,577 @@
+import { bridge } from "@/services";
+import { useApprovalStore } from "./approval.store";
+import { useSettingsStore } from "./settings.store";
+import { isPreflightError, isUserInterrupt } from "shared/errors";
+import type { ChatMessage, UIStep, UIStepItem, ChatState, TokenUsage } from "./chat.store";
+import type { ContentPart, ToolCall, ToolResult, TurnBegin, SubagentEvent, ApprovalRequestPayload, DiffBlock, RunResult, QuestionRequest } from "shared/legacy-sdk";
+import type { UIStreamEvent, StreamError } from "shared/types";
+
+type EventHandler = (draft: ChatState, payload: any) => void;
+
+function createEmptyTokenUsage(): TokenUsage {
+  return { input_other: 0, output: 0, input_cache_read: 0, input_cache_creation: 0 };
+}
+
+function addTokenUsage(target: TokenUsage, source: TokenUsage): void {
+  target.input_other += source.input_other || 0;
+  target.output += source.output || 0;
+  target.input_cache_read += source.input_cache_read || 0;
+  target.input_cache_creation += source.input_cache_creation || 0;
+}
+
+function extractDiffPaths(display?: { type: string; path?: string }[]): string[] {
+  if (!display) {
+    return [];
+  }
+  return display.filter((block): block is DiffBlock => block.type === "diff" && typeof block.path === "string").map((block) => block.path);
+}
+
+function getLastAssistant(draft: ChatState): ChatMessage | undefined {
+  const last = draft.messages.at(-1);
+  return last?.role === "assistant" ? last : undefined;
+}
+
+function hasContent(message: ChatMessage): boolean {
+  if (typeof message.content === "string" && message.content.trim()) {
+    return true;
+  }
+  if (Array.isArray(message.content) && message.content.length > 0) {
+    return true;
+  }
+
+  return message.steps?.some((s) => s.items.length > 0) ?? false;
+}
+
+function findToolUseItem(steps: UIStep[], toolId: string): (UIStepItem & { type: "tool_use" }) | null {
+  for (const step of steps) {
+    for (const item of step.items) {
+      if (item.type === "tool_use") {
+        if (item.id === toolId) {
+          return item;
+        }
+
+        if (item.subagent_steps) {
+          const found = findToolUseItem(item.subagent_steps, toolId);
+          if (found) {
+            return found;
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function resolveSubagentTarget(
+  steps: UIStep[],
+  payload: SubagentEvent,
+): { steps: UIStep[]; event: { type: string; payload: any }; toolItem: UIStepItem & { type: "tool_use" } } | null {
+  const { parent_tool_call_id, event } = payload;
+
+  // Nested SubagentEvent
+  if (event.type === "SubagentEvent") {
+    return resolveSubagentTarget(steps, event.payload as SubagentEvent);
+  }
+
+  const toolItem = findToolUseItem(steps, parent_tool_call_id);
+  if (!toolItem) {
+    return null;
+  }
+
+  if (!toolItem.subagent_steps) {
+    toolItem.subagent_steps = [];
+  }
+
+  return { steps: toolItem.subagent_steps, event, toolItem };
+}
+
+function finishAllTextItems(steps: UIStep[]): void {
+  for (const step of steps) {
+    for (const item of step.items) {
+      if (item.type === "text" || item.type === "thinking") {
+        item.finished = true;
+      }
+      if (item.type === "tool_use" && item.subagent_steps) {
+        finishAllTextItems(item.subagent_steps);
+      }
+    }
+  }
+}
+
+function applyEventToSteps(steps: UIStep[], event: { type: string; payload: any }, onText?: (text: string) => void): void {
+  const currentStep = steps.at(-1);
+
+  const appendOrCreate = (type: "text" | "thinking", content: string): void => {
+    if (!currentStep) {
+      return;
+    }
+    const last = currentStep.items.at(-1);
+
+    if (last?.type === type) {
+      (last as { content: string }).content += content;
+    } else {
+      currentStep.items.push({ type, content });
+    }
+  };
+
+  const findLastToolUse = (): (UIStepItem & { type: "tool_use" }) | null => {
+    for (let i = steps.length - 1; i >= 0; i--) {
+      const items = steps[i].items;
+
+      for (let j = items.length - 1; j >= 0; j--) {
+        if (items[j].type === "tool_use") {
+          return items[j] as UIStepItem & { type: "tool_use" };
+        }
+      }
+    }
+
+    return null;
+  };
+
+  const updateToolResult = (toolCallId: string, returnValue: ToolResult["return_value"]): boolean => {
+    for (const step of steps) {
+      for (const item of step.items) {
+        if (item.type === "tool_use") {
+          if (item.id === toolCallId) {
+            item.result = returnValue;
+            return true;
+          }
+
+          if (item.subagent_steps && applyToolResult(item.subagent_steps, toolCallId, returnValue)) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  };
+
+  const applyToolResult = (subSteps: UIStep[], toolCallId: string, returnValue: ToolResult["return_value"]): boolean => {
+    for (const step of subSteps) {
+      for (const item of step.items) {
+        if (item.type === "tool_use") {
+          if (item.id === toolCallId) {
+            item.result = returnValue;
+            return true;
+          }
+
+          if (item.subagent_steps && applyToolResult(item.subagent_steps, toolCallId, returnValue)) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  };
+
+  switch (event.type) {
+    case "StepBegin":
+      finishAllTextItems(steps);
+      steps.push({ n: event.payload.n, items: [] });
+      break;
+
+    case "ContentPart": {
+      const part = event.payload as ContentPart;
+
+      if (part.type === "text" && part.text) {
+        appendOrCreate("text", part.text);
+        onText?.(part.text);
+      } else if (part.type === "think" && part.think) {
+        appendOrCreate("thinking", part.think);
+      }
+
+      break;
+    }
+
+    case "ToolCall": {
+      if (!currentStep) {
+        break;
+      }
+      finishAllTextItems(steps);
+      const call = event.payload as ToolCall;
+
+      currentStep.items.push({
+        type: "tool_use",
+        id: call.id,
+        call: {
+          id: call.id,
+          name: call.function.name,
+          arguments: call.function.arguments ?? null,
+        },
+      });
+
+      break;
+    }
+
+    case "ToolCallPart": {
+      const { arguments_part, tool_call_id } = event.payload;
+      if (!arguments_part) {
+        break;
+      }
+      const tool = typeof tool_call_id === "string"
+        ? findToolUseItem(steps, tool_call_id)
+        : findLastToolUse();
+
+      if (tool) {
+        tool.call.arguments = (tool.call.arguments || "") + arguments_part;
+      }
+
+      break;
+    }
+
+    case "ToolResult": {
+      const result = event.payload as ToolResult;
+      updateToolResult(result.tool_call_id, result.return_value);
+
+      const paths = extractDiffPaths(result.return_value.display);
+      if (paths.length > 0) {
+        void bridge.trackFiles(paths);
+      }
+
+      break;
+    }
+  }
+}
+
+function isTaskToolResult(steps: UIStep[] | undefined, toolCallId: string): boolean {
+  if (!steps) {
+    return false;
+  }
+  const toolItem = findToolUseItem(steps, toolCallId);
+  return toolItem?.call.name === "Task" || toolItem?.call.name === "Agent";
+}
+
+function handlePreflightError(draft: ChatState, _code: string, _message: string): void {
+  // Pre-flight: 删除未发送成功的消息，恢复输入
+  addTokenUsage(draft.tokenUsage, draft.activeTokenUsage);
+  draft.activeTokenUsage = createEmptyTokenUsage();
+  draft.isStreaming = false;
+  draft.isCompacting = false;
+  useApprovalStore.getState().clearRequests();
+
+  // 删除空的 assistant 消息
+  const lastAssistant = getLastAssistant(draft);
+  if (lastAssistant && !hasContent(lastAssistant)) {
+    draft.messages.pop();
+  }
+
+  // 删除对应的 user 消息
+  const lastUser = draft.messages.at(-1);
+  if (lastUser?.role === "user") {
+    const userContent = lastUser.content;
+    draft.messages.pop();
+    // 触发回滚（通过 pendingInput 保存）
+    draft.pendingInput = { content: userContent, model: "" };
+  }
+}
+
+function handleRuntimeError(draft: ChatState, code: string, message: string, detail?: string): void {
+  // Runtime: 保留现场，添加内嵌错误
+  addTokenUsage(draft.tokenUsage, draft.activeTokenUsage);
+  draft.activeTokenUsage = createEmptyTokenUsage();
+  draft.isStreaming = false;
+  draft.isCompacting = false;
+  useApprovalStore.getState().clearRequests();
+
+  const lastAssistant = getLastAssistant(draft);
+  if (lastAssistant) {
+    // 如果完全没有内容，添加一个空的 step 以便显示错误
+    if (!lastAssistant.steps) {
+      lastAssistant.steps = [];
+    }
+    finishAllTextItems(lastAssistant.steps);
+    // 设置内嵌错误，保留服务器原始错误信息
+    lastAssistant.inlineError = { code, message, detail };
+  }
+}
+
+const eventHandlers: Record<string, EventHandler> = {
+  // UI 事件 (Bridge 层)
+  session_start: (draft, payload: { sessionId: string; model?: string }) => {
+    if (payload.sessionId) {
+      draft.sessionId = payload.sessionId;
+    }
+  },
+
+  stream_complete: (draft, _payload: { result: RunResult }) => {
+    addTokenUsage(draft.tokenUsage, draft.activeTokenUsage);
+    draft.activeTokenUsage = createEmptyTokenUsage();
+    draft.isStreaming = false;
+    draft.isCompacting = false;
+    draft.pendingInput = null;
+    useApprovalStore.getState().clearRequests();
+    const lastAssistant = getLastAssistant(draft);
+    if (lastAssistant?.steps) {
+      finishAllTextItems(lastAssistant.steps);
+    }
+  },
+
+  error: (draft, payload: StreamError) => {
+    const code = payload.code || "UNKNOWN";
+    const phase = payload.phase || (isPreflightError(code) ? "preflight" : "runtime");
+
+    if (code === "UNKNOWN_EVENT_TYPE") {
+      return;
+    } // 忽略未知事件类型错误，通常是版本不匹配导致
+
+    if (phase === "preflight") {
+      handlePreflightError(draft, code, payload.message);
+    } else {
+      if (isUserInterrupt(code)) {
+        addTokenUsage(draft.tokenUsage, draft.activeTokenUsage);
+        draft.activeTokenUsage = createEmptyTokenUsage();
+        draft.isStreaming = false;
+        draft.isCompacting = false;
+        useApprovalStore.getState().clearRequests();
+        const lastAssistant = getLastAssistant(draft);
+        if (lastAssistant?.steps) {
+          finishAllTextItems(lastAssistant.steps);
+        }
+      } else {
+        handleRuntimeError(draft, code, payload.message, payload.detail);
+      }
+    }
+  },
+
+  // Wire 事件
+  TurnBegin: (draft, payload: TurnBegin & { forkable?: boolean }) => {
+    draft.tokenUsage = createEmptyTokenUsage();
+    draft.activeTokenUsage = createEmptyTokenUsage();
+
+    draft.messages.push({
+      id: crypto.randomUUID(),
+      role: "user",
+      content: payload.user_input,
+      timestamp: Date.now(),
+      forkable: payload.forkable,
+    });
+
+    draft.messages.push({
+      id: crypto.randomUUID(),
+      role: "assistant",
+      content: "",
+      timestamp: Date.now(),
+      steps: [],
+      forkable: payload.forkable,
+    });
+
+    draft.isStreaming = true;
+  },
+
+  CompactionBegin: (draft) => {
+    draft.isCompacting = true;
+
+    const last = getLastAssistant(draft);
+
+    if (last) {
+      if (!last.steps) {
+        last.steps = [];
+      }
+
+      if (last.steps.length === 0) {
+        last.steps.push({ n: 0, items: [] });
+      }
+
+      finishAllTextItems(last.steps);
+      last.steps.at(-1)!.items.push({ type: "compaction" });
+    }
+  },
+
+  CompactionEnd: (draft) => {
+    draft.isCompacting = false;
+  },
+
+  StepBegin: (draft, payload) => {
+    if (draft.lastStatus?.retrying) {
+      draft.lastStatus.retrying = null;
+    }
+    const last = getLastAssistant(draft);
+
+    if (last) {
+      if (!last.steps) {
+        last.steps = [];
+      }
+
+      applyEventToSteps(last.steps, { type: "StepBegin", payload });
+
+      // Tag the newly created step with current plan mode state
+      // Note: only top-level steps get tagged. Subagent steps go through
+      // SubagentEvent -> applyEventToSteps and won't inherit main agent's planMode.
+      const newStep = last.steps.at(-1);
+      if (newStep && draft.planMode) {
+        newStep.planMode = true;
+      }
+    }
+  },
+
+  StepInterrupted: (draft) => {
+    addTokenUsage(draft.tokenUsage, draft.activeTokenUsage);
+    draft.activeTokenUsage = createEmptyTokenUsage();
+
+    draft.isStreaming = false;
+    useApprovalStore.getState().clearRequests();
+    const lastAssistant = getLastAssistant(draft);
+    if (lastAssistant?.steps) {
+      finishAllTextItems(lastAssistant.steps);
+    }
+  },
+
+  ContentPart: (draft, payload: ContentPart) => {
+    const last = getLastAssistant(draft);
+    if (!last?.steps) {
+      return;
+    }
+
+    applyEventToSteps(last.steps, { type: "ContentPart", payload }, (text) => {
+      if (typeof last.content === "string") {
+        last.content += text;
+      }
+    });
+  },
+
+  ToolCall: (draft, payload: ToolCall) => {
+    const last = getLastAssistant(draft);
+    if (!last?.steps) {
+      return;
+    }
+    applyEventToSteps(last.steps, { type: "ToolCall", payload });
+  },
+
+  ToolCallPart: (draft, payload) => {
+    const last = getLastAssistant(draft);
+    if (!last?.steps) {
+      return;
+    }
+    applyEventToSteps(last.steps, { type: "ToolCallPart", payload });
+  },
+
+  ToolResult: (draft, payload: ToolResult) => {
+    const last = getLastAssistant(draft);
+    if (!last?.steps) {
+      return;
+    }
+
+    if (isTaskToolResult(last.steps, payload.tool_call_id)) {
+      addTokenUsage(draft.tokenUsage, draft.activeTokenUsage);
+      draft.activeTokenUsage = createEmptyTokenUsage();
+    }
+
+    applyEventToSteps(last.steps, { type: "ToolResult", payload });
+  },
+
+  SubagentEvent: (draft, payload: SubagentEvent) => {
+    const last = getLastAssistant(draft);
+    if (!last?.steps) {
+      return;
+    }
+
+    const target = resolveSubagentTarget(last.steps, payload);
+    if (!target) {
+      return;
+    }
+
+    if (target.event.type === "StatusUpdate") {
+      const { token_usage } = target.event.payload;
+
+      if (token_usage) {
+        addTokenUsage(draft.activeTokenUsage, {
+          input_other: token_usage.input_other || 0,
+          output: token_usage.output || 0,
+          input_cache_read: token_usage.input_cache_read || 0,
+          input_cache_creation: token_usage.input_cache_creation || 0,
+        });
+      }
+
+      return;
+    }
+
+    if (target.steps.length === 0) {
+      target.steps.push({ n: 1, items: [] });
+    }
+
+    // Nested Subagent Task End: accumulate token usage
+    if (target.event.type === "ToolResult") {
+      const toolResultPayload = target.event.payload as ToolResult;
+      if (isTaskToolResult(target.steps, toolResultPayload.tool_call_id)) {
+        addTokenUsage(draft.tokenUsage, draft.activeTokenUsage);
+        draft.activeTokenUsage = createEmptyTokenUsage();
+      }
+    }
+
+    applyEventToSteps(target.steps, target.event);
+  },
+
+  ApprovalRequest: (_, payload: ApprovalRequestPayload) => {
+    useApprovalStore.getState().addRequest({
+      id: payload.id,
+      tool_call_id: payload.tool_call_id,
+      sender: payload.sender,
+      action: payload.action,
+      description: payload.description,
+      display: payload.display ?? [],
+    });
+  },
+
+  QuestionRequest: (draft, payload: QuestionRequest) => {
+    draft.pendingQuestion = payload;
+  },
+
+  StatusUpdate: (draft, payload) => {
+    const { context_usage, token_usage, plan_mode, model, thinking_effort, retrying } = payload;
+
+    if (typeof model === "string" && model.length > 0) {
+      useSettingsStore.getState().setCurrentModel(model);
+    }
+    if (typeof thinking_effort === "string" && thinking_effort.length > 0) {
+      useSettingsStore.getState().setThinkingEffort(thinking_effort);
+    }
+
+    if (plan_mode !== undefined && plan_mode !== null) {
+      draft.planMode = plan_mode;
+    }
+
+    if (token_usage) {
+      addTokenUsage(draft.activeTokenUsage, {
+        input_other: token_usage.input_other || 0,
+        output: token_usage.output || 0,
+        input_cache_read: token_usage.input_cache_read || 0,
+        input_cache_creation: token_usage.input_cache_creation || 0,
+      });
+    }
+
+    draft.lastStatus = {
+      context_usage: context_usage ?? draft.lastStatus?.context_usage,
+      token_usage,
+      retrying: retrying ?? draft.lastStatus?.retrying,
+    };
+
+    const last = getLastAssistant(draft);
+
+    if (last) {
+      last.status = draft.lastStatus;
+    }
+  },
+
+  SteerInput: (draft, payload: { user_input: string | ContentPart[] }) => {
+    const last = getLastAssistant(draft);
+    if (!last?.steps) return;
+
+    const currentStep = last.steps.at(-1);
+    if (!currentStep) return;
+
+    finishAllTextItems(last.steps);
+    currentStep.items.push({ type: "steer", content: payload.user_input });
+  },
+};
+
+export function processEvent(draft: ChatState, event: UIStreamEvent): void {
+  const handler = eventHandlers[event.type];
+
+  if (handler) {
+    const payload = "payload" in event ? event.payload : event;
+    handler(draft, payload);
+  }
+}
diff --git a/apps/vscode/webview-ui/src/stores/index.ts b/apps/vscode/webview-ui/src/stores/index.ts
new file mode 100644
index 000000000..850016005
--- /dev/null
+++ b/apps/vscode/webview-ui/src/stores/index.ts
@@ -0,0 +1,20 @@
+export { useChatStore } from "./chat.store";
+export type { ChatMessage, UIStep, UIStepItem, UIToolCall, MediaInConversation, TokenUsage, QueuedItem } from "./chat.store";
+
+export { useSettingsStore } from "./settings.store";
+export {
+  DEFAULT_EXTENSION_CONFIG,
+  getMediaFallbackModel,
+  getModelThinkingMode,
+  getModelById,
+  getModelsForMedia,
+  groupModelsByProvider,
+  isImageModel,
+  isVideoModel,
+  providerDisplayName,
+  requiresManagedProviderLogin,
+} from "./settings.store";
+export type { MediaRequirements, ModelProviderGroup } from "./settings.store";
+
+export { useApprovalStore } from "./approval.store";
+export type { ApprovalRequest } from "./approval.store";
diff --git a/apps/vscode/webview-ui/src/stores/settings.store.ts b/apps/vscode/webview-ui/src/stores/settings.store.ts
new file mode 100644
index 000000000..564dd9407
--- /dev/null
+++ b/apps/vscode/webview-ui/src/stores/settings.store.ts
@@ -0,0 +1,309 @@
+import { create } from "zustand";
+import { bridge } from "@/services";
+import { toast } from "@/components/ui/sonner";
+import type { ExtensionConfig } from "shared/types";
+import type { MCPServerConfig, ModelConfig, ThinkingMode, SlashCommandInfo } from "shared/legacy-sdk";
+
+let settingsSaveRevision = 0;
+const MANAGED_KIMI_CODE_PROVIDER = "managed:kimi-code";
+
+function saveConfigWithRollback(
+  config: Parameters<typeof bridge.saveConfig>[0],
+  rollback: Partial<SettingsState>,
+  set: (state: Partial<SettingsState>) => void,
+): void {
+  const revision = ++settingsSaveRevision;
+  void bridge.saveConfig(config).catch((error: unknown) => {
+    // A later selection supersedes this request; rolling an older request back
+    // would overwrite the user's latest choice.
+    if (revision !== settingsSaveRevision) return;
+    set(rollback);
+    toast.error(`Failed to save model settings: ${error instanceof Error ? error.message : String(error)}`);
+  });
+}
+
+export const DEFAULT_EXTENSION_CONFIG: ExtensionConfig = {
+  yoloMode: false,
+  autosave: true,
+  useCtrlEnterToSend: false,
+  enableNewConversationShortcut: false,
+  showThinkingContent: true,
+  showThinkingExpanded: true,
+  version: "",
+};
+
+/** Metadata-driven only; mirrors the TUI's thinkingAvailability rules. */
+export function getModelThinkingMode(model: ModelConfig): ThinkingMode {
+  if ((model.support_efforts?.length ?? 0) > 0) {
+    return "effort";
+  }
+  if (model.capabilities.includes("always_thinking")) {
+    return "always";
+  }
+  if (model.capabilities.includes("thinking") || model.adaptive_thinking === true) {
+    return "switch";
+  }
+  return "none";
+}
+
+export function providerDisplayName(provider: string): string {
+  if (provider === MANAGED_KIMI_CODE_PROVIDER) return "Kimi Code";
+  if (provider.startsWith("managed:")) return provider.slice("managed:".length);
+  return provider;
+}
+
+export interface ModelProviderGroup {
+  provider: string;
+  label: string;
+  models: ModelConfig[];
+}
+
+export function groupModelsByProvider(models: ModelConfig[]): ModelProviderGroup[] {
+  const grouped = new Map<string, ModelConfig[]>();
+  for (const model of models) {
+    const group = grouped.get(model.provider);
+    if (group === undefined) {
+      grouped.set(model.provider, [model]);
+    } else {
+      group.push(model);
+    }
+  }
+  return [...grouped.entries()]
+    .map(([provider, providerModels]) => ({
+      provider,
+      label: providerDisplayName(provider),
+      models: providerModels.toSorted((left, right) => left.name.localeCompare(right.name)),
+    }))
+    .toSorted((left, right) => left.label.localeCompare(right.label));
+}
+
+export function requiresManagedProviderLogin(
+  models: ModelConfig[],
+  defaultModel: string | null,
+  loggedIn: boolean,
+): boolean {
+  if (loggedIn) return false;
+  const activeModel = getModelById(models, defaultModel ?? "") ?? models[0];
+  return activeModel?.provider === MANAGED_KIMI_CODE_PROVIDER;
+}
+
+function defaultEffortForModel(model: ModelConfig, defaultThinking: boolean, configuredEffort?: string): string {
+  const mode = getModelThinkingMode(model);
+  if (mode === "none") return "off";
+  const efforts = model.support_efforts ?? [];
+  if (efforts.length > 0) {
+    const alwaysOn = model.capabilities.includes("always_thinking");
+    if (!defaultThinking && !alwaysOn) return "off";
+    if (configuredEffort && efforts.includes(configuredEffort)) return configuredEffort;
+    if (model.default_effort && efforts.includes(model.default_effort)) return model.default_effort;
+    return efforts[Math.floor(efforts.length / 2)] ?? "off";
+  }
+  if (mode === "always") return "on";
+  return defaultThinking ? "on" : "off";
+}
+
+export function isImageModel(model: ModelConfig): boolean {
+  return model.capabilities.includes("image_in");
+}
+
+export function isVideoModel(model: ModelConfig): boolean {
+  return model.capabilities.includes("video_in");
+}
+
+export function getModelById(models: ModelConfig[], id: string): ModelConfig | undefined {
+  return models.find((m) => m.id === id);
+}
+
+export interface MediaRequirements {
+  image: boolean;
+  video: boolean;
+}
+
+export function getModelsForMedia(models: ModelConfig[], mediaReq: MediaRequirements): ModelConfig[] {
+  return models.filter((m) => {
+    if (mediaReq.image && !isImageModel(m)) {
+      return false;
+    }
+    if (mediaReq.video && !isVideoModel(m)) {
+      return false;
+    }
+    return true;
+  });
+}
+
+export function getMediaFallbackModel(
+  compatibleModels: ModelConfig[],
+  currentModel?: ModelConfig,
+): ModelConfig | undefined {
+  return compatibleModels.find((model) => model.provider === currentModel?.provider)
+    ?? compatibleModels[0];
+}
+
+interface SettingsState {
+  currentModel: string;
+  thinkingEffort: string;
+  extensionConfig: ExtensionConfig;
+  mcpServers: MCPServerConfig[];
+  mcpModalOpen: boolean;
+  workDirModalOpen: boolean;
+  currentWorkDir: string | null;
+  workspaceRoot: string | null;
+  models: ModelConfig[];
+  defaultModel: string | null;
+  defaultThinking: boolean;
+  defaultThinkingEffort?: string;
+  modelsLoaded: boolean;
+  wireSlashCommands: SlashCommandInfo[];
+  slashCommands: SlashCommandInfo[];
+  isLoggedIn: boolean;
+
+  setCurrentModel: (model: string) => void;
+  setThinkingEffort: (effort: string) => void;
+  updateModel: (modelId: string) => void;
+  toggleThinking: () => void;
+  selectThinkingEffort: (effort: string) => void;
+  setExtensionConfig: (config: ExtensionConfig) => void;
+  setMCPServers: (servers: MCPServerConfig[]) => void;
+  setMCPModalOpen: (open: boolean) => void;
+  setWorkDirModalOpen: (open: boolean) => void;
+  setCurrentWorkDir: (workDir: string | null) => void;
+  setWorkspaceRoot: (root: string | null) => void;
+  initModels: (models: ModelConfig[], defaultModel: string | null, defaultThinking: boolean, defaultThinkingEffort?: string) => void;
+  setWireSlashCommands: (commands: SlashCommandInfo[]) => void;
+  setIsLoggedIn: (loggedIn: boolean) => void;
+  getCurrentThinkingMode: () => ThinkingMode;
+}
+
+export const useSettingsStore = create<SettingsState>((set, get) => ({
+  currentModel: "",
+  thinkingEffort: "off",
+  extensionConfig: DEFAULT_EXTENSION_CONFIG,
+  mcpServers: [],
+  mcpModalOpen: false,
+  workDirModalOpen: false,
+  currentWorkDir: null,
+  workspaceRoot: null,
+  models: [],
+  defaultModel: null,
+  defaultThinking: false,
+  modelsLoaded: false,
+  wireSlashCommands: [],
+  slashCommands: [],
+  isLoggedIn: false,
+
+  setCurrentModel: (currentModel) => set({ currentModel }),
+
+  setThinkingEffort: (thinkingEffort) => set({ thinkingEffort }),
+
+  updateModel: (modelId) => {
+    const { models, defaultThinking, defaultThinkingEffort, currentModel, thinkingEffort: previousEffort } = get();
+    const model = getModelById(models, modelId);
+    if (!model) {
+      return;
+    }
+
+    const thinkingEffort = defaultEffortForModel(model, defaultThinking, defaultThinkingEffort);
+    set({ currentModel: modelId, thinkingEffort });
+    saveConfigWithRollback(
+      { model: modelId, thinking: thinkingEffort !== "off", effort: thinkingEffort },
+      { currentModel, thinkingEffort: previousEffort },
+      set,
+    );
+  },
+
+  toggleThinking: () => {
+    const { models, currentModel, thinkingEffort, defaultThinking } = get();
+    const model = getModelById(models, currentModel);
+    if (!model) {
+      return;
+    }
+
+    const thinkingMode = getModelThinkingMode(model);
+    if (thinkingMode !== "switch") {
+      return;
+    } // Can only toggle in switch mode
+
+    const newEffort = thinkingEffort === "off" ? "on" : "off";
+    set({ thinkingEffort: newEffort, defaultThinking: newEffort !== "off" });
+    saveConfigWithRollback(
+      { model: currentModel, thinking: newEffort !== "off", effort: newEffort },
+      { thinkingEffort, defaultThinking },
+      set,
+    );
+  },
+
+  selectThinkingEffort: (effort) => {
+    const { models, currentModel, thinkingEffort: previousEffort, defaultThinking, defaultThinkingEffort } = get();
+    const model = getModelById(models, currentModel);
+    if (!model) return;
+    // Match the TUI's commitEffort rule: a boolean "on" never reaches the
+    // engine for effort-capable models; resolve it to the model's default
+    // effort first. "on" remains valid only for genuine boolean models.
+    let thinkingEffort = effort;
+    if (thinkingEffort === "on" && getModelThinkingMode(model) === "effort") {
+      thinkingEffort = defaultEffortForModel(model, true, defaultThinkingEffort);
+    }
+    const allowed = model.support_efforts ?? [];
+    const alwaysOn = model.capabilities.includes("always_thinking");
+    if (thinkingEffort !== "off" && thinkingEffort !== "on" && !allowed.includes(thinkingEffort)) return;
+    if (alwaysOn && thinkingEffort === "off") return;
+    set({
+      thinkingEffort,
+      defaultThinking: thinkingEffort !== "off",
+      defaultThinkingEffort: thinkingEffort !== "off" && thinkingEffort !== "on" ? thinkingEffort : undefined,
+    });
+    saveConfigWithRollback(
+      { model: currentModel, thinking: thinkingEffort !== "off", effort: thinkingEffort },
+      { thinkingEffort: previousEffort, defaultThinking, defaultThinkingEffort },
+      set,
+    );
+  },
+
+  setExtensionConfig: (extensionConfig) => set({ extensionConfig }),
+
+  setMCPServers: (mcpServers) => set({ mcpServers }),
+
+  setMCPModalOpen: (mcpModalOpen) => set({ mcpModalOpen }),
+
+  setWorkDirModalOpen: (workDirModalOpen) => set({ workDirModalOpen }),
+
+  setCurrentWorkDir: (currentWorkDir) => set({ currentWorkDir }),
+
+  setWorkspaceRoot: (workspaceRoot) => set({ workspaceRoot }),
+
+  initModels: (models, defaultModel, defaultThinking, defaultThinkingEffort) => {
+    settingsSaveRevision += 1;
+    const initialModel = defaultModel || models[0]?.id || "";
+    const model = getModelById(models, initialModel);
+
+    const thinkingEffort = model ? defaultEffortForModel(model, defaultThinking, defaultThinkingEffort) : "off";
+
+    set({
+      models,
+      defaultModel,
+      defaultThinking,
+      defaultThinkingEffort,
+      modelsLoaded: true,
+      currentModel: initialModel,
+      thinkingEffort,
+    });
+  },
+
+  setWireSlashCommands: (commands) => {
+    set({
+      wireSlashCommands: commands,
+      slashCommands: commands,
+    });
+  },
+
+  setIsLoggedIn: (isLoggedIn) => set({ isLoggedIn }),
+
+  getCurrentThinkingMode: () => {
+    const { models, currentModel } = get();
+    const model = getModelById(models, currentModel);
+    if (!model) {
+      return "none";
+    }
+    return getModelThinkingMode(model);
+  },
+}));
diff --git a/apps/vscode/webview-ui/src/styles/index.css b/apps/vscode/webview-ui/src/styles/index.css
new file mode 100644
index 000000000..b06cbe9bd
--- /dev/null
+++ b/apps/vscode/webview-ui/src/styles/index.css
@@ -0,0 +1,200 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "shadcn/tailwind.css";
+@import "@fontsource-variable/inter";
+@import "katex/dist/katex.min.css";
+
+@custom-variant dark (&:is(.dark *));
+
+:root {
+  --radius: 0.5rem;
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.141 0.005 285.823);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.141 0.005 285.823);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.141 0.005 285.823);
+  --primary: oklch(0.21 0.006 285.885);
+  --primary-foreground: oklch(1 0 0);
+  --secondary: oklch(0.967 0.001 286.375);
+  --secondary-foreground: oklch(0.21 0.006 285.885);
+  --muted: oklch(0.967 0.001 286.375);
+  --muted-foreground: oklch(0.552 0.016 285.938);
+  --accent: oklch(0.967 0.001 286.375);
+  --accent-foreground: oklch(0.21 0.006 285.885);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0.92 0.004 286.32);
+  --input: oklch(0.92 0.004 286.32);
+  --ring: oklch(0.552 0.016 285.938);
+}
+
+.dark {
+  --background: oklch(0.141 0.005 285.823);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.18 0.005 285.823);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.18 0.005 285.823);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.21 0.006 285.885);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.274 0.006 286.033);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.274 0.006 286.033);
+  --muted-foreground: oklch(0.705 0.015 286.067);
+  --accent: oklch(0.274 0.006 286.033);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(0.274 0.006 286.033);
+  --input: oklch(0.274 0.006 286.033);
+  --ring: oklch(0.552 0.016 285.938);
+}
+
+* {
+  border-color: var(--border);
+}
+
+html,
+body {
+  margin: 0;
+  padding: 0;
+  height: 100%;
+  overflow: hidden;
+}
+
+body {
+  font-family: var(--vscode-font-family, "Inter Variable", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif);
+  font-size: var(--vscode-font-size, 12px);
+  background-color: var(--background);
+  color: var(--foreground);
+}
+
+#root {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+@theme inline {
+  --font-sans: "Inter Variable", sans-serif;
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+  --text-xs: 0.795rem;
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground font-sans antialiased;
+  }
+}
+
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--muted-foreground);
+  border-radius: 3px;
+  opacity: 0.5;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  opacity: 0.8;
+}
+
+@keyframes cursor-blink {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0;
+  }
+}
+
+.animate-cursor {
+  animation: cursor-blink 1s step-end infinite;
+}
+
+@keyframes glow-pulse {
+  0%,
+  100% {
+    box-shadow: 0 0 4px rgba(59, 130, 246, 0.4);
+  }
+  50% {
+    box-shadow: 0 0 12px rgba(59, 130, 246, 0.8);
+  }
+}
+
+.step-indicator-active {
+  animation: glow-pulse 1.5s ease-in-out infinite;
+}
+
+.overflow-y-auto {
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+}
+
+@keyframes slide-in-from-bottom {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.animate-in {
+  animation-duration: 200ms;
+  animation-fill-mode: both;
+}
+
+.fade-in {
+  animation-name: slide-in-from-bottom;
+}
+
+.slide-in-from-bottom-2 {
+  --tw-enter-translate-y: 0.5rem;
+}
+
+.kbd {
+  display: inline-block;
+  min-width: 1.5em;
+  padding: 0.1em 0.4em;
+  margin-right: 0.4em;
+  font-family: var(--vscode-editor-font-family, monospace);
+  font-size: 0.9em;
+  background: var(--muted);
+  border-radius: 3px;
+  text-align: center;
+}
diff --git a/apps/vscode/webview-ui/src/vite-env.d.ts b/apps/vscode/webview-ui/src/vite-env.d.ts
new file mode 100644
index 000000000..11f02fe2a
--- /dev/null
+++ b/apps/vscode/webview-ui/src/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/apps/vscode/webview-ui/tsconfig.json b/apps/vscode/webview-ui/tsconfig.json
new file mode 100644
index 000000000..4e59bb53e
--- /dev/null
+++ b/apps/vscode/webview-ui/tsconfig.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["DOM", "DOM.Iterable", "ES2024"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "ignoreDeprecations": "6.0",
+    "paths": {
+      "@/*": ["./src/*"],
+      "shared/*": ["../shared/*"]
+    }
+  },
+  "include": ["src", "../test/settings-store.test.ts"]
+}
diff --git a/apps/vscode/webview-ui/vite.config.ts b/apps/vscode/webview-ui/vite.config.ts
new file mode 100644
index 000000000..f4ab0a9e2
--- /dev/null
+++ b/apps/vscode/webview-ui/vite.config.ts
@@ -0,0 +1,38 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import cssInjectedByJsPlugin from "vite-plugin-css-injected-by-js";
+import { resolve } from "node:path";
+
+const webviewRoot = import.meta.dirname;
+
+export default defineConfig({
+  root: webviewRoot,
+  plugins: [react(), tailwindcss(), cssInjectedByJsPlugin()],
+  publicDir: resolve(webviewRoot, "public"),
+  resolve: {
+    alias: {
+      "@": resolve(webviewRoot, "./src"),
+      shared: resolve(webviewRoot, "../shared"),
+    },
+  },
+  define: {
+    "process.env.NODE_ENV": '"production"',
+  },
+  build: {
+    outDir: resolve(webviewRoot, "../dist"),
+    emptyOutDir: false,
+    lib: {
+      entry: resolve(webviewRoot, "src/main.tsx"),
+      name: "KimiWebview",
+      fileName: () => "webview.js",
+      formats: ["iife"],
+    },
+    rollupOptions: {
+      output: {
+        entryFileNames: "webview.js",
+        assetFileNames: "webview.css",
+      },
+    },
+  },
+});
diff --git a/docs/en/configuration/config-files.md b/docs/en/configuration/config-files.md
index 58199d5d7..933f282cc 100644
--- a/docs/en/configuration/config-files.md
+++ b/docs/en/configuration/config-files.md
@@ -52,7 +52,7 @@ effort = "high"
 keep = "all"
 
 [loop_control]
-max_retries_per_step = 3
+max_retries_per_step = 10
 reserved_context_size = 50000
 
 [background]
@@ -198,7 +198,7 @@ You can also switch models temporarily without touching the config file — by s
 | Field | Type | Default | Description |
 | --- | --- | --- | --- |
 | `max_steps_per_turn` | `integer` | — | Maximum steps per turn; unset or `0` means unlimited |
-| `max_retries_per_step` | `integer` | `3` | Maximum retries after a step failure |
+| `max_retries_per_step` | `integer` | `10` | Maximum retries after a step failure |
 | `reserved_context_size` | `integer` | — | Number of tokens reserved for model output; automatic compaction is triggered when the remaining context window falls below this value |
 
 ## `background`
@@ -210,20 +210,21 @@ You can also switch models temporarily without touching the config file — by s
 | `max_running_tasks` | `integer` | — | Maximum number of background tasks running concurrently |
 | `keep_alive_on_exit` | `boolean` | `false` | Whether to keep still-running background tasks when the session closes. By default, Kimi Code requests that all background tasks stop before the process exits; set this to `true` only when you want tasks to outlive the session. In print mode (`kimi -p`), this is only a legacy fallback used when `print_background_mode` is unset: `true` is equivalent to `print_background_mode = "drain"` |
 | `kill_grace_period_ms` | `integer` | `5000` | Grace period in milliseconds after session close, a manual stop, or a task timeout requests graceful termination. If a task is still running after this period, Kimi Code attempts to force-stop it |
-| `bash_auto_background_on_timeout` | `boolean` | `true` | When a foreground `Bash` command hits its timeout, move it to a background task instead of killing it — the agent is notified when it completes, and the backgrounded command is bounded by the 600s default background timeout. Set to `false` to kill timed-out foreground commands instead |
-| `print_background_mode` | `"exit" \| "drain" \| "steer"` | `"exit"` | Print mode (`kimi -p`) only. Governs how pending background tasks are handled once the main agent's turn ends: `"exit"` exits immediately; `"drain"` waits for every background task to reach a terminal state before exiting (results are not fed back to the main agent); `"steer"` stays alive so a completing background task — like a background subagent — injects a synthetic user message that steers the main agent into a new turn, looping until a turn ends with no pending background tasks or a limit is hit. Takes precedence over the `keep_alive_on_exit` print fallback |
-| `print_wait_ceiling_s` | `integer` | `3600` | In print mode (`kimi -p`), the wall-clock ceiling (seconds) for the wait/steer loop when `print_background_mode` is `"drain"` or `"steer"`. Has no effect outside print mode or when it is `"exit"` |
-| `print_max_turns` | `integer` | `50` | In print mode (`kimi -p`) with `print_background_mode = "steer"`, the maximum number of new turns that may be triggered by background-task completions, to keep the steering loop bounded |
+| `bash_auto_background_on_timeout` | `boolean` | `true` | When a foreground `Bash` command hits its timeout, move it to a background task instead of killing it — the agent is notified when it completes, and the backgrounded command is bounded by the `bash_task_timeout_s` default background timeout. Set to `false` to kill timed-out foreground commands instead |
+| `bash_task_timeout_s` | `integer` | `600` | Default timeout (seconds) for background `Bash` tasks when the call omits `timeout`; also used to re-arm foreground commands moved to the background on timeout. `0` means no timeout — the task runs until it exits or the model stops it. Explicit per-call `timeout` values are unaffected. In print mode (`kimi -p`) the default is `0` unless explicitly set |
+| `print_background_mode` | `"exit" \| "drain" \| "steer"` | `"steer"` | Print mode (`kimi -p`) only. Governs how pending background tasks are handled once the main agent's turn ends: `"exit"` exits immediately; `"drain"` waits for every background task to reach a terminal state before exiting (results are not fed back to the main agent); `"steer"` stays alive so a completing background task — like a background subagent — injects a synthetic user message that steers the main agent into a new turn, looping until a turn ends with no pending background tasks or a limit is hit. Takes precedence over the `keep_alive_on_exit` print fallback |
+| `print_wait_ceiling_s` | `integer` | `315360000` | In print mode (`kimi -p`), the wall-clock ceiling (seconds) for the wait/steer loop when `print_background_mode` is `"drain"` or `"steer"` (the default is 10 years — effectively unbounded). Has no effect outside print mode or when it is `"exit"` |
+| `print_max_turns` | `integer` | `100000` | In print mode (`kimi -p`) with `print_background_mode = "steer"`, the maximum number of new turns that may be triggered by background-task completions, to keep the steering loop bounded (the default is effectively unbounded) |
 
 `keep_alive_on_exit` can be overridden by the `KIMI_CODE_BACKGROUND_KEEP_ALIVE_ON_EXIT` environment variable, which takes higher priority than `config.toml`.
 
-In print mode (`kimi -p "<prompt>"`), Kimi Code by default runs a single non-interactive turn and exits as soon as the main agent finishes (`print_background_mode = "exit"`). If you launch background tasks (for example, concurrent subagents via `Agent(run_in_background=true)`, or a long command via `Bash(run_in_background=true)`) and need them to run to completion, set `print_background_mode` to `"drain"` (wait for them to finish, without feeding results back) or `"steer"` (feed each completion back to the main agent, starting a new turn so it can act on the result). `"steer"` is useful when the main agent should keep working based on the outcome of a long background task (e.g. training or evaluation); its total wall-clock is bounded by `print_wait_ceiling_s` and the number of extra turns by `print_max_turns`.
+In print mode (`kimi -p "<prompt>"`), Kimi Code stays alive after the main agent's turn as long as background tasks are still pending: each completion is fed back to the main agent as a synthetic user message, steering it into a new turn (`print_background_mode = "steer"` by default), and the run exits once a turn ends with nothing pending. The loop is bounded by `print_wait_ceiling_s` and `print_max_turns`, both effectively unbounded by default. Background work is never killed by a wall-clock cap in print mode either: background `Bash` tasks default to no timeout (`bash_task_timeout_s = 0`), and subagents run without a timeout (`[subagent] timeout_ms = 0`), so only the model itself stops a task. Set `print_background_mode` to `"drain"` to wait for tasks without feeding results back, or `"exit"` to end the run as soon as the main agent finishes.
 
 ## `subagent`
 
 | Field | Type | Default | Description |
 | --- | --- | --- | --- |
-| `timeout_ms` | `integer` | `7200000` (2 hours) | Maximum wall-clock time (milliseconds) a single subagent (`Agent` / `AgentSwarm`) is allowed to run before it is settled as `timed_out`. Set a very large value (e.g. `259200000`, i.e. 3 days) to effectively lift the cap. This is the background-task manager's per-task timeout for each subagent task, so it applies to both foreground and background subagents. Note: any value above `2147483647` (about 24.8 days) is clamped to 1ms by the runtime. |
+| `timeout_ms` | `integer` | `7200000` (2 hours) | Maximum wall-clock time (milliseconds) a single subagent (`Agent` / `AgentSwarm`) is allowed to run before it is settled as `timed_out`. `0` means no timeout — the subagent runs until it finishes or the model stops it. This is the background-task manager's per-task timeout for each subagent task, so it applies to both foreground and background subagents. In print mode (`kimi -p`) the default is `0` unless explicitly set. Note: any value above `2147483647` (about 24.8 days) is clamped to roughly 24.8 days by the runtime |
 
 `timeout_ms` can be overridden by the `KIMI_SUBAGENT_TIMEOUT_MS` environment variable, which takes higher priority than `config.toml`.
 
diff --git a/docs/en/customization/agents.md b/docs/en/customization/agents.md
index 4eb0b753b..909848a24 100644
--- a/docs/en/customization/agents.md
+++ b/docs/en/customization/agents.md
@@ -12,6 +12,8 @@ Kimi Code CLI includes three built-in sub-agents, ready to use out of the box, e
 - **`explore`**: Dedicated to codebase exploration; performs read-only operations only and does not modify any files. Ideal for quickly searching, reading, and summarizing a repository without touching files.
 - **`plan`**: Dedicated to implementation planning and architecture design; even shell commands are not available, keeping the focus on "figuring out how to do something" rather than "actually doing it."
 
+A `coder` sub-agent shares most of the main Agent's tool set: it can run shell commands in the background, maintain todo lists, enter Plan mode, invoke Agent Skills, and dispatch its own nested sub-agents when a task decomposes naturally. If it finishes its turn while background tasks are still running, its run only reports completion after those tasks settle, so the parent receives the result after the underlying work has actually finished.
+
 ## How to Invoke
 
 Sub-agents are scheduled automatically by the main Agent — based on task complexity, context consumption, and sub-task independence, they are dispatched at the right moment without the user having to specify one.
@@ -29,7 +31,7 @@ This isolation provides two benefits:
 - **The main Agent's context stays lean** and is not filled with large volumes of exploratory logs during long sessions.
 - **Multiple sub-agents can run in parallel** without interfering with each other.
 
-Note that each sub-agent independently consumes model tokens. For simple tasks, there is no need to dispatch a sub-agent — the main Agent handles them more economically. Sub-agents also cannot themselves schedule further nested sub-agents.
+Note that each sub-agent independently consumes model tokens. For simple tasks, there is no need to dispatch a sub-agent — the main Agent handles them more economically.
 
 ## Permission Inheritance
 
diff --git a/docs/en/guides/goals.md b/docs/en/guides/goals.md
index ff2fa0cb6..65cf4a781 100644
--- a/docs/en/guides/goals.md
+++ b/docs/en/guides/goals.md
@@ -108,7 +108,7 @@ Write stop conditions into the objective. `/goal` does not have a separate stop-
 
 The web UI shows the current goal in a strip below the conversation. Select the strip to expand or collapse its details. When a token budget is configured, the header shows its progress; goals without a token budget do not show a progress bar.
 
-Use the strip actions to pause an active goal, resume a paused or blocked goal, or cancel the current goal. Cancellation requires confirmation because it cannot be resumed afterwards.
+Use the strip actions to pause an active goal, resume a paused or blocked goal, or cancel the current goal. Selecting Resume starts the next goal turn so the agent continues the work. Cancellation requires confirmation because it cannot be resumed afterwards.
 
 ## Queue upcoming goals
 
diff --git a/docs/en/reference/slash-commands.md b/docs/en/reference/slash-commands.md
index f74812c0e..a84271a14 100644
--- a/docs/en/reference/slash-commands.md
+++ b/docs/en/reference/slash-commands.md
@@ -122,6 +122,7 @@ Kimi Code CLI ships with a set of built-in Skills that appear directly as `/<nam
 | `/mcp-config` | Configure MCP servers and handle MCP OAuth login. See [MCP](../customization/mcp.md) |
 | `/custom-theme [<text>]` | Create or edit a custom TUI color theme. See [Themes](../customization/themes.md) |
 | `/update-config` | Inspect or edit `config.toml` (model, provider, permission, hooks) and `tui.toml` (theme, editor, notifications, auto-update) |
+| `/check-kimi-code-docs` | Answer Kimi Code product questions (CLI usage, configuration, membership, error codes) against the official docs |
 | `/import-from-cc-codex` | Import Claude Code and Codex instructions, skills, and MCP settings into Kimi Code |
 | `/sub-skill` | Discover and reorganize the local skill inventory into hierarchical sub-skill bundles. Includes `/sub-skill.review` (read-only proposal) and `/sub-skill.consolidate` (apply the reorganization) |
 
diff --git a/docs/en/reference/tools.md b/docs/en/reference/tools.md
index 132416e01..8854caefc 100644
--- a/docs/en/reference/tools.md
+++ b/docs/en/reference/tools.md
@@ -40,11 +40,11 @@ File tools handle reading, writing, and searching the local filesystem — the f
 - `command` (required): the shell command to execute
 - `cwd`: working directory
 - `timeout`: timeout in milliseconds; foreground default is 60 seconds, maximum is 5 minutes
-- `run_in_background`: whether to run as a background task; background tasks default to a 10-minute timeout
+- `run_in_background`: whether to run as a background task; background tasks default to a 10-minute timeout (no timeout by default in print mode `kimi -p`)
 - `description`: background task description; required when `run_in_background=true`
 - `disable_timeout`: whether to remove the timeout limit for background tasks
 
-Foreground mode blocks the current turn until the command completes or times out, and the TUI streams stdout and stderr into the running `Bash` tool card while the command is still active. By default, a foreground command that hits its timeout is not killed — it keeps running as a background task (bounded by the 600s default background timeout); to restore kill-on-timeout, set [`bash_auto_background_on_timeout`](../configuration/config-files.md#background) to `false` under `[background]`. Background mode returns a task ID immediately and automatically notifies the Agent when the task finishes. stdin is always closed — interactive commands receive EOF immediately. A two-phase termination strategy (SIGTERM → 5-second grace period → SIGKILL) ensures reliable process cleanup when a task is stopped or hits its background timeout. On Windows, Git Bash is used by default.
+Foreground mode blocks the current turn until the command completes or times out, and the TUI streams stdout and stderr into the running `Bash` tool card while the command is still active. By default, a foreground command that hits its timeout is not killed — it keeps running as a background task (bounded by the 600s default background timeout); to restore kill-on-timeout, set [`bash_auto_background_on_timeout`](../configuration/config-files.md#background) to `false` under `[background]`. The 600s background default is configurable via [`bash_task_timeout_s`](../configuration/config-files.md#background) (`0` = no timeout) and defaults to no timeout in print mode (`kimi -p`). Background mode returns a task ID immediately and automatically notifies the Agent when the task finishes. stdin is always closed — interactive commands receive EOF immediately. A two-phase termination strategy (SIGTERM → 5-second grace period → SIGKILL) ensures reliable process cleanup when a task is stopped or hits its background timeout. On Windows, Git Bash is used by default.
 
 ## Web Tools
 
@@ -89,7 +89,7 @@ Collaboration tools handle inter-Agent coordination, user interaction, and Skill
 | `AskUserQuestion` | Auto-allow | Ask the user a question to gather structured input |
 | `Skill` | Auto-allow | Invoke a registered inline Skill |
 
-**`Agent`** delegates a subtask to a sub-Agent. Required parameters: `prompt` (complete task description) and `description` (a 3–5 word short summary). Optional parameters: `subagent_type` (defaults to `coder`), `resume` (ID of an existing Agent to resume; mutually exclusive with `subagent_type`), and `run_in_background` (defaults to false). Agent tasks time out after 2 hours by default; the limit is configurable via `[subagent] timeout_ms` in `config.toml` (or the `KIMI_SUBAGENT_TIMEOUT_MS` env var). In foreground mode the parent Agent waits for the sub-Agent to complete before continuing; in background mode a task ID is returned immediately and the result is automatically delivered back to the main Agent via a synthetic User message when done. When several foreground `Agent` calls run in the same step, the TUI groups them and shows each subagent's running, waiting, completed, or failed status with elapsed time. See [Agent & Sub-Agents](../customization/agents.md) for details.
+**`Agent`** delegates a subtask to a sub-Agent. Required parameters: `prompt` (complete task description) and `description` (a 3–5 word short summary). Optional parameters: `subagent_type` (defaults to `coder`), `resume` (ID of an existing Agent to resume; mutually exclusive with `subagent_type`), and `run_in_background` (defaults to false). Agent tasks time out after 2 hours by default; the limit is configurable via `[subagent] timeout_ms` in `config.toml` (`0` = no timeout, or the `KIMI_SUBAGENT_TIMEOUT_MS` env var), and defaults to no timeout in print mode (`kimi -p`). In foreground mode the parent Agent waits for the sub-Agent to complete before continuing; in background mode a task ID is returned immediately and the result is automatically delivered back to the main Agent via a synthetic User message when done. When several foreground `Agent` calls run in the same step, the TUI groups them and shows each subagent's running, waiting, completed, or failed status with elapsed time. See [Agent & Sub-Agents](../customization/agents.md) for details.
 
 **`AgentSwarm`** launches subagents from a shared `prompt_template` and an `items` array, resumes existing subagents through `resume_agent_ids`, or combines both in one call. The template must contain the `{{item}}` placeholder; each item replaces that placeholder and launches one new subagent. Pass `subagent_type` to choose the profile used by every spawned subagent in the swarm, or omit it to use `coder`. Without `resume_agent_ids`, the tool requires at least 2 items; with `resume_agent_ids`, it can resume one or more existing subagents. The tool supports up to 128 total subagents, waits for all subagents to finish, and returns an aggregated report. In the TUI, foreground swarms show a live `Agent swarm` progress panel above the input box. If a model response calls `AgentSwarm`, that call must be the only tool call in the response; to run multiple swarms, call one `AgentSwarm`, wait for its result, then call the next, or combine the work into one swarm when a single template can cover it. In `manual` permission mode, `AgentSwarm` calls outside active swarm mode request approval unless a permission rule allows them; while swarm mode is active, `AgentSwarm` itself is auto-approved. Permission rules match `AgentSwarm` by tool name only — argument patterns such as `AgentSwarm(swarm)` are not supported. By default the tool ramps up concurrency without an upper limit (5 subagents start immediately, then 1 more every 700 ms); set `KIMI_CODE_AGENT_SWARM_MAX_CONCURRENCY` to a positive integer to cap how many subagents run at the same time during that ramp, or leave it unset for no cap. If it is set to a value that is not a positive integer, the AgentSwarm call fails fast.
 
diff --git a/docs/en/release-notes/changelog.md b/docs/en/release-notes/changelog.md
index 1f3a76194..22980a26f 100644
--- a/docs/en/release-notes/changelog.md
+++ b/docs/en/release-notes/changelog.md
@@ -6,6 +6,107 @@ outline: 2
 
 This page documents the changes in each Kimi Code CLI release.
 
+## 0.26.0 (2026-07-16) Say hi to the BIIIG DAY!
+
+### Polish
+
+- Expand the coder subagent tool set to include background tasks, todo lists, plan mode, skill invocation, and nested agents, mirroring the main agent's capabilities.
+- Warn in the `/model` and `/effort` pickers that switching invalidates the existing prompt cache, and hint to use `/new` to avoid extra token costs.
+- web: Refresh the model catalog for all providers when opening the model picker, so newly available models always show up.
+- Optimize the unit formatting of the context usage display.
+
+### Bug Fixes
+
+- Fix a resumed session being marked as just updated and jumping to the top of the session list without any new activity.
+- Fix the context size indicator under-reporting the model's actual context usage.
+- Fix Kimi-provider models routed through the Anthropic protocol incorrectly showing reasoning effort options.
+- Honor an explicit thinking "off" on OpenAI-compatible (chat completions) providers.
+- Report when users stop tasks and preserve other stop reasons in model context.
+- Fix a race where resuming a background subagent right after it was manually stopped could fail with an "already running" error.
+- Replay empty thinking content verbatim instead of substituting a placeholder space on Anthropic-compatible and Kimi preserved-thinking endpoints.
+- Keep legacy migrations idempotent across multiple Kimi homes and report damaged or unmapped sessions instead of silently skipping them.
+- web: Fix the sidebar resize handle being covered by the chat composer background.
+
+## 0.25.0 (2026-07-16)
+
+### Features
+
+- web: Attach any file type in chat — files can be dropped anywhere in the window, and sent files, images, and videos show as chips in the message bubble.
+
+### Polish
+
+- web: Show full diagnostics for model request failures.
+- Apply official Anthropic effort profiles and a 128k output fallback for unknown models.
+
+### Bug Fixes
+
+- Fix the web server bearer-token check being bypassed by percent-encoded API paths, which allowed unauthenticated access to every API route.
+- Fix the session filesystem API following symlinks that point outside the workspace, which allowed accessing host files beyond the session directory.
+- web: Keep session activity indicators in sync with agent work and prevent duplicate streamed content after session activation races or LLM retries.
+- Fix custom-named models on Anthropic-compatible providers starting new sessions with thinking effort off and not showing the thinking control in ACP clients.
+- Honor adaptive_thinking = false on Anthropic-compatible models by omitting the effort parameter from requests.
+- web: Fix the Content-Security-Policy on non-loopback server binds blocking the web UI's theme bootstrap script and bundled fonts.
+- Fix sessions failing to be created when the workspace directory is given through a symlink.
+- Fix the CLI exiting unexpectedly when reading an image from the clipboard fails; it now falls back to pasting text.
+- web: Fix completed background subagents losing their final output after a session reload.
+- web: Fix Enter not confirming modal confirmation dialogs in dev builds.
+- web: Fix a background subagent showing up as two identical rows in the agents dock panel during streaming.
+- Fix the diagnostic log missing the actual error when the CLI exits unexpectedly.
+
+## 0.24.2 (2026-07-15)
+
+### Features
+
+- Add a builtin `/check-kimi-code-docs` skill that automatically answers Kimi Code product questions with official-docs sources.
+
+### Polish
+
+- Align `kimi -p` behavior across engines: `print_background_mode` and `print_max_turns` now apply, and `/goal` runs stay alive until the goal finishes.
+- `kimi -p` now stays alive by default while background tasks are pending, with no effective wait or turn limit, and feeds each completion back to the agent. Set `print_background_mode = "exit"` or `"drain"` to restore the old exit-after-one-turn behavior.
+- `kimi -p` background tasks and subagents no longer time out by default (interactive mode is unchanged); restore limits with `[background] bash_task_timeout_s` or `[subagent] timeout_ms`.
+- Subagent timeout now defaults to 2 hours everywhere; override with `[subagent] timeout_ms` or `KIMI_SUBAGENT_TIMEOUT_MS`.
+- The per-step LLM retry limit is raised from 3 to 10 attempts, so transient provider failures (429 / overload) are retried before a turn fails; tune with `loop_control.max_retries_per_step`.
+- Workspaces now stay in sync: new sessions register automatically, missing workspaces are restored at startup, and removed ones stay removed.
+- `kimi web` now logs failed requests and key operations so daemon issues are easier to diagnose.
+- web: AgentSwarm cards now stay expanded while subagents are still running.
+- web: Minimized plan review and question cards now use an upward chevron for expand.
+
+### Bug Fixes
+
+- web: Fix mobile layout on iOS, including the composer, safe areas, and toasts.
+- Fix new sessions not opening in older CLI versions.
+- Fix completion notifications firing early when a subagent finished while the main turn was still running.
+- Fix the web UI showing the wrong CLI version.
+- Fix Gemini tool call IDs colliding across turns and merging swarm runs into one card.
+- web: Show server error details when actions like stopping or archiving a session fail.
+- web: Fix long responses stalling after the tab was backgrounded.
+- web: Fix code block copy buttons over plain HTTP.
+- web: Keep loaded sessions visible when the session list fails to reload.
+- web: Restore the AgentSwarm member list after a page refresh.
+- web: Fix session titles not generating when the first message is a slash command.
+- web: Show each message's actual send time after reloading a session.
+- Fix several goal-mode issues around budgets and turn limits, pausing and resuming, crash recovery, final status messages, and invalid persisted goal records.
+- Fix replaced goals being able to affect the new goal's budget, and reject subagent goals consistently.
+- Correct the guidance shown when a goal cannot be paused or resumed.
+
+### Refactors
+
+- Rename the dynamic tool loading capability from `select_tools` to `dynamically_loaded_tools`; behavior is unchanged.
+
+## 0.24.1 (2026-07-14)
+
+### Bug Fixes
+
+- Fix Kimi sessions getting stuck when preserved-thinking history contains an empty reasoning step.
+- Fix built-in tools being unavailable when the model provider becomes ready after the session starts.
+- Fix Thinking effort routing: non-Kimi providers now preserve configured values, while Kimi models validate runtime selections and fall back safely during model resolution.
+- web: Align thinking-level handling with the CLI: submit the selected level verbatim instead of silently downgrading it, fall back to the model's own default when nothing was chosen or the model switches, and persist explicit picks as the default for new sessions.
+- Preserve goal completion summaries and show untyped LLM errors without an internal error-code prefix in step interruption events.
+
+### Polish
+
+- web: Show just the level name (e.g. Max) in the model pill instead of "thinking: max".
+
 ## 0.24.0 (2026-07-14)
 
 ### Features
diff --git a/docs/zh/configuration/config-files.md b/docs/zh/configuration/config-files.md
index 574bff2e2..529b16676 100644
--- a/docs/zh/configuration/config-files.md
+++ b/docs/zh/configuration/config-files.md
@@ -52,7 +52,7 @@ effort = "high"
 keep = "all"
 
 [loop_control]
-max_retries_per_step = 3
+max_retries_per_step = 10
 reserved_context_size = 50000
 
 [background]
@@ -198,7 +198,7 @@ display_name = "Kimi for Coding (custom)"
 | 字段 | 类型 | 默认值 | 说明 |
 | --- | --- | --- | --- |
 | `max_steps_per_turn` | `integer` | — | 单轮最大步数；不设或设为 `0` 则无上限 |
-| `max_retries_per_step` | `integer` | `3` | 单步失败后的最大重试次数 |
+| `max_retries_per_step` | `integer` | `10` | 单步失败后的最大重试次数 |
 | `reserved_context_size` | `integer` | — | 预留给模型输出的 token 数；上下文窗口剩余量低于此值时触发自动压缩 |
 
 ## `background`
@@ -210,20 +210,21 @@ display_name = "Kimi for Coding (custom)"
 | `max_running_tasks` | `integer` | — | 同时运行的最大后台任务数 |
 | `keep_alive_on_exit` | `boolean` | `false` | 会话关闭时是否保留仍在运行的后台任务。默认情况下，Kimi Code 会在进程退出前请求停止所有后台任务；只有希望任务在会话结束后继续运行时才设为 `true`。在 print 模式（`kimi -p`）下，本字段仅作为 `print_background_mode` 未设置时的兼容回退：`true` 等价于 `print_background_mode = "drain"` |
 | `kill_grace_period_ms` | `integer` | `5000` | 会话关闭、手动停止或任务超时请求正常终止后，等待任务自行结束的宽限时间（毫秒）。超过该时间仍在运行时，Kimi Code 会尝试强制停止该任务 |
-| `bash_auto_background_on_timeout` | `boolean` | `true` | 前台 `Bash` 命令触及超时时间时，将其转为后台任务而不是直接终止：命令完成时 agent 会收到通知，转入后台的命令受 600s 默认后台超时约束。设为 `false` 则恢复超时即终止的行为 |
-| `print_background_mode` | `"exit" \| "drain" \| "steer"` | `"exit"` | 仅 print 模式（`kimi -p`）生效，决定主 agent 的 turn 结束后如何处理未返回的后台任务：`"exit"` 立即退出；`"drain"` 退出前等待所有后台任务进入终态（结果不回馈给主 agent）；`"steer"` 不退出，让后台任务完成时像后台子代理一样以合成 user 消息 steer 主 agent 进入新 turn，直到某 turn 结束时无未决后台任务或触及上限。设置后优先级高于 `keep_alive_on_exit` 的 print 回退 |
-| `print_wait_ceiling_s` | `integer` | `3600` | print 模式（`kimi -p`）下，`print_background_mode` 为 `"drain"` 或 `"steer"` 时，等待/steer 循环的墙钟上限（秒）。在非 print 模式或 `"exit"` 时无效 |
-| `print_max_turns` | `integer` | `50` | print 模式（`kimi -p`）且 `print_background_mode = "steer"` 时，允许由后台任务完成触发的新 turn 的最大数量，防止 steer 循环失控 |
+| `bash_auto_background_on_timeout` | `boolean` | `true` | 前台 `Bash` 命令触及超时时间时，将其转为后台任务而不是直接终止：命令完成时 agent 会收到通知，转入后台的命令受 `bash_task_timeout_s` 默认后台超时约束。设为 `false` 则恢复超时即终止的行为 |
+| `bash_task_timeout_s` | `integer` | `600` | 后台 `Bash` 任务在调用未传 `timeout` 时的默认超时（秒）；前台命令超时转后台后也按此值重新计时。`0` 表示无超时——任务一直运行到自行结束或被模型手动停止。显式传入的 `timeout` 不受影响。在 print 模式（`kimi -p`）下未显式设置时默认为 `0` |
+| `print_background_mode` | `"exit" \| "drain" \| "steer"` | `"steer"` | 仅 print 模式（`kimi -p`）生效，决定主 agent 的 turn 结束后如何处理未返回的后台任务：`"exit"` 立即退出；`"drain"` 退出前等待所有后台任务进入终态（结果不回馈给主 agent）；`"steer"` 不退出，让后台任务完成时像后台子代理一样以合成 user 消息 steer 主 agent 进入新 turn，直到某 turn 结束时无未决后台任务或触及上限。设置后优先级高于 `keep_alive_on_exit` 的 print 回退 |
+| `print_wait_ceiling_s` | `integer` | `315360000` | print 模式（`kimi -p`）下，`print_background_mode` 为 `"drain"` 或 `"steer"` 时，等待/steer 循环的墙钟上限（秒；默认 10 年，近似不设限）。在非 print 模式或 `"exit"` 时无效 |
+| `print_max_turns` | `integer` | `100000` | print 模式（`kimi -p`）且 `print_background_mode = "steer"` 时，允许由后台任务完成触发的新 turn 的最大数量，防止 steer 循环失控（默认值近似不设限） |
 
 `keep_alive_on_exit` 可被环境变量 `KIMI_CODE_BACKGROUND_KEEP_ALIVE_ON_EXIT` 覆盖，优先级高于配置文件。
 
-在 print 模式（`kimi -p "<prompt>"`）下，Kimi Code 默认只跑一个非交互的单轮 turn，主 agent 一结束就退出（`print_background_mode = "exit"`）。如果你启动了后台任务（例如通过 `Agent(run_in_background=true)` 并发子代理，或 `Bash(run_in_background=true)` 的长命令）并希望它们跑完，可将 `print_background_mode` 设为 `"drain"`（等任务结束再退出，结果不回馈）或 `"steer"`（任务结束后把结果 steer 给主 agent，触发新 turn 继续处理）。`"steer"` 适合让主 agent 依据后台长任务（如训练、评测）的结果继续做后续步骤；其总耗时受 `print_wait_ceiling_s` 限制、额外 turn 数受 `print_max_turns` 限制。
+在 print 模式（`kimi -p "<prompt>"`）下，只要还有未决的后台任务，Kimi Code 在主 agent 的 turn 结束后不会退出：每个任务完成都会以合成 user 消息回馈给主 agent，steer 出新的 turn（默认 `print_background_mode = "steer"`），直到某 turn 结束时没有任何未决任务才退出。该循环受 `print_wait_ceiling_s` 与 `print_max_turns` 约束，默认值都近似不设限。print 模式下后台工作也不会被墙钟超时杀掉：后台 `Bash` 任务默认无超时（`bash_task_timeout_s = 0`），子代理默认无超时（`[subagent] timeout_ms = 0`），只有模型自己能停止任务。将 `print_background_mode` 设为 `"drain"` 可等待任务结束但不回馈结果，设为 `"exit"` 则在主 agent 结束后立即退出。
 
 ## `subagent`
 
 | 字段 | 类型 | 默认值 | 说明 |
 | --- | --- | --- | --- |
-| `timeout_ms` | `integer` | `7200000`（2 小时） | 单个子代理（`Agent` / `AgentSwarm`）允许运行的最长时间（毫秒）。超时后子代理以 `timed_out` 收尾。设为很大的值（例如 `259200000`，即 3 天）可近似取消上限。该值是后台任务管理器对每个子代理任务的 per-task timeout，因此对前台与后台子代理同时生效。注意：超过 `2147483647`（约 24.8 天）会被运行时钳成 1ms |
+| `timeout_ms` | `integer` | `7200000`（2 小时） | 单个子代理（`Agent` / `AgentSwarm`）允许运行的最长时间（毫秒）。超时后子代理以 `timed_out` 收尾。`0` 表示无超时——子代理一直运行到自行结束或被模型手动停止。该值是后台任务管理器对每个子代理任务的 per-task timeout，因此对前台与后台子代理同时生效。在 print 模式（`kimi -p`）下未显式设置时默认为 `0`。注意：超过 `2147483647`（约 24.8 天）的值会被运行时钳到约 24.8 天 |
 
 `timeout_ms` 可被环境变量 `KIMI_SUBAGENT_TIMEOUT_MS` 覆盖，优先级高于配置文件。
 
diff --git a/docs/zh/customization/agents.md b/docs/zh/customization/agents.md
index 5b754ada1..10d0bb9ed 100644
--- a/docs/zh/customization/agents.md
+++ b/docs/zh/customization/agents.md
@@ -12,6 +12,8 @@ Kimi Code CLI 内置三种子 Agent，开箱即用，分别面向不同任务形
 - **`explore`**：代码库探索专用，只做只读操作，不修改任何文件。适合在不改动文件的前提下快速搜索、阅读和总结仓库。
 - **`plan`**：实现规划与架构设计专用，连 Shell 命令都不提供，专注于"想清楚怎么做"而不是"动手做"。
 
+`coder` 子 Agent 与主 Agent 共享大部分工具集：可以在后台执行 Shell 命令、维护待办列表、进入 Plan 模式、调用 Agent Skills，也可以在任务自然拆解时继续派发自己的嵌套子 Agent。如果它结束自己的轮次时仍有后台任务在运行，那么只有在这些后台任务全部落定后，这次运行才会回报完成——主 Agent 拿到结果时，背后的工作也已经真正完成。
+
 ## 调用方式
 
 子 Agent 由主 Agent 自动调度——根据任务复杂度、上下文消耗和子任务的独立性，在适当时机派发，无需用户手动指定。
@@ -29,7 +31,7 @@ Kimi Code CLI 内置三种子 Agent，开箱即用，分别面向不同任务形
 - **主 Agent 上下文保持精炼**，长会话中不会被大量探索性日志撑满。
 - **多个子 Agent 可以并行运行**，互不干扰。
 
-需要注意的是，每个子 Agent 都会独立消耗模型 token。简单任务没有必要派发子 Agent，主 Agent 直接处理更经济。子 Agent 也不支持继续嵌套调度。
+需要注意的是，每个子 Agent 都会独立消耗模型 token。简单任务没有必要派发子 Agent，主 Agent 直接处理更经济。
 
 ## 权限继承
 
diff --git a/docs/zh/guides/goals.md b/docs/zh/guides/goals.md
index 64cf6b56b..104f3cbb1 100644
--- a/docs/zh/guides/goals.md
+++ b/docs/zh/guides/goals.md
@@ -108,7 +108,7 @@ Kimi Code 会保存该目标，把它作为下一条用户消息发送，并进
 
 Web 界面会在对话下方显示当前目标条。点击目标条可以展开或收起详细信息。配置 token 预算时，标题栏会显示预算进度；没有配置 token 预算的目标不会显示进度条。
 
-使用目标条中的操作可以暂停进行中的目标、继续已暂停或已阻塞的目标，或取消当前目标。取消操作需要确认，因为取消后无法继续。
+使用目标条中的操作可以暂停进行中的目标、继续已暂停或已阻塞的目标，或取消当前目标。点击继续会启动下一轮目标工作，Agent 会继续处理该目标。取消操作需要确认，因为取消后无法继续。
 
 ## 安排后续目标
 
diff --git a/docs/zh/reference/slash-commands.md b/docs/zh/reference/slash-commands.md
index 218010835..7692e06c9 100644
--- a/docs/zh/reference/slash-commands.md
+++ b/docs/zh/reference/slash-commands.md
@@ -120,6 +120,7 @@ Kimi Code CLI 随包内置了一组 Skill，直接以 `/<name>` 形式出现在
 | `/mcp-config` | 配置 MCP server 并处理 MCP OAuth 登录。详见 [MCP](../customization/mcp.md) |
 | `/custom-theme [<text>]` | 创建或编辑自定义 TUI 配色主题。详见 [主题](../customization/themes.md) |
 | `/update-config` | 查看或编辑 `config.toml`（模型、供应商、权限、hooks）和 `tui.toml`（主题、编辑器、通知、自动更新） |
+| `/check-kimi-code-docs` | 依据官方文档回答 Kimi Code 产品问题（CLI 用法、配置、会员、错误码） |
 | `/import-from-cc-codex` | 从 Claude Code 和 Codex 导入 instructions、skills 和 MCP 设置 |
 | `/sub-skill` | 发现并将本地 skill 库存重组为分层子 skill 包。包含 `/sub-skill.review`（只读提案）和 `/sub-skill.consolidate`（执行重组） |
 
diff --git a/docs/zh/reference/tools.md b/docs/zh/reference/tools.md
index 0c0fb1579..810ffc6b9 100644
--- a/docs/zh/reference/tools.md
+++ b/docs/zh/reference/tools.md
@@ -40,11 +40,11 @@
 - `command`（必填）：要执行的 Shell 命令
 - `cwd`：工作目录
 - `timeout`：超时时间（毫秒）；前台默认 60 秒、最长 5 分钟
-- `run_in_background`：是否以后台任务运行；后台默认 10 分钟超时
+- `run_in_background`：是否以后台任务运行；后台默认 10 分钟超时（print 模式 `kimi -p` 下默认无超时）
 - `description`：后台任务描述，`run_in_background=true` 时必填
 - `disable_timeout`：后台任务是否取消超时限制
 
-前台模式会阻塞当前轮次，直到命令结束或超时；命令运行期间，TUI 会把 stdout 和 stderr 流式显示在正在运行的 `Bash` 工具卡片中。前台命令超时后默认不会被终止，而是转为后台任务继续运行（受 600 秒默认后台超时约束）；如需恢复超时即终止的行为，将 `[background]` 的 [`bash_auto_background_on_timeout`](../configuration/config-files.md#background) 设为 `false`。后台模式立即返回任务 ID，任务结束时自动通知 Agent。stdin 始终被关闭，交互式命令会立即收到 EOF。任务被停止或后台超时时采用两阶段终止策略（SIGTERM → 5 秒宽限期 → SIGKILL），确保进程可靠结束。Windows 平台默认使用 Git Bash。
+前台模式会阻塞当前轮次，直到命令结束或超时；命令运行期间，TUI 会把 stdout 和 stderr 流式显示在正在运行的 `Bash` 工具卡片中。前台命令超时后默认不会被终止，而是转为后台任务继续运行（受 600 秒默认后台超时约束）；如需恢复超时即终止的行为，将 `[background]` 的 [`bash_auto_background_on_timeout`](../configuration/config-files.md#background) 设为 `false`。600 秒的默认后台超时可通过 [`bash_task_timeout_s`](../configuration/config-files.md#background) 配置（`0` = 无超时），且在 print 模式（`kimi -p`）下默认无超时。后台模式立即返回任务 ID，任务结束时自动通知 Agent。stdin 始终被关闭，交互式命令会立即收到 EOF。任务被停止或后台超时时采用两阶段终止策略（SIGTERM → 5 秒宽限期 → SIGKILL），确保进程可靠结束。Windows 平台默认使用 Git Bash。
 
 ## 网络类
 
@@ -89,7 +89,7 @@ Plan 模式是一种受约束的工作状态：进入后 `Write` 与 `Edit` 只
 | `AskUserQuestion` | 自动放行 | 向用户提问以获取结构化输入 |
 | `Skill` | 自动放行 | 调用已注册的 inline Skill |
 
-**`Agent`** 将子任务委托给子 Agent 执行。必填参数：`prompt`（完整任务描述）和 `description`（3–5 个词的简短说明）。可选参数：`subagent_type`（默认 `coder`）、`resume`（恢复已有 Agent 的 ID，与 `subagent_type` 互斥）和 `run_in_background`（默认 false）。Agent 任务默认 2 小时超时，可通过 `config.toml` 的 `[subagent] timeout_ms`（或 `KIMI_SUBAGENT_TIMEOUT_MS` 环境变量）配置。前台模式下父 Agent 等待子 Agent 完成再继续；后台模式立即返回任务 ID，完成时通过合成 User 消息自动回到主 Agent。多个前台 `Agent` 调用在同一步运行时，TUI 会合并展示，并为每个子 Agent 显示运行、等待、完成或失败状态以及已耗时长。子 Agent 体系细节见 [Agent 与子 Agent](../customization/agents.md)。
+**`Agent`** 将子任务委托给子 Agent 执行。必填参数：`prompt`（完整任务描述）和 `description`（3–5 个词的简短说明）。可选参数：`subagent_type`（默认 `coder`）、`resume`（恢复已有 Agent 的 ID，与 `subagent_type` 互斥）和 `run_in_background`（默认 false）。Agent 任务默认 2 小时超时，可通过 `config.toml` 的 `[subagent] timeout_ms`（`0` = 无超时，或 `KIMI_SUBAGENT_TIMEOUT_MS` 环境变量）配置，且在 print 模式（`kimi -p`）下默认无超时。前台模式下父 Agent 等待子 Agent 完成再继续；后台模式立即返回任务 ID，完成时通过合成 User 消息自动回到主 Agent。多个前台 `Agent` 调用在同一步运行时，TUI 会合并展示，并为每个子 Agent 显示运行、等待、完成或失败状态以及已耗时长。子 Agent 体系细节见 [Agent 与子 Agent](../customization/agents.md)。
 
 **`AgentSwarm`** 可以从共享的 `prompt_template` 和 `items` 数组启动子 Agent，也可以通过 `resume_agent_ids` 恢复已有子 Agent，或在一次调用中同时使用两者。模板必须包含 `{{item}}` 占位符；每个 item 会替换该占位符，并启动一个新的子 Agent。传入 `subagent_type` 可以指定整个 swarm 中所有新启动的子 Agent 使用的 profile；省略时默认使用 `coder`。不传 `resume_agent_ids` 时，本工具要求至少 2 个 item；传入 `resume_agent_ids` 时，可以恢复 1 个或多个已有子 Agent。本工具最多支持 128 个子 Agent，会等待全部子 Agent 完成，并返回聚合报告。在 TUI 中，前台 swarm 会在输入框上方显示实时 `Agent swarm` 进度面板。若一次模型响应调用 `AgentSwarm`，该调用必须是该响应中的唯一工具调用；如需运行多个 swarm，应先调用一个 `AgentSwarm` 并等待结果，再调用下一个，若单个模板可以覆盖这些工作，也可以合并为一个 swarm。在 `manual` 权限模式下，未处于 swarm mode 时调用 `AgentSwarm` 会触发审批，除非已有权限规则允许；swarm mode 已开启时，`AgentSwarm` 本身会自动放行。权限规则只能按工具名 `AgentSwarm` 匹配，不支持 `AgentSwarm(swarm)` 这类参数模式。默认情况下，本工具会逐步提升并发且不设上限（立即启动 5 个子 Agent，之后每 700 毫秒再启动 1 个）；将 `KIMI_CODE_AGENT_SWARM_MAX_CONCURRENCY` 设为正整数可限制该阶段同时运行的子 Agent 数量，不设置则表示不限制。若设置为非正整数的值，本次 AgentSwarm 调用会立即失败。
 
diff --git a/docs/zh/release-notes/changelog.md b/docs/zh/release-notes/changelog.md
index 21c2eb1d9..06181650b 100644
--- a/docs/zh/release-notes/changelog.md
+++ b/docs/zh/release-notes/changelog.md
@@ -6,6 +6,107 @@ outline: 2
 
 本页记录 Kimi Code CLI 每个版本的变更内容。
 
+## 0.26.0（2026-07-16）Say hi to the BIIIG DAY!
+
+### 优化
+
+- 扩展 coder 子 Agent 的工具集：新增后台任务、待办列表、Plan 模式、Skill 调用与嵌套 Agent 能力，与主 Agent 对齐。
+- `/model` 与 `/effort` 选择器现在会提示切换会使已有提示词缓存失效，并建议使用 `/new` 以避免额外 token 开销。
+- web: 打开模型选择器时刷新所有供应商的模型目录，新上线的模型现在总能显示。
+- 优化上下文用量显示的单位格式。
+
+### 修复
+
+- 修复恢复的会话没有新活动却被标记为刚更新、跳到会话列表顶部的问题。
+- 修复上下文大小指示器低估模型实际上下文用量的问题。
+- 修复经 Anthropic 协议接入的 Kimi 供应商模型错误显示思考强度选项的问题。
+- 修复 OpenAI 兼容（chat completions）供应商上显式关闭思考不生效的问题。
+- 用户停止任务时现在会向模型报告，其他停止原因也会保留在模型上下文中。
+- 修复后台子 Agent 被手动停止后立即恢复时可能因竞争报 `"already running"` 错误的问题。
+- Anthropic 兼容与 Kimi 的 preserved-thinking 端点现在原样回放空思考内容，不再替换为占位空格。
+- 旧版迁移在多个 Kimi 主目录之间保持幂等，损坏或无法映射的会话现在会明确报告，不再静默跳过。
+- web: 修复侧边栏调整宽度的拖拽手柄被聊天输入框背景遮挡的问题。
+
+## 0.25.0（2026-07-16）
+
+### 新功能
+
+- web: 聊天支持附加任意类型文件，可直接将文件拖放到窗口任意位置；发送的文件、图片、视频都会以附件标签显示在消息气泡中。
+
+### 优化
+
+- web: 模型请求失败时展示完整诊断信息。
+- 应用 Anthropic 官方 effort 配置，未知模型回退到 128k 输出上限。
+
+### 修复
+
+- 修复 Web 服务器 bearer token 校验可被百分号编码的 API 路径绕过、导致所有 API 路由可被未认证访问的问题。
+- 修复会话文件系统 API 可跟随指向工作区外的符号链接、导致宿主机文件被越权访问的问题。
+- web: 会话活动指示器现与 Agent 实际工作保持同步；修复会话激活竞争或 LLM 重试后流式内容重复的问题。
+- 修复 Anthropic 兼容供应商中自定义命名模型新会话思考强度被错误关闭、且 ACP 客户端不显示思考强度控件的问题。
+- Anthropic 兼容模型现在正确遵循 `adaptive_thinking = false`，请求中不再携带 effort 参数。
+- web: 修复服务器绑定非回环地址时 CSP 阻止 Web UI 主题初始化脚本与内置字体加载的问题。
+- 修复工作区目录通过符号链接给出时会话创建失败的问题。
+- 修复剪贴板图片读取失败导致 CLI 意外退出的问题，现在会回退为粘贴文本。
+- web: 修复已完成的后台子 Agent 在会话重新加载后丢失最终输出的问题。
+- web: 修复开发构建中 Enter 键无法确认模态对话框的问题。
+- web: 修复流式输出期间后台子 Agent 在 agents dock 面板中显示为两行相同记录的问题。
+- 修复 CLI 意外退出时诊断日志缺少实际错误信息的问题。
+
+## 0.24.2（2026-07-15）
+
+### 新功能
+
+- 新增内置 `/check-kimi-code-docs` Skill，自动基于官方文档回答 Kimi Code 产品问题并附来源链接。
+
+### 优化
+
+- 对齐 `kimi -p` 在各引擎的行为：`print_background_mode` 与 `print_max_turns` 生效，`/goal` 会运行到目标结束。
+- `kimi -p` 默认在后台任务未完成时保持运行，等待与轮次实际上不设上限，并把完成结果反馈给主 Agent。如需恢复旧的一轮后退出，可设置 `print_background_mode = "exit"` 或 `"drain"`。
+- `kimi -p` 后台任务和子 Agent 默认不再超时（交互模式不变）；如需恢复限制，可设置 `[background] bash_task_timeout_s` 或 `[subagent] timeout_ms`。
+- 子 Agent 超时统一默认为 2 小时，可通过 `[subagent] timeout_ms` 或 `KIMI_SUBAGENT_TIMEOUT_MS` 覆盖。
+- 每步 LLM 重试上限从 3 次提高到 10 次，供应商临时失败（429 / 过载）会在轮次失败前自动重试；可通过 `loop_control.max_retries_per_step` 调整。
+- 工作区现在自动保持同步：新会话自动注册，缺失工作区启动时补全，已移除的不再重现。
+- `kimi web` 现在会记录失败请求和关键操作，便于诊断服务问题。
+- web: AgentSwarm 卡片在子 Agent 运行时保持展开。
+- web: 最小化的计划审阅与问题卡片改用向上的 chevron 作为展开图标。
+
+### 修复
+
+- web: 修复 iOS 移动端布局问题，包括 composer、安全区和 toast。
+- 修复新会话无法在旧版 CLI 中打开的问题。
+- 修复子 Agent 完成时过早触发完成通知的问题。
+- 修复 Web UI 显示错误 CLI 版本的问题。
+- 修复 Gemini 模型的 tool call id 跨轮次冲突，导致 swarm 运行被合并到一张卡片的问题。
+- web: 操作（如停止或归档会话）失败时现在会展示服务器错误详情。
+- web: 修复标签页切换到后台后长响应卡住的问题。
+- web: 修复纯 HTTP 下代码块复制按钮不可用的问题。
+- web: 修复会话列表刷新失败时会话被清空的问题。
+- web: 修复刷新页面后 AgentSwarm 成员列表丢失的问题。
+- web: 修复首条消息为斜杠命令时会话标题不生成的问题。
+- web: 修复重新加载会话后消息时间显示为会话创建时间的问题。
+- 修复多个 `/goal` 模式问题，涉及预算与轮次上限、暂停与恢复、崩溃恢复、最终状态消息和无效的持久化目标记录。
+- 修复被替换目标仍可能影响新目标预算的问题，并统一拒绝无效的子 Agent 目标。
+- 修正目标无法暂停或恢复时显示的引导文案。
+
+### 重构
+
+- 将动态工具加载能力从 `select_tools` 重命名为 `dynamically_loaded_tools`，行为不变。
+
+## 0.24.1（2026-07-14）
+
+### 修复
+
+- 修复 preserved-thinking 历史包含空推理步骤时，Kimi 会话卡住的问题。
+- 修复模型供应商在会话启动后才就绪时，内置工具不可用的问题。
+- 修复思考强度（thinking effort）路由问题：非 Kimi 供应商现在保留配置值，Kimi 模型会校验运行时选择，并在模型解析时安全回退。
+- web: 对齐 Web 端与 CLI 的思考级别处理：所选级别原样提交，不再被静默降级；未选择或切换模型时回退到模型自身的默认级别；显式选择会保存为默认值并被新会话继承。
+- 修复目标完成摘要丢失的问题；步骤中断事件中的无类型 LLM 错误不再显示内部错误码前缀。
+
+### 优化
+
+- web: 模型标签只显示级别名称（如 Max），不再显示 "thinking: max"。
+
 ## 0.24.0（2026-07-14）
 
 ### 新功能
diff --git a/flake.nix b/flake.nix
index 82edde273..dc44288a9 100644
--- a/flake.nix
+++ b/flake.nix
@@ -66,7 +66,6 @@
         ./packages/agent-core
         ./packages/agent-core-v2
         ./packages/kap-server
-        ./packages/server-e2e
         ./packages/kaos
         ./packages/klient
         ./packages/kosong
@@ -79,6 +78,7 @@
         ./packages/telemetry
         ./apps/kimi-code
         ./apps/kimi-desktop
+        ./apps/vscode
         ./apps/kimi-web
         ./apps/vis
         ./apps/vis/server
@@ -91,7 +91,6 @@
         "@moonshot-ai/agent-core"
         "@moonshot-ai/agent-core-v2"
         "@moonshot-ai/kap-server"
-        "@moonshot-ai/server-e2e"
         "@moonshot-ai/kaos"
         "@moonshot-ai/kosong"
         "@moonshot-ai/migration-legacy"
@@ -104,6 +103,7 @@
         "@moonshot-ai/kimi-telemetry"
         "@moonshot-ai/kimi-code"
         "@moonshot-ai/kimi-desktop"
+        "kimi-code"
         "@moonshot-ai/kimi-web"
         "@moonshot-ai/vis"
         "@moonshot-ai/vis-server"
@@ -158,7 +158,7 @@
               inherit (finalAttrs) pname version src pnpmWorkspaces;
               inherit pnpm;
               fetcherVersion = 3;
-              hash = "sha256-dqniDBWjKjtTcr+zKhtilkKXdNMfiwnfrqH/7Cg4eZ0=";
+              hash = "sha256-/mJN7mNZgce57+dCQv0MBDESAxQpeBGQCky/2AR1qCk=";
             };
 
             nativeBuildInputs = [
diff --git a/package.json b/package.json
index 276d5fe0f..a2783f2d6 100644
--- a/package.json
+++ b/package.json
@@ -18,7 +18,7 @@
     "build:plugin-marketplace": "pnpm -C apps/kimi-code run build:plugin-marketplace",
     "vis": "pnpm -C apps/vis run dev",
     "dev:docs": "pnpm -C docs install --ignore-workspace && pnpm -C docs run dev",
-    "typecheck": "pnpm run build:packages && pnpm -r --filter './packages/*' run typecheck && pnpm --filter @moonshot-ai/kimi-code run typecheck && pnpm --filter @moonshot-ai/kimi-web run typecheck && pnpm --filter @moonshot-ai/vis-server run typecheck && pnpm --filter @moonshot-ai/vis-web run typecheck && pnpm --filter @moonshot-ai/kimi-desktop run typecheck",
+    "typecheck": "pnpm run build:packages && pnpm -r --filter './packages/*' run typecheck && pnpm --filter @moonshot-ai/kimi-code run typecheck && pnpm --filter kimi-code run typecheck && pnpm --filter @moonshot-ai/kimi-web run typecheck && pnpm --filter @moonshot-ai/vis-server run typecheck && pnpm --filter @moonshot-ai/vis-web run typecheck && pnpm --filter @moonshot-ai/kimi-desktop run typecheck",
     "lint": "oxlint --type-aware",
     "lint:fix": "pnpm run lint --fix",
     "lint:pkg": "pnpm --filter @moonshot-ai/kimi-code exec publint && npm_config_cache=${TMPDIR:-/tmp}/kimi-code-npm-cache pnpm --filter @moonshot-ai/kimi-code exec attw --pack . --profile node16",
diff --git a/packages/acp-adapter/src/model-catalog.ts b/packages/acp-adapter/src/model-catalog.ts
index 5ce4256d9..a3c87a638 100644
--- a/packages/acp-adapter/src/model-catalog.ts
+++ b/packages/acp-adapter/src/model-catalog.ts
@@ -15,14 +15,23 @@
  * `for model_key, model in models.items()`.
  *
  * `thinkingSupported` is true if any of:
- *   1. the alias's declared `capabilities` array contains `'thinking'`, or
+ *   1. the alias's declared `capabilities` array contains `'thinking'`
+ *      (including the capability inferred from the Anthropic wire protocol —
+ *      see the `providerType` context below), or
  *   2. the underlying model name matches `/thinking|reason/i`
  *      (always-thinking variants), or
  *   3. the underlying model name is on the {@link TOGGLEABLE_THINKING_MODELS}
  *      allow-list (mirrors `kimi-cli/src/kimi_cli/llm.py:derive_model_capabilities`).
+ *
+ * The runtime resolves a model's wire protocol from
+ * `alias.protocol ?? provider.type` (see
+ * `ProviderManager.resolveProviderConfig`). The derive helpers below take the
+ * provider's `type` as an optional second argument so the catalog agrees with
+ * the runtime about Anthropic profiles even when the alias itself does not
+ * declare `protocol`.
  */
 
-import { effectiveModelAlias } from '@moonshot-ai/agent-core';
+import { effectiveModelAlias, type ProviderType } from '@moonshot-ai/agent-core';
 import type { KimiHarness, ModelAlias } from '@moonshot-ai/kimi-code-sdk';
 
 /**
@@ -55,8 +64,8 @@ export interface AcpModelEntry {
  */
 const TOGGLEABLE_THINKING_MODELS = new Set(['kimi-for-coding', 'kimi-code']);
 
-export function deriveThinkingSupported(alias: ModelAlias): boolean {
-  const effective = effectiveModelAlias(alias);
+export function deriveThinkingSupported(alias: ModelAlias, providerType?: ProviderType): boolean {
+  const effective = effectiveModelAlias(alias, providerType);
   const declared = effective.capabilities ?? [];
   if (declared.includes('thinking') || declared.includes('always_thinking')) return true;
   const lower = effective.model.toLowerCase();
@@ -72,8 +81,10 @@ export function deriveThinkingSupported(alias: ModelAlias): boolean {
  * `thinkingSupported`, but only an explicit (server-derived) declaration
  * may remove the off option from the client.
  */
-export function deriveAlwaysThinking(alias: ModelAlias): boolean {
-  return (effectiveModelAlias(alias).capabilities ?? []).includes('always_thinking');
+export function deriveAlwaysThinking(alias: ModelAlias, providerType?: ProviderType): boolean {
+  return (effectiveModelAlias(alias, providerType).capabilities ?? []).includes(
+    'always_thinking',
+  );
 }
 
 /**
@@ -81,8 +92,11 @@ export function deriveAlwaysThinking(alias: ModelAlias): boolean {
  * `default_effort`, else the middle `support_efforts` entry, else `'on'` for
  * boolean models (no `support_efforts`).
  */
-export function deriveDefaultThinkingEffort(alias: ModelAlias): string {
-  const effective = effectiveModelAlias(alias);
+export function deriveDefaultThinkingEffort(
+  alias: ModelAlias,
+  providerType?: ProviderType,
+): string {
+  const effective = effectiveModelAlias(alias, providerType);
   const efforts = effective.supportEfforts;
   if (efforts !== undefined && efforts.length > 0) {
     return effective.defaultEffort ?? efforts[Math.floor(efforts.length / 2)]!;
@@ -102,24 +116,49 @@ export async function listModelsFromHarness(
   harness: KimiHarness,
 ): Promise<readonly AcpModelEntry[]> {
   if (typeof harness.getConfig !== 'function') return [];
-  let models: Record<string, ModelAlias> | undefined;
+  let config: Awaited<ReturnType<KimiHarness['getConfig']>>;
   try {
-    const config = await harness.getConfig();
-    models = config.models;
+    config = await harness.getConfig();
   } catch {
     return [];
   }
+  const models = config.models;
   if (models === undefined) return [];
   const out: AcpModelEntry[] = [];
   for (const [id, alias] of Object.entries(models)) {
-    const effective = effectiveModelAlias(alias);
+    const providerType = providerTypeOf(alias, config);
+    const effective = effectiveModelAlias(alias, providerType);
     out.push({
       id,
       name: effective.displayName ?? effective.model ?? id,
-      thinkingSupported: deriveThinkingSupported(alias),
-      alwaysThinking: deriveAlwaysThinking(alias),
-      defaultThinkingEffort: deriveDefaultThinkingEffort(alias),
+      thinkingSupported: deriveThinkingSupported(alias, providerType),
+      alwaysThinking: deriveAlwaysThinking(alias, providerType),
+      defaultThinkingEffort: deriveDefaultThinkingEffort(alias, providerType),
     });
   }
   return out;
 }
+
+/**
+ * The alias's provider type, resolved like
+ * `ProviderManager.resolveProviderConfig` does: the alias's provider (falling
+ * back to the configured default provider). The Anthropic fallback profile in
+ * `effectiveModelAlias` only applies to non-Kimi providers, so a custom-named
+ * model on a `type = "anthropic"` provider still gets an inferred effort list
+ * while managed Kimi models keep only their catalog-declared efforts.
+ */
+function providerTypeOf(
+  alias: ModelAlias,
+  config: {
+    providers?: Record<string, { type?: ProviderType } | undefined>;
+    defaultProvider?: string | undefined;
+  },
+): ProviderType | undefined {
+  const providerName = alias.provider ?? config.defaultProvider;
+  const providerType =
+    providerName === undefined ? undefined : config.providers?.[providerName]?.type;
+  // Flat models (inline base_url, no named provider) have no provider entry to
+  // look up; their own protocol declaration plays the provider-identity role,
+  // mirroring the v2 ModelResolverService.
+  return providerType ?? alias.protocol;
+}
diff --git a/packages/acp-adapter/src/server.ts b/packages/acp-adapter/src/server.ts
index a43fe5ebb..d0286d18d 100644
--- a/packages/acp-adapter/src/server.ts
+++ b/packages/acp-adapter/src/server.ts
@@ -115,6 +115,12 @@ async function harnessIsAuthed(harness: KimiHarness): Promise<boolean> {
   return status.providers.some((entry) => entry.hasToken === true);
 }
 
+function thinkingEnabledFromEffort(effort: unknown): boolean | undefined {
+  if (typeof effort !== 'string') return undefined;
+  const normalized = effort.trim().toLowerCase();
+  return normalized.length > 0 && normalized !== 'off';
+}
+
 /**
  * Agent-side ACP handler. Routes `initialize` + `session/new` + `session/cancel`
  * into {@link KimiHarness}; refuses methods that are not yet wired with a
@@ -295,7 +301,7 @@ export class AcpServer implements Agent {
       mcpServers,
     });
     const currentModelId = await this.resolveCurrentModelId();
-    const currentThinkingEnabled = await this.resolveCurrentThinkingEnabled();
+    const currentThinkingEnabled = await this.resolveCurrentThinkingEnabled(session);
     const acpSession = new AcpSession(
       this.conn,
       session,
@@ -492,14 +498,13 @@ export class AcpServer implements Agent {
     // Phase 15 reads the resumed thinking effort off the main-agent
     // config and projects it onto the binary toggle: any non-`'off'`
     // effort reads as "thinking on" because the ACP surface only
-    // exposes the boolean axis. Falls back to the harness-level default
-    // when the resume state lacks the field.
+    // exposes the boolean axis. Falls back to the live session status, then
+    // the harness-level default, when the resume state lacks the field.
     const resumedThinkingEffort = resumeState?.agents?.['main']?.config?.thinkingEffort;
-    const currentThinkingEnabled =
-      typeof resumedThinkingEffort === 'string'
-        ? resumedThinkingEffort.trim().toLowerCase() !== 'off' &&
-          resumedThinkingEffort.trim().length > 0
-        : await this.resolveCurrentThinkingEnabled();
+    const currentThinkingEnabled = await this.resolveCurrentThinkingEnabled(
+      session,
+      resumedThinkingEffort,
+    );
     const acpSession = new AcpSession(
       this.conn,
       session,
@@ -824,31 +829,43 @@ export class AcpServer implements Agent {
   }
 
   /**
-   * Compute the initial value for the `thinking` toggle when
-   * a session is created (or loaded with no persisted thinking state).
-   * Reads the harness's `getConfig().thinking.enabled` flag if exposed —
-   * the same source `Session.createSession` would consult for new
-   * sessions. Returns `false` when the harness has no opinion, so the
-   * toggle starts off.
+   * Compute the initial value for the `thinking` toggle from the session's
+   * effective effort. A persisted resume-state effort wins; otherwise the
+   * live session status is authoritative. The harness config remains a
+   * best-effort fallback for partial SDK stubs and status-read failures.
    *
-   * Tolerant to partial-stub harnesses for the same reason
-   * {@link resolveCurrentModelId} is — adapter-level unit tests
-   * routinely omit `getConfig`. The swallow-and-fallback path keeps
-   * the test ergonomics symmetric.
+   * Tolerant to partial SDK/session stubs for the same reason
+   * {@link resolveCurrentModelId} is — adapter-level unit tests routinely
+   * omit `getStatus` or `getConfig`. The swallow-and-fallback path keeps the
+   * test ergonomics symmetric.
    */
-  private async resolveCurrentThinkingEnabled(): Promise<boolean> {
+  private async resolveCurrentThinkingEnabled(
+    session: Session,
+    resumedThinkingEffort?: unknown,
+  ): Promise<boolean> {
+    const resumed = thinkingEnabledFromEffort(resumedThinkingEffort);
+    if (resumed !== undefined) return resumed;
+
+    if (typeof session.getStatus === 'function') {
+      try {
+        const current = thinkingEnabledFromEffort((await session.getStatus()).thinkingEffort);
+        if (current !== undefined) return current;
+      } catch (error) {
+        log.warn('acp: session.getStatus threw during thinking toggle resolution; falling back', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
     if (typeof this.harness.getConfig !== 'function') return false;
     try {
       const config = await this.harness.getConfig();
       const thinking = (config as { thinking?: { enabled?: unknown; effort?: unknown } })
         .thinking;
-      if (typeof thinking?.enabled === 'boolean') return thinking.enabled;
-      // A non-empty effort with no explicit enabled flag still means thinking
-      // is on — agent-core's resolveThinkingEffort treats config.effort as
-      // enabled unless enabled === false, so mirror that here to keep the
-      // toggle consistent with the runtime.
-      if (typeof thinking?.effort === 'string' && thinking.effort.length > 0) return true;
-      return false;
+      if (thinking?.enabled === false) return false;
+      const configured = thinkingEnabledFromEffort(thinking?.effort);
+      if (configured !== undefined) return configured;
+      return thinking?.enabled === true;
     } catch (err) {
       log.warn('acp: harness.getConfig threw during thinking toggle resolution; defaulting to off', {
         error: err instanceof Error ? err.message : String(err),
diff --git a/packages/acp-adapter/test/config-options.test.ts b/packages/acp-adapter/test/config-options.test.ts
index acd0110d6..08475497f 100644
--- a/packages/acp-adapter/test/config-options.test.ts
+++ b/packages/acp-adapter/test/config-options.test.ts
@@ -11,21 +11,43 @@ import {
 import type { AcpModelEntry } from '../src/model-catalog';
 
 function makeHarnessWithModels(
-  entries: ReadonlyArray<{ id: string; model?: string; displayName?: string; capabilities?: readonly string[] }>,
+  entries: ReadonlyArray<{
+    id: string;
+    model?: string;
+    displayName?: string;
+    capabilities?: readonly string[];
+    protocol?: 'anthropic';
+    providerType?: 'anthropic' | 'kimi' | 'openai';
+  }>,
 ): { harness: KimiHarness; getConfig: ReturnType<typeof vi.fn> } {
   // Mirror the `listAvailableModels` derivation: `id` is the config map
   // key, `model` defaults to id, `displayName` to model. The test fixtures
   // below pick names that exercise the three thinkingSupported triggers
-  // (name regex, capabilities array, toggleable allow-list).
-  const models: Record<string, { model: string; displayName?: string; capabilities?: readonly string[] }> = {};
+  // (name regex, capabilities array, toggleable allow-list). Entries with a
+  // `providerType` also get a backing provider so provider-aware derivation
+  // (e.g. the Anthropic fallback profile) can resolve the provider's type.
+  const models: Record<string, {
+    provider?: string;
+    model: string;
+    displayName?: string;
+    capabilities?: readonly string[];
+    protocol?: 'anthropic';
+  }> = {};
+  const providers: Record<string, { type: string }> = {};
   for (const entry of entries) {
+    const providerName = `provider-${entry.id}`;
     models[entry.id] = {
+      ...(entry.providerType !== undefined ? { provider: providerName } : {}),
       model: entry.model ?? entry.id,
       ...(entry.displayName !== undefined ? { displayName: entry.displayName } : {}),
       ...(entry.capabilities !== undefined ? { capabilities: entry.capabilities } : {}),
+      protocol: entry.protocol,
     };
+    if (entry.providerType !== undefined) {
+      providers[providerName] = { type: entry.providerType };
+    }
   }
-  const getConfig = vi.fn(async () => ({ models }));
+  const getConfig = vi.fn(async () => ({ models, providers }));
   return { harness: { getConfig } as unknown as KimiHarness, getConfig };
 }
 
@@ -157,6 +179,36 @@ describe('buildSessionConfigOptions', () => {
     }
   });
 
+  it('shows the thinking control for an unknown model using the Anthropic protocol', async () => {
+    const { harness } = makeHarnessWithModels([
+      {
+        id: 'custom',
+        model: 'custom-anthropic-model',
+        protocol: 'anthropic',
+        providerType: 'anthropic',
+      },
+    ]);
+
+    const result = await buildSessionConfigOptions(harness, 'custom', false, 'default');
+
+    expect(result.map((option) => option.id)).toEqual(['model', 'thinking', 'mode']);
+  });
+
+  it('hides the thinking control for an unknown model on a Kimi provider using the Anthropic protocol', async () => {
+    const { harness } = makeHarnessWithModels([
+      {
+        id: 'custom',
+        model: 'custom-anthropic-model',
+        protocol: 'anthropic',
+        providerType: 'kimi',
+      },
+    ]);
+
+    const result = await buildSessionConfigOptions(harness, 'custom', false, 'default');
+
+    expect(result.map((option) => option.id)).toEqual(['model', 'mode']);
+  });
+
   it('omits the thinking toggle when current model is non-thinking-supported', async () => {
     const { harness } = makeHarnessWithModels([
       { id: 'kimi-coder', model: 'kimi-for-coding', displayName: 'Kimi Coder' },
diff --git a/packages/acp-adapter/test/model-catalog.test.ts b/packages/acp-adapter/test/model-catalog.test.ts
index e637a95bd..bfa852ac8 100644
--- a/packages/acp-adapter/test/model-catalog.test.ts
+++ b/packages/acp-adapter/test/model-catalog.test.ts
@@ -1,11 +1,12 @@
 import { describe, expect, it } from 'vitest';
 
-import type { ModelAlias } from '@moonshot-ai/kimi-code-sdk';
+import type { KimiHarness, ModelAlias } from '@moonshot-ai/kimi-code-sdk';
 
 import {
   deriveAlwaysThinking,
   deriveDefaultThinkingEffort,
   deriveThinkingSupported,
+  listModelsFromHarness,
 } from '../src/model-catalog';
 
 function alias(model: string, capabilities?: readonly string[]): ModelAlias {
@@ -52,3 +53,117 @@ describe('deriveDefaultThinkingEffort', () => {
     ).toBe('high');
   });
 });
+
+describe('listModelsFromHarness', () => {
+  it('advertises thinking with a high default for an unknown model using the Anthropic protocol', async () => {
+    const harness = {
+      getConfig: async () => ({
+        providers: {
+          custom: { type: 'anthropic' },
+        },
+        models: {
+          custom: {
+            provider: 'custom',
+            model: 'custom-anthropic-model',
+            maxContextSize: 200000,
+            protocol: 'anthropic',
+          },
+        },
+      }),
+    } as unknown as KimiHarness;
+
+    await expect(listModelsFromHarness(harness)).resolves.toEqual([
+      {
+        id: 'custom',
+        name: 'custom-anthropic-model',
+        thinkingSupported: true,
+        alwaysThinking: false,
+        defaultThinkingEffort: 'high',
+      },
+    ]);
+  });
+
+  it('advertises thinking for a flat providerless model using the Anthropic protocol', async () => {
+    const harness = {
+      getConfig: async () => ({
+        models: {
+          custom: {
+            model: 'custom-anthropic-model',
+            maxContextSize: 200000,
+            protocol: 'anthropic',
+          },
+        },
+      }),
+    } as unknown as KimiHarness;
+
+    await expect(listModelsFromHarness(harness)).resolves.toEqual([
+      {
+        id: 'custom',
+        name: 'custom-anthropic-model',
+        thinkingSupported: true,
+        alwaysThinking: false,
+        defaultThinkingEffort: 'high',
+      },
+    ]);
+  });
+
+  it('does not advertise thinking for an unknown model on a Kimi provider using the Anthropic protocol', async () => {
+    const harness = {
+      getConfig: async () => ({
+        providers: {
+          'managed:kimi-code': { type: 'kimi' },
+        },
+        models: {
+          custom: {
+            provider: 'managed:kimi-code',
+            model: 'custom-anthropic-model',
+            maxContextSize: 200000,
+            protocol: 'anthropic',
+          },
+        },
+      }),
+    } as unknown as KimiHarness;
+
+    await expect(listModelsFromHarness(harness)).resolves.toEqual([
+      {
+        id: 'custom',
+        name: 'custom-anthropic-model',
+        thinkingSupported: false,
+        alwaysThinking: false,
+        defaultThinkingEffort: 'on',
+      },
+    ]);
+  });
+
+  it('derives thinking support from the provider type when the alias omits protocol', async () => {
+    // Same shape the runtime sees for `[providers.compat] type = "anthropic"`
+    // + a custom-named model with no alias-level protocol: the provider
+    // context must make the catalog agree with ProviderManager, which infers
+    // the latest Anthropic profile (thinking-capable, default effort high).
+    const harness = {
+      getConfig: async () => ({
+        defaultProvider: 'compat',
+        providers: {
+          compat: { type: 'anthropic', apiKey: 'test-key', baseUrl: 'https://api.example.test' },
+        },
+        models: {
+          custom: {
+            provider: 'compat',
+            model: 'joint-model-0714-vibe',
+            maxContextSize: 200000,
+          },
+        },
+      }),
+    } as unknown as KimiHarness;
+
+    await expect(listModelsFromHarness(harness)).resolves.toEqual([
+      {
+        id: 'custom',
+        name: 'joint-model-0714-vibe',
+        thinkingSupported: true,
+        alwaysThinking: false,
+        defaultThinkingEffort: 'high',
+      },
+    ]);
+  });
+});
diff --git a/packages/acp-adapter/test/session-load.test.ts b/packages/acp-adapter/test/session-load.test.ts
index fb3e62807..e7f7b989d 100644
--- a/packages/acp-adapter/test/session-load.test.ts
+++ b/packages/acp-adapter/test/session-load.test.ts
@@ -63,6 +63,7 @@ function makeInMemoryStreamPair(): {
 function makeSessionWithHistory(
   sessionId: string,
   history: ReadonlyArray<unknown>,
+  statusThinkingEffort?: string,
 ): Session {
   return {
     id: sessionId,
@@ -77,6 +78,10 @@ function makeSessionWithHistory(
         },
       },
     }),
+    getStatus:
+      statusThinkingEffort === undefined
+        ? undefined
+        : async () => ({ thinkingEffort: statusThinkingEffort }),
   } as unknown as Session;
 }
 
@@ -319,4 +324,24 @@ describe('AcpServer session/load replay', () => {
     // Phase 15: model dropdown holds N rows (no `,thinking` variants).
     expect(modelOpt!.options).toHaveLength(2);
   });
+
+  it('advertises thinking on when resume state omits effort and live status is high', async () => {
+    const sessionId = 'sess-status-thinking-high';
+    const session = makeSessionWithHistory(sessionId, [], 'high');
+    const harness = makeHarness({ hasUsableToken: true, session });
+    const { agentStream, clientStream } = makeInMemoryStreamPair();
+
+    void new AgentSideConnection((c) => new AcpServer(harness, c), agentStream);
+    const clientConn = new ClientSideConnection((_a) => new CapturingClient(), clientStream);
+
+    const response = await clientConn.loadSession({
+      sessionId,
+      cwd: '/tmp/x',
+      mcpServers: [],
+    });
+
+    const thinking = response.configOptions?.find((option) => option.id === 'thinking');
+    if (thinking?.type !== 'select') throw new Error('thinking option must be a select');
+    expect(thinking.currentValue).toBe('on');
+  });
 });
diff --git a/packages/acp-adapter/test/session-new.test.ts b/packages/acp-adapter/test/session-new.test.ts
index ece351999..61220b462 100644
--- a/packages/acp-adapter/test/session-new.test.ts
+++ b/packages/acp-adapter/test/session-new.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import {
   AgentSideConnection,
@@ -49,7 +49,12 @@ interface CapturedCall {
   options: { id?: string; workDir: string; mcpServers?: Record<string, unknown> };
 }
 
-function makeHarness(sessionId: string, captured: CapturedCall[]): {
+function makeHarness(
+  sessionId: string,
+  captured: CapturedCall[],
+  statusThinkingEffort?: string | Error,
+  fallbackThinking?: { enabled?: boolean; effort?: string },
+): {
   harness: KimiHarness;
   fakeSession: Session;
 } {
@@ -58,6 +63,13 @@ function makeHarness(sessionId: string, captured: CapturedCall[]): {
     prompt: async () => undefined,
     cancel: async () => undefined,
     onEvent: () => () => undefined,
+    getStatus:
+      statusThinkingEffort === undefined
+        ? undefined
+        : vi.fn(async () => {
+            if (statusThinkingEffort instanceof Error) throw statusThinkingEffort;
+            return { thinkingEffort: statusThinkingEffort };
+          }),
   } as unknown as Session;
   const harness = {
     auth: { status: async () => AUTHED_STATUS },
@@ -73,6 +85,7 @@ function makeHarness(sessionId: string, captured: CapturedCall[]): {
         { id: 'kimi-coder', name: 'Kimi Coder', thinkingSupported: true },
         { id: 'kimi-plain', name: 'Kimi Plain', thinkingSupported: false },
       ]),
+      thinking: fallbackThinking,
     }),
   } as unknown as KimiHarness;
   return { harness, fakeSession };
@@ -207,4 +220,56 @@ describe('AcpServer session/new', () => {
     const modelValues = modelOpt!.options.map((o) => 'value' in o ? o.value : '');
     expect(modelValues).toEqual(['kimi-coder', 'kimi-plain']);
   });
+
+  it('advertises thinking on when the created session status has a high effort', async () => {
+    const captured: CapturedCall[] = [];
+    const { harness } = makeHarness('sess-thinking-high', captured, 'high');
+    const { agentStream, clientStream } = makeInMemoryStreamPair();
+
+    void new AgentSideConnection((c) => new AcpServer(harness, c), agentStream);
+    const client = new ClientSideConnection((_a) => new StubClient(), clientStream);
+
+    const response = await client.newSession({ cwd: '/tmp/work', mcpServers: [] });
+
+    const thinking = response.configOptions?.find((option) => option.id === 'thinking');
+    if (thinking?.type !== 'select') throw new Error('thinking option must be a select');
+    expect(thinking.currentValue).toBe('on');
+  });
+
+  it.each([
+    { name: 'explicit high effort', config: { effort: 'high' }, expected: 'on' },
+    { name: 'explicit off effort', config: { effort: 'off' }, expected: 'off' },
+    {
+      name: 'disabled with a high effort',
+      config: { enabled: false, effort: 'high' },
+      expected: 'off',
+    },
+    {
+      name: 'enabled with an off effort',
+      config: { enabled: true, effort: 'off' },
+      expected: 'off',
+    },
+  ])(
+    'falls back to $name when the created session status cannot be read',
+    async ({ config, expected }) => {
+      const captured: CapturedCall[] = [];
+      const { harness, fakeSession } = makeHarness(
+        'sess-thinking-status-error',
+        captured,
+        new Error('status unavailable'),
+        config,
+      );
+      const { agentStream, clientStream } = makeInMemoryStreamPair();
+
+      void new AgentSideConnection((c) => new AcpServer(harness, c), agentStream);
+      const client = new ClientSideConnection((_a) => new StubClient(), clientStream);
+
+      const response = await client.newSession({ cwd: '/tmp/work', mcpServers: [] });
+
+      expect(fakeSession.getStatus).toHaveBeenCalledOnce();
+      const thinking = response.configOptions?.find((option) => option.id === 'thinking');
+      if (thinking?.type !== 'select') throw new Error('thinking option must be a select');
+      expect(thinking.currentValue).toBe(expected);
+    },
+  );
 });
diff --git a/packages/agent-core-v2/scripts/check-domain-layers.mjs b/packages/agent-core-v2/scripts/check-domain-layers.mjs
index cfb7c6cae..c3b966c99 100644
--- a/packages/agent-core-v2/scripts/check-domain-layers.mjs
+++ b/packages/agent-core-v2/scripts/check-domain-layers.mjs
@@ -94,10 +94,9 @@ const DOMAIN_LAYER = new Map([
   ['os/backends', 6],
   // L2 — data & cross-cutting capabilities
   ['records', 2],
-  ['wireRecord', 2],
-  // `wire` is the scope-agnostic Model/Op/Signal state-machine layer: it
-  // consumes `persistence/interface` (L1) and is consumed by the scope tiers,
-  // so it sits in L2 beside the other data/cross-cutting layers.
+  // `wire` owns the Agent-scoped replayable-state aggregate plus its pure
+  // Model/Op/record/migration language. It consumes only L1 infrastructure
+  // and same-layer blob storage, and is consumed by the scope tiers.
   ['wire', 2],
   ['blob', 2],
   ['file', 2],
@@ -133,7 +132,11 @@ const DOMAIN_LAYER = new Map([
   ['modelCatalog', 3],
   ['agentProfileCatalog', 3],
   // L4 — agent behaviour
-  ['activity', 4],
+  // `activityView` is the Agent-scope read model folding the agent's own event
+  // bus into the activity projection (`agent.activity.updated`); it owns no
+  // authoritative state (turn mechanics live in `loop`, admission/drain in
+  // `sessionLifecycle`, background bookkeeping in `agentLifecycle`).
+  ['activityView', 4],
   ['context', 4],
   ['message', 4],
   ['turn', 4],
@@ -301,11 +304,18 @@ const ALLOWED_EXCEPTIONS = new Set([
   'auth>tool',
   'auth>toolRegistry',
   'permissionGate>approval',
+  // `permissionRules` (L3) persists the approval broker's `ApprovalResponse`
+  // (Session, L7) verbatim in its wire-logged `PermissionApprovalResultRecord`
+  // — a real cross-scope dependency, surfaced here rather than hidden behind a
+  // re-declared copy of the shape.
+  'permissionRules>approval',
   'userTool>interaction',
   'permissionPolicy>plan',
   'permissionPolicy>swarm',
-  'skill>turn',
-  'turn>agentLifecycle',
+  'skill>loop',
+  // `activityView` seeds its background-task slice once from the agent's task
+  // registry (a read, never a write) — everything else it folds from events.
+  'activityView>agentTask',
   'swarm>agentLifecycle',
   // `swarm` (L4) drives sub-agent runs through the `subagent` domain (L6) —
   // same shape as the `swarm>agentLifecycle` spawn exception above.
@@ -313,7 +323,6 @@ const ALLOWED_EXCEPTIONS = new Set([
   'cron>agentLifecycle',
   'cron>sessionContext',
   'todo>agentLifecycle',
-  'wireRecord>hooks',
   // L3/L4 type-sharing: tool contract + execution hook contexts now live in
   // `tool`; the remaining upward import is a `loop` error/event helper.
   'contextMemory>agentTask',
@@ -342,9 +351,6 @@ const ALLOWED_EXCEPTIONS = new Set([
   'btw>agentLifecycle',
   'toolExecutor>loop',
   'userTool>profile',
-  'wireRecord>contextMemory',
-  'wireRecord>loop',
-  'wireRecord>tool',
   'hostFolderBrowser>os/backends',
   'filestore>persistence/backends',
   'process>os/backends',
diff --git a/packages/agent-core-v2/src/_base/errors/codes.ts b/packages/agent-core-v2/src/_base/errors/codes.ts
index 64c2d0f1f..7a1a40cdd 100644
--- a/packages/agent-core-v2/src/_base/errors/codes.ts
+++ b/packages/agent-core-v2/src/_base/errors/codes.ts
@@ -6,13 +6,12 @@
  * codes, the registry (`registerErrorDomain` / `errorInfo` / `isErrorCode`) the
  * serializer reads, and the domain-independent core codes (`internal`,
  * `not_implemented`). Domain-owned codes live next to their owning domain and
- * are aggregated into the public `ErrorCodes` const by `#/errors`.
+ * are aggregated into the public `ErrorCodes` const by `#/errors`, which also
+ * derives the `ErrorCode` union type from that aggregate — so each domain's
+ * `errors.ts` is the single source of truth and there is no central
+ * hand-maintained list to keep in sync.
  */
 
-import type { KimiErrorCode } from '@moonshot-ai/protocol';
-
-export type ErrorCode = KimiErrorCode;
-
 export interface ErrorInfo {
   readonly title: string;
   readonly retryable: boolean;
@@ -21,18 +20,25 @@ export interface ErrorInfo {
 }
 
 export interface ErrorDomain {
-  readonly codes: { readonly [name: string]: ErrorCode };
-  readonly retryable?: ReadonlyArray<ErrorCode>;
+  readonly codes: { readonly [name: string]: string };
+  readonly retryable?: ReadonlyArray<string>;
   readonly info?: { readonly [code: string]: ErrorInfo };
 }
 
-const registeredCodes = new Set<ErrorCode>();
-const retryableCodes = new Set<ErrorCode>();
+// Maps each registered code to the `codes` object that contributed it: a
+// domain re-registering itself stays idempotent, while two different domains
+// claiming the same code fail loudly at registration time.
+const registeredCodes = new Map<string, object>();
+const retryableCodes = new Set<string>();
 const infoOverrides: { [code: string]: ErrorInfo } = {};
 
 export function registerErrorDomain(domain: ErrorDomain): void {
   for (const code of Object.values(domain.codes)) {
-    registeredCodes.add(code);
+    const owner = registeredCodes.get(code);
+    if (owner !== undefined && owner !== domain.codes) {
+      throw new Error(`error code '${code}' is registered by two different domains`);
+    }
+    registeredCodes.set(code, domain.codes);
   }
   for (const code of domain.retryable ?? []) {
     retryableCodes.add(code);
@@ -42,11 +48,11 @@ export function registerErrorDomain(domain: ErrorDomain): void {
   }
 }
 
-export function isErrorCode(code: unknown): code is ErrorCode {
-  return typeof code === 'string' && registeredCodes.has(code as ErrorCode);
+export function isErrorCode(code: unknown): code is string {
+  return typeof code === 'string' && registeredCodes.has(code);
 }
 
-export function errorInfo(code: ErrorCode): ErrorInfo {
+export function errorInfo(code: string): ErrorInfo {
   const override = infoOverrides[code];
   if (override !== undefined) return override;
   return {
@@ -60,6 +66,7 @@ export const CoreErrors = {
   codes: {
     INTERNAL: 'internal',
     NOT_IMPLEMENTED: 'not_implemented',
+    VALIDATION_FAILED: 'validation.failed',
   },
   info: {
     internal: {
diff --git a/packages/agent-core-v2/src/_base/errors/errors.ts b/packages/agent-core-v2/src/_base/errors/errors.ts
index 373db6344..d5cd7cebe 100644
--- a/packages/agent-core-v2/src/_base/errors/errors.ts
+++ b/packages/agent-core-v2/src/_base/errors/errors.ts
@@ -4,7 +4,7 @@
  */
 
 import { CoreErrors } from './codes';
-import type { ErrorCode } from './codes';
+import type { ErrorCode } from '#/errors';
 
 export class ExpectedError extends Error {
   readonly isExpected = true;
diff --git a/packages/agent-core-v2/src/_base/errors/serialize.ts b/packages/agent-core-v2/src/_base/errors/serialize.ts
index 3d1b2a634..5b6ad0b40 100644
--- a/packages/agent-core-v2/src/_base/errors/serialize.ts
+++ b/packages/agent-core-v2/src/_base/errors/serialize.ts
@@ -9,7 +9,7 @@
  */
 
 import { CoreErrors, errorInfo, isErrorCode } from './codes';
-import type { ErrorCode } from './codes';
+import type { ErrorCode } from '#/errors';
 import { Error2 } from './errors';
 
 export interface ErrorPayload {
diff --git a/packages/agent-core-v2/src/_base/utils/isoDateTime.ts b/packages/agent-core-v2/src/_base/utils/isoDateTime.ts
new file mode 100644
index 000000000..f5346c4d2
--- /dev/null
+++ b/packages/agent-core-v2/src/_base/utils/isoDateTime.ts
@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+const ISO_8601_REGEX =
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
+
+/**
+ * Wire-schema primitive for ISO 8601 datetime strings: validates the shape and
+ * normalizes to `Date#toISOString()` output. Shared by the edge DTO schemas
+ * (`sessionFs`, `file`, `terminal`, `auth`, …) that expose timestamps.
+ */
+export const isoDateTimeSchema = z
+  .string()
+  .refine((value) => ISO_8601_REGEX.test(value), {
+    message: 'must be an ISO 8601 datetime string',
+  })
+  .transform((value, ctx) => {
+    const ms = Date.parse(value);
+    if (Number.isNaN(ms)) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'invalid ISO 8601 datetime',
+      });
+      return z.NEVER;
+    }
+    return new Date(ms).toISOString();
+  });
diff --git a/packages/agent-core-v2/src/_base/utils/retry.ts b/packages/agent-core-v2/src/_base/utils/retry.ts
index ee984047e..1db6758a7 100644
--- a/packages/agent-core-v2/src/_base/utils/retry.ts
+++ b/packages/agent-core-v2/src/_base/utils/retry.ts
@@ -1,12 +1,15 @@
 /**
  * `_base` retry helpers — exponential and server-directed backoff, abortable
  * sleeps, and error-field extraction shared by retry policies (the loop's
- * `stepRetry` plugin, full-compaction's self-managed resends).
+ * `stepRetry` plugin, full-compaction's self-managed resends). The default
+ * budget is 10 attempts per step (kept in sync with v1
+ * `agent-core/loop/retry.ts`): the 500ms ×2 ramp capped at 32s waits out
+ * multi-minute provider overload (sustained 429s) before a turn fails.
  */
 
 import { abortable } from '#/_base/utils/abort';
 
-export const DEFAULT_MAX_RETRY_ATTEMPTS = 3;
+export const DEFAULT_MAX_RETRY_ATTEMPTS = 10;
 
 const BASE_DELAY_MS = 500;
 const MAX_DELAY_MS = 32_000;
diff --git a/packages/agent-core-v2/src/activity/activity.ts b/packages/agent-core-v2/src/activity/activity.ts
deleted file mode 100644
index 0026e9a09..000000000
--- a/packages/agent-core-v2/src/activity/activity.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * `activity` domain (L4) — Agent / Session activity kernel contracts.
- *
- * Defines the authoritative activity state machines shared by the Agent and
- * Session scopes. `IAgentActivityService` is the Agent-scope lane machine: it
- * owns turn admission (`begin`/`tryBegin`), cancellation, background-activity
- * registration and disposal settlement, and is the sole dispatcher of the
- * `activityLane` wire Model (`activityOps`). `ISessionActivityKernel` is the
- * Session-scope lifecycle lane + admission table that the Agent kernel consults
- * synchronously on every `begin` (child-injects-parent), so admission stays
- * atomic inside a single event-loop turn. The `ActivityLease` returned by
- * `begin` carries the turn's `AbortSignal` and is the only path back to `idle`
- * (`lease.end`). Multi-scope domain: `IAgentActivityService` bound at Agent
- * scope, `ISessionActivityKernel` bound at Session scope.
- */
-
-import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-import type { IDisposable } from '#/_base/di/lifecycle';
-import type { PromptOrigin } from '#/agent/contextMemory/types';
-import type { TurnEndReason } from '@moonshot-ai/protocol';
-
-export type AgentLane = 'initializing' | 'idle' | 'turn' | 'disposing' | 'disposed';
-
-export interface BeginOptions {
-  readonly origin?: PromptOrigin;
-  readonly turnId?: number;
-}
-
-export interface ActivityLease {
-  readonly kind: 'turn';
-  readonly turnId: number;
-  readonly origin: PromptOrigin;
-  readonly signal: AbortSignal;
-  readonly ending: boolean;
-  end(outcome: 'completed' | 'cancelled' | 'failed', detail?: { error?: unknown }): void;
-}
-
-export interface BackgroundActivityRef {
-  readonly kind: 'compaction' | 'task' | (string & {});
-  readonly id: string;
-  readonly since: number;
-  readonly signal: AbortSignal;
-}
-
-export interface IAgentActivityService {
-  readonly _serviceBrand: undefined;
-
-  lane(): AgentLane;
-
-  begin(kind: 'turn', opts?: BeginOptions): ActivityLease;
-
-  tryBegin(kind: 'turn', opts?: BeginOptions): ActivityLease | undefined;
-
-  markReady(): void;
-
-  cancel(reason?: unknown): boolean;
-
-  registerBackground(kind: string, controller: AbortController): IDisposable & { readonly id: string };
-
-  beginDisposal(): void;
-  settled(): Promise<void>;
-}
-
-export const IAgentActivityService: ServiceIdentifier<IAgentActivityService> =
-  createDecorator<IAgentActivityService>('agentActivityService');
-
-export type SessionLane = 'restoring' | 'active' | 'quiescing' | 'closing' | 'disposed';
-
-export type SessionCommand =
-  | 'turn.begin'
-  | 'agent.create'
-  | 'session.fork'
-  | 'session.archive'
-  | 'session.close'
-  | (string & {});
-
-export interface SessionQuiesceLease extends IDisposable {
-  readonly reason: string;
-}
-
-export interface ISessionActivityKernel {
-  readonly _serviceBrand: undefined;
-
-  lane(): SessionLane;
-
-  markActive(): void;
-
-  canAccept(command: SessionCommand): boolean;
-
-  admitTurn(agentId: string, lease: ActivityLease): IDisposable;
-
-  quiesce(reason: string): Promise<SessionQuiesceLease>;
-
-  beginClosing(): void;
-  settled(): Promise<void>;
-
-  markActive(): void;
-}
-
-export const ISessionActivityKernel: ServiceIdentifier<ISessionActivityKernel> =
-  createDecorator<ISessionActivityKernel>('sessionActivityKernel');
-
-export type TurnPhase = 'running' | 'streaming' | 'tool_call' | 'retrying';
-
-export interface ApprovalRef {
-  readonly approvalId: string;
-  readonly toolCallId?: string;
-  readonly since: number;
-}
-
-export interface ToolCallRef {
-  readonly toolCallId: string;
-  readonly name: string;
-  readonly since: number;
-}
-
-export interface ActivityRetryState {
-  readonly failedAttempt: number;
-  readonly nextAttempt: number;
-  readonly maxAttempts: number;
-  readonly delayMs: number;
-  readonly errorName?: string;
-  readonly statusCode?: number;
-}
-
-export interface ActivityTurnState {
-  readonly turnId: number;
-  readonly origin: PromptOrigin;
-  readonly phase: TurnPhase;
-  readonly stream?: 'assistant' | 'thinking' | 'tool_call';
-  readonly step: number;
-  readonly ending: boolean;
-  readonly endingReason?: 'aborted' | 'max_steps' | 'error';
-  readonly retry?: ActivityRetryState;
-  readonly pendingApprovals: readonly ApprovalRef[];
-  readonly activeToolCalls: readonly ToolCallRef[];
-  readonly since: number;
-}
-
-export interface ActivityLastTurnState {
-  readonly turnId: number;
-  readonly reason: TurnEndReason;
-  readonly durationMs?: number;
-  readonly at: number;
-}
-
-export interface AgentActivitySnapshot {
-  readonly lane: AgentLane;
-  readonly turn?: ActivityTurnState;
-  readonly lastTurn?: ActivityLastTurnState;
-  readonly background: readonly BackgroundActivityRef[];
-}
diff --git a/packages/agent-core-v2/src/activity/activityOps.ts b/packages/agent-core-v2/src/activity/activityOps.ts
deleted file mode 100644
index f7c7dc43c..000000000
--- a/packages/agent-core-v2/src/activity/activityOps.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * `activity` domain (L4) — wire Model (`LaneModel`) and the `activity.set_lane`
- * Op that holds the Agent activity lane.
- *
- * The lane is a live-only Model (`persist: false`): nothing is persisted or
- * replayed, so a resumed agent starts back at `idle`. The Agent kernel
- * (`agentActivityService`) is the sole dispatcher of `setLane`; `apply` returns
- * the SAME reference when the incoming state is unchanged under `laneEqual`
- * (which ignores the `since` / `at` timestamps) so redundant dispatches do not
- * flood subscribers. The Op derives no event here — the outward snapshot event
- * is emitted by the projector so there is a single event source (PR5). The
- * initial lane is `idle` (fresh agents accept turns immediately); the
- * half-replay window is gated at the Session kernel (`restoring`), not here.
- * Consumed by the Agent-scope `agentActivityService` and (PR5) the projector.
- */
-
-import { z } from 'zod';
-
-import { defineModel } from '#/wire/model';
-import type { PromptOrigin } from '#/agent/contextMemory/types';
-
-import type { AgentLane, BackgroundActivityRef, SessionLane } from './activity';
-
-export interface LaneTurnState {
-  readonly turnId: number;
-  readonly origin: PromptOrigin;
-  readonly ending: boolean;
-  readonly endingReason?: 'aborted' | 'max_steps' | 'error';
-  readonly since: number;
-}
-
-export interface LaneLastTurnState {
-  readonly turnId: number;
-  readonly reason: 'completed' | 'cancelled' | 'failed';
-  readonly at: number;
-}
-
-export interface LaneModelState {
-  readonly lane: AgentLane;
-  readonly turn?: LaneTurnState;
-  readonly lastTurn?: LaneLastTurnState;
-  readonly background: readonly BackgroundActivityRef[];
-}
-
-export const LaneModel = defineModel<LaneModelState>('activityLane', () => ({
-  lane: 'idle',
-  background: [],
-}));
-
-declare module '#/wire/types' {
-  interface TransientOpMap {
-    'activity.set_lane': typeof setLane;
-    'activity.set_session_lane': typeof setSessionLane;
-  }
-}
-
-export const setLane = LaneModel.defineOp('activity.set_lane', {
-  schema: z.object({ next: z.custom<LaneModelState>() }),
-  persist: false,
-  apply: (s, p) => (laneEqual(s, p.next) ? s : p.next),
-});
-
-export function laneEqual(a: LaneModelState, b: LaneModelState): boolean {
-  if (a.lane !== b.lane) return false;
-  if (a.background.length !== b.background.length) return false;
-  if ((a.turn === undefined) !== (b.turn === undefined)) return false;
-  if (a.turn !== undefined && b.turn !== undefined) {
-    if (
-      a.turn.turnId !== b.turn.turnId ||
-      a.turn.ending !== b.turn.ending ||
-      a.turn.endingReason !== b.turn.endingReason
-    ) {
-      return false;
-    }
-  }
-  if ((a.lastTurn === undefined) !== (b.lastTurn === undefined)) return false;
-  if (a.lastTurn !== undefined && b.lastTurn !== undefined) {
-    if (a.lastTurn.turnId !== b.lastTurn.turnId || a.lastTurn.reason !== b.lastTurn.reason) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export interface SessionLaneModelState {
-  readonly lane: SessionLane;
-  readonly activeLeases: number;
-}
-
-export const SessionLaneModel = defineModel<SessionLaneModelState>('sessionActivityLane', () => ({
-  lane: 'restoring',
-  activeLeases: 0,
-}));
-
-export const setSessionLane = SessionLaneModel.defineOp('activity.set_session_lane', {
-  schema: z.object({ next: z.custom<SessionLaneModelState>() }),
-  persist: false,
-  apply: (s, p) => (s.lane === p.next.lane && s.activeLeases === p.next.activeLeases ? s : p.next),
-});
diff --git a/packages/agent-core-v2/src/activity/agentActivityService.ts b/packages/agent-core-v2/src/activity/agentActivityService.ts
deleted file mode 100644
index f3012ee00..000000000
--- a/packages/agent-core-v2/src/activity/agentActivityService.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-/**
- * `activity` domain (L4) — `IAgentActivityService` implementation.
- *
- * Owns the Agent activity lane (`idle ⇄ turn(active|ending)`, plus `disposing`
- * / `disposed`) and is the sole dispatcher of the `activityLane` wire Model
- * (`activity.set_lane`). `begin('turn')` atomically consults the Session kernel
- * (`ISessionActivityKernel.admitTurn`, child-injects-parent), reads the next
- * turn id from the `turn` `TurnModel`, enters the turn lane and returns an
- * `ActivityLease`; the lease's `AbortSignal` is the only cancellation channel,
- * and `lease.end()` is the only path back to `idle`. Background activities
- * (`registerBackground`) are tracked so disposal can abort and await them. The
- * lane starts at `initializing` and is driven to `idle` by `markReady()` once
- * the agent bootstrap (`agentLifecycle.create`) finishes; until then `begin`
- * rejects with `activity.initializing`. The half-replay window on resume is
- * gated by the Session kernel (`restoring`). Bound at Agent scope.
- */
-
-import { Disposable, type IDisposable } from '#/_base/di/lifecycle';
-import { InstantiationType } from '#/_base/di/extensions';
-import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { userCancellationReason } from '#/_base/utils/abort';
-import { ErrorCodes, Error2 } from '#/errors';
-import { USER_PROMPT_ORIGIN } from '#/agent/contextMemory/types';
-import type { PromptOrigin } from '#/agent/contextMemory/types';
-import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
-import { TurnModel } from '#/agent/loop/turnOps';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
-
-import type {
-  ActivityLease,
-  AgentLane,
-  BackgroundActivityRef,
-  BeginOptions,
-} from './activity';
-import { IAgentActivityService, ISessionActivityKernel } from './activity';
-import { type LaneLastTurnState, setLane } from './activityOps';
-
-let nextBackgroundId = 0;
-
-interface BackgroundEntry {
-  readonly ref: BackgroundActivityRef;
-  readonly controller: AbortController;
-}
-
-class LeaseImpl implements ActivityLease {
-  readonly kind = 'turn' as const;
-  readonly origin: PromptOrigin;
-  readonly turnId: number;
-  readonly since: number;
-  private readonly controller = new AbortController();
-  private _ending = false;
-  private _ended = false;
-  private _endingReason: 'aborted' | 'max_steps' | 'error' | undefined;
-  registration: IDisposable = Disposable.None;
-
-  constructor(
-    turnId: number,
-    origin: PromptOrigin,
-    private readonly owner: AgentActivityService,
-  ) {
-    this.turnId = turnId;
-    this.origin = origin;
-    this.since = Date.now();
-  }
-
-  get signal(): AbortSignal {
-    return this.controller.signal;
-  }
-
-  get ending(): boolean {
-    return this._ending;
-  }
-
-  get endingReason(): 'aborted' | 'max_steps' | 'error' | undefined {
-    return this._endingReason;
-  }
-
-  markEnding(reason?: unknown): void {
-    if (this._ending || this._ended) return;
-    this._ending = true;
-    this._endingReason = 'aborted';
-    this.controller.abort(reason ?? userCancellationReason());
-  }
-
-  end(outcome: 'completed' | 'cancelled' | 'failed', detail?: { error?: unknown }): void {
-    if (this._ended) return;
-    this._ended = true;
-    if (outcome === 'failed' && this._endingReason === undefined) {
-      this._endingReason = 'error';
-    }
-    this.owner.onLeaseEnd(this, outcome, detail);
-  }
-}
-
-export class AgentActivityService extends Disposable implements IAgentActivityService {
-  declare readonly _serviceBrand: undefined;
-
-  private _lane: AgentLane = 'initializing';
-  private activeLease: LeaseImpl | undefined;
-  private lastTurn: LaneLastTurnState | undefined;
-  private readonly background = new Map<string, BackgroundEntry>();
-  private readonly settleWaiters: Array<() => void> = [];
-
-  constructor(
-    @IAgentWireService private readonly wire: IWireService,
-    @ISessionActivityKernel private readonly sessionKernel: ISessionActivityKernel,
-    @IAgentScopeContext private readonly scopeContext: IAgentScopeContext,
-  ) {
-    super();
-  }
-
-  lane(): AgentLane {
-    return this._lane;
-  }
-
-  begin(kind: 'turn', opts?: BeginOptions): ActivityLease {
-    if (kind !== 'turn') {
-      throw new Error2(ErrorCodes.NOT_IMPLEMENTED, `Unsupported activity kind: ${String(kind)}`);
-    }
-    switch (this._lane) {
-      case 'turn':
-        throw new Error2(
-          ErrorCodes.ACTIVITY_AGENT_BUSY,
-          `Cannot begin a new turn while turn ${this.activeLease?.turnId ?? '?'} is active`,
-          { details: { turnId: this.activeLease?.turnId } },
-        );
-      case 'disposing':
-        throw new Error2(ErrorCodes.ACTIVITY_DISPOSING, 'Agent is disposing');
-      case 'disposed':
-        throw new Error2(ErrorCodes.ACTIVITY_DISPOSED, 'Agent is disposed');
-      case 'initializing':
-        throw new Error2(ErrorCodes.ACTIVITY_INITIALIZING, 'Agent is still restoring');
-      case 'idle':
-        break;
-    }
-
-    const turnId = opts?.turnId ?? this.wire.getModel(TurnModel).nextTurnId;
-    const origin = opts?.origin ?? USER_PROMPT_ORIGIN;
-    const lease = new LeaseImpl(turnId, origin, this);
-    lease.registration = this.sessionKernel.admitTurn(this.scopeContext.agentId, lease);
-
-    this.activeLease = lease;
-    this._lane = 'turn';
-    this.publishLane();
-    return lease;
-  }
-
-  tryBegin(kind: 'turn', opts?: BeginOptions): ActivityLease | undefined {
-    try {
-      return this.begin(kind, opts);
-    } catch (error) {
-      if (error instanceof Error2) return undefined;
-      throw error;
-    }
-  }
-
-  markReady(): void {
-    if (this._lane !== 'initializing') return;
-    this._lane = 'idle';
-    this.publishLane();
-  }
-
-  cancel(reason?: unknown): boolean {
-    const lease = this.activeLease;
-    if (lease === undefined) return false;
-    if (lease.ending) return true;
-    lease.markEnding(reason);
-    this.publishLane();
-    return true;
-  }
-
-  registerBackground(kind: string, controller: AbortController): IDisposable & { readonly id: string } {
-    const id = `bg-${nextBackgroundId++}`;
-    const ref: BackgroundActivityRef = {
-      kind,
-      id,
-      since: Date.now(),
-      signal: controller.signal,
-    };
-    this.background.set(id, { ref, controller });
-    this.publishLane();
-    const dispose = (): void => {
-      if (this.background.delete(id)) {
-        this.publishLane();
-      }
-      this.maybeSettle();
-    };
-    return { id, dispose };
-  }
-
-  beginDisposal(): void {
-    if (this._lane === 'disposing' || this._lane === 'disposed') return;
-    this._lane = 'disposing';
-    this.activeLease?.markEnding();
-    for (const entry of this.background.values()) {
-      entry.controller.abort();
-    }
-    this.publishLane();
-    this.maybeSettle();
-  }
-
-  settled(): Promise<void> {
-    if (this._lane === 'disposed') return Promise.resolve();
-    if (
-      this._lane !== 'disposing' &&
-      this.activeLease === undefined &&
-      this.background.size === 0
-    ) {
-      return Promise.resolve();
-    }
-    return new Promise<void>((resolve) => {
-      this.settleWaiters.push(resolve);
-    });
-  }
-
-  onLeaseEnd(
-    lease: LeaseImpl,
-    outcome: 'completed' | 'cancelled' | 'failed',
-    _detail?: { error?: unknown },
-  ): void {
-    if (this.activeLease !== lease) return;
-    this.activeLease = undefined;
-    lease.registration.dispose();
-    lease.registration = Disposable.None;
-    this.lastTurn = { turnId: lease.turnId, reason: outcome, at: Date.now() };
-    if (this._lane === 'disposing') {
-      this.maybeSettle();
-      return;
-    }
-    this._lane = 'idle';
-    this.publishLane();
-    this.maybeSettle();
-  }
-
-  private maybeSettle(): void {
-    if (this.activeLease !== undefined || this.background.size > 0) return;
-    if (this._lane === 'disposing') {
-      this._lane = 'disposed';
-      this.publishLane();
-    }
-    if (this.settleWaiters.length === 0) return;
-    const waiters = this.settleWaiters.splice(0);
-    for (const resolve of waiters) resolve();
-  }
-
-  private publishLane(): void {
-    const lease = this.activeLease;
-    this.wire.dispatch(
-      setLane({
-        next: {
-          lane: this._lane,
-          turn:
-            lease === undefined
-              ? undefined
-              : {
-                  turnId: lease.turnId,
-                  origin: lease.origin,
-                  ending: lease.ending,
-                  endingReason: lease.endingReason,
-                  since: lease.since,
-                },
-          lastTurn: this.lastTurn,
-          background: [...this.background.values()].map((entry) => entry.ref),
-        },
-      }),
-    );
-  }
-}
-
-registerScopedService(
-  LifecycleScope.Agent,
-  IAgentActivityService,
-  AgentActivityService,
-  InstantiationType.Eager,
-  'activity',
-);
diff --git a/packages/agent-core-v2/src/activity/errors.ts b/packages/agent-core-v2/src/activity/errors.ts
deleted file mode 100644
index f3a670682..000000000
--- a/packages/agent-core-v2/src/activity/errors.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * `activity` domain error codes.
- *
- * `activity.agent_busy` inherits the retryable semantics of the legacy
- * `turn.agent_busy`; the two coexist during migration, and `turn.*` callers
- * move to the new code before the legacy one is retired. The legacy
- * `TURN_AGENT_BUSY` code itself is also registered here: with the `turn`
- * domain folded into `loop`, skill activation is its last thrower, and this
- * is the migration harbor that retires it once that caller moves over.
- */
-
-import { registerErrorDomain, type ErrorDomain } from '#/_base/errors/codes';
-
-export const ActivityErrors = {
-  codes: {
-    ACTIVITY_AGENT_BUSY: 'activity.agent_busy',
-    ACTIVITY_CANCELLING: 'activity.cancelling',
-    ACTIVITY_DISPOSING: 'activity.disposing',
-    ACTIVITY_DISPOSED: 'activity.disposed',
-    ACTIVITY_INITIALIZING: 'activity.initializing',
-    ACTIVITY_SESSION_REJECTED: 'activity.session_rejected',
-    TURN_AGENT_BUSY: 'turn.agent_busy',
-  },
-  retryable: [
-    'activity.agent_busy',
-    'activity.cancelling',
-    'activity.initializing',
-    'activity.session_rejected',
-    'turn.agent_busy',
-  ],
-} as const satisfies ErrorDomain;
-
-registerErrorDomain(ActivityErrors);
diff --git a/packages/agent-core-v2/src/activity/sessionActivityKernel.ts b/packages/agent-core-v2/src/activity/sessionActivityKernel.ts
deleted file mode 100644
index 39848eb59..000000000
--- a/packages/agent-core-v2/src/activity/sessionActivityKernel.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-/**
- * `activity` domain (L4) — `ISessionActivityKernel` implementation.
- *
- * Owns the Session activity lane (`restoring → active ⇄ quiescing → closing →
- * disposed`) and the admission table that the Agent kernel consults on every
- * `begin` (child-injects-parent). `restoring` covers the materialize / replay
- * window (the half-initialized handle of矛盾 j): the lifecycle drives the
- * `restoring → active` transition via `markActive()` once the session is ready.
- * `quiesce()` atomically flips to `quiescing` (closing the door so subsequent
- * `admitTurn` calls reject with `activity.session_rejected`) and awaits every
- * in-flight lease to drain — this eliminates the fork check-then-act race
- * (矛盾 k). `beginClosing()` starts the close/archive cascade; `settled()`
- * resolves once every admitted lease has returned. The lane is mirrored to the
- * live-only `sessionActivityLane` wire Model for the derived `ISessionActivity`
- * read model. Bound at Session scope.
- */
-
-import { Disposable, toDisposable, type IDisposable } from '#/_base/di/lifecycle';
-import { InstantiationType } from '#/_base/di/extensions';
-import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { ErrorCodes, Error2 } from '#/errors';
-
-import type {
-  ActivityLease,
-  SessionCommand,
-  SessionLane,
-  SessionQuiesceLease,
-} from './activity';
-import { ISessionActivityKernel } from './activity';
-
-export class SessionActivityKernel extends Disposable implements ISessionActivityKernel {
-  declare readonly _serviceBrand: undefined;
-
-  private _lane: SessionLane = 'restoring';
-  private readonly leases = new Map<string, ActivityLease>();
-  private readonly settleWaiters: Array<() => void> = [];
-
-  constructor() {
-    super();
-  }
-
-  lane(): SessionLane {
-    return this._lane;
-  }
-
-  canAccept(command: SessionCommand): boolean {
-    switch (this._lane) {
-      case 'active':
-        return true;
-      case 'restoring':
-        return command === 'agent.create';
-      default:
-        return false;
-    }
-  }
-
-  admitTurn(agentId: string, lease: ActivityLease): IDisposable {
-    if (this._lane !== 'active') {
-      throw new Error2(
-        ErrorCodes.ACTIVITY_SESSION_REJECTED,
-        `Session is ${this._lane}; turn begin rejected`,
-        { details: { lane: this._lane, agentId } },
-      );
-    }
-    const key = `${agentId}:${lease.turnId}`;
-    this.leases.set(key, lease);
-    this.publishLane();
-    return toDisposable(() => {
-      this.leases.delete(key);
-      this.publishLane();
-      this.maybeSettle();
-    });
-  }
-
-  quiesce(reason: string): Promise<SessionQuiesceLease> {
-    if (this._lane !== 'active') {
-      return Promise.reject(
-        new Error2(
-          ErrorCodes.ACTIVITY_SESSION_REJECTED,
-          `Cannot quiesce while ${this._lane}`,
-          { details: { lane: this._lane } },
-        ),
-      );
-    }
-    this._lane = 'quiescing';
-    this.publishLane();
-    return this.settled().then(() => {
-      let released = false;
-      return {
-        reason,
-        dispose: () => {
-          if (released) return;
-          released = true;
-          if (this._lane === 'quiescing') {
-            this._lane = 'active';
-            this.publishLane();
-          }
-        },
-      };
-    });
-  }
-
-  beginClosing(): void {
-    if (this._lane === 'closing' || this._lane === 'disposed') return;
-    this._lane = 'closing';
-    this.publishLane();
-    this.maybeSettle();
-  }
-
-  markActive(): void {
-    if (this._lane !== 'restoring') return;
-    this._lane = 'active';
-    this.publishLane();
-  }
-
-  settled(): Promise<void> {
-    if (this.leases.size === 0) return Promise.resolve();
-    return new Promise<void>((resolve) => {
-      this.settleWaiters.push(resolve);
-    });
-  }
-
-  private maybeSettle(): void {
-    if (this.leases.size > 0) return;
-    if (this._lane === 'closing') {
-      this._lane = 'disposed';
-      this.publishLane();
-    }
-    if (this.settleWaiters.length === 0) return;
-    const waiters = this.settleWaiters.splice(0);
-    for (const resolve of waiters) resolve();
-  }
-
-  private publishLane(): void {
-  }
-}
-
-registerScopedService(
-  LifecycleScope.Session,
-  ISessionActivityKernel,
-  SessionActivityKernel,
-  InstantiationType.Eager,
-  'activity',
-);
diff --git a/packages/agent-core-v2/src/agent/activityView/activityView.ts b/packages/agent-core-v2/src/agent/activityView/activityView.ts
new file mode 100644
index 000000000..bf67c2cb2
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/activityView/activityView.ts
@@ -0,0 +1,105 @@
+/**
+ * `activityView` domain (L4) — the agent's one-way activity projection.
+ *
+ * Defines `IAgentActivityView`: a per-agent, read-only, event-folded read
+ * model of "what this agent is doing" — the current turn with its live
+ * phase/stream/step/retry/pending-approval/tool-call detail and the latest
+ * turn outcome, published on the agent's event bus as
+ * `agent.activity.updated`. The view OWNS NO authoritative state: every fact
+ * is folded from the agent's own event bus (loop turn/step/delta/tool/retry,
+ * permission approval, task, and full-compaction events) and seeded once from
+ * the owning services; it can be discarded and rebuilt at any time. Turn
+ * mechanics live in the loop, admission/drain in the session lifecycle, and
+ * background work in task/full-compaction services — none of that is
+ * duplicated here. Bound at Agent scope — one instance per agent, dying with
+ * it.
+ */
+
+import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
+import type { PromptOrigin } from '#/agent/contextMemory/types';
+import type { TurnEndReason } from '#/agent/loop/turnEvents';
+
+export type TurnPhase = 'running' | 'streaming' | 'tool_call' | 'retrying';
+
+export interface ApprovalRef {
+  readonly approvalId: string;
+  readonly toolCallId?: string;
+  readonly since: number;
+}
+
+export interface ToolCallRef {
+  readonly toolCallId: string;
+  readonly name: string;
+  readonly since: number;
+}
+
+export interface ActivityRetryState {
+  readonly failedAttempt: number;
+  readonly nextAttempt: number;
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly errorName?: string;
+  readonly statusCode?: number;
+}
+
+export interface ActivityTurnState {
+  readonly turnId: number;
+  readonly origin: PromptOrigin;
+  readonly phase: TurnPhase;
+  readonly stream?: 'assistant' | 'thinking' | 'tool_call';
+  readonly step: number;
+  readonly ending: boolean;
+  readonly endingReason?: 'aborted' | 'max_steps' | 'error';
+  readonly retry?: ActivityRetryState;
+  readonly pendingApprovals: readonly ApprovalRef[];
+  readonly activeToolCalls: readonly ToolCallRef[];
+  readonly since: number;
+}
+
+export interface ActivityLastTurnState {
+  readonly turnId: number;
+  readonly reason: TurnEndReason;
+  readonly durationMs?: number;
+  readonly at: number;
+}
+
+/**
+ * Coarse existence reference to one piece of the agent's active background
+ * work (task or full compaction) — the second busy layer. Owner-specific
+ * details live in their own domains; this carries only "there is live
+ * background work".
+ */
+export interface BackgroundRef {
+  readonly kind: string;
+  readonly id: string;
+  readonly since: number;
+}
+
+/** The view's lifecycle slice: `ready` once materialized, `disposed` when the
+ *  agent is being torn down. There is no `initializing` state — the view is
+ *  created lazily and a restoring agent exposes no handles yet. */
+export type ActivityViewLifecycle = 'ready' | 'disposed';
+
+/** The agent's folded activity snapshot — the payload of `agent.activity.updated`. */
+export interface AgentActivityState {
+  readonly lifecycle: ActivityViewLifecycle;
+  readonly turn?: ActivityTurnState;
+  readonly lastTurn?: ActivityLastTurnState;
+  readonly background: readonly BackgroundRef[];
+}
+
+export interface IAgentActivityView {
+  readonly _serviceBrand: undefined;
+
+  /** The current folded snapshot (cheap to recompute; do not cache long-term). */
+  state(): AgentActivityState;
+}
+
+export const IAgentActivityView: ServiceIdentifier<IAgentActivityView> =
+  createDecorator<IAgentActivityView>('agentActivityView');
+
+declare module '#/app/event/eventBus' {
+  interface DomainEventMap {
+    'agent.activity.updated': AgentActivityState & { readonly type: 'agent.activity.updated' };
+  }
+}
diff --git a/packages/agent-core-v2/src/agent/activityView/activityViewService.ts b/packages/agent-core-v2/src/agent/activityView/activityViewService.ts
new file mode 100644
index 000000000..fdee68fc0
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/activityView/activityViewService.ts
@@ -0,0 +1,364 @@
+/**
+ * `activityView` domain (L4) — `IAgentActivityView` implementation.
+ *
+ * A pure fold of the agent's own event bus: turn boundaries drive the turn
+ * slice (active → detail updates → ended → `lastTurn`), step/delta/tool/retry
+ * events drive the live phase/stream/retry detail, permission approval events
+ * drive the pending-approval list, while task and full-compaction events drive
+ * the background-work slice. The view seeds once from `IAgentLoopService`,
+ * `IAgentTaskService`, and `IAgentFullCompactionService` (reads, never writes)
+ * and otherwise holds only derived state, so it can be discarded and rebuilt
+ * at any time. Bound at Agent scope.
+ */
+
+import { Disposable } from '#/_base/di/lifecycle';
+import { InstantiationType } from '#/_base/di/extensions';
+import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
+import { IEventBus } from '#/app/event/eventBus';
+import { IAgentLoopService } from '#/agent/loop/loop';
+import { IAgentTaskService } from '#/agent/task/task';
+import { IAgentFullCompactionService } from '#/agent/fullCompaction/fullCompaction';
+import { USER_PROMPT_ORIGIN } from '#/agent/contextMemory/types';
+import type { PromptOrigin } from '#/agent/contextMemory/types';
+import type { TurnEndReason } from '#/agent/loop/turnEvents';
+
+import type {
+  ActivityLastTurnState,
+  ActivityRetryState,
+  ActivityTurnState,
+  ActivityViewLifecycle,
+  AgentActivityState,
+  ApprovalRef,
+  BackgroundRef,
+  ToolCallRef,
+  TurnPhase,
+} from './activityView';
+import { IAgentActivityView } from './activityView';
+
+type EndingReason = NonNullable<ActivityTurnState['endingReason']>;
+const FULL_COMPACTION_BACKGROUND_ID = 'full-compaction';
+
+export class AgentActivityView extends Disposable implements IAgentActivityView {
+  declare readonly _serviceBrand: undefined;
+
+  private lifecycle: ActivityViewLifecycle = 'ready';
+  private turn: MutableTurn | undefined;
+  private lastTurn: ActivityLastTurnState | undefined;
+  private readonly background = new Map<string, BackgroundRef>();
+  private current: AgentActivityState = { lifecycle: 'ready', background: [] };
+
+  constructor(
+    @IEventBus private readonly eventBus: IEventBus,
+    @IAgentLoopService private readonly loop: IAgentLoopService,
+    @IAgentTaskService private readonly tasks: IAgentTaskService,
+    @IAgentFullCompactionService private readonly fullCompaction: IAgentFullCompactionService,
+  ) {
+    super();
+    this.seedFromLoop();
+    this.seedFromTasks();
+    this.seedFromFullCompaction();
+
+    this._register(this.eventBus.subscribe('turn.started', (e) => this.onTurnStarted(e.turnId, e.origin)));
+    this._register(this.eventBus.subscribe('turn.step.started', (e) => this.onStepStarted(e.step)));
+    this._register(this.eventBus.subscribe('assistant.delta', () => this.onDelta('assistant')));
+    this._register(this.eventBus.subscribe('thinking.delta', () => this.onDelta('thinking')));
+    this._register(this.eventBus.subscribe('tool.call.delta', () => this.onDelta('tool_call')));
+    this._register(
+      this.eventBus.subscribe('tool.call.started', (e) => this.onToolCallStarted(e.toolCallId, e.name)),
+    );
+    this._register(this.eventBus.subscribe('tool.result', (e) => this.onToolResult(e.toolCallId)));
+    this._register(
+      this.eventBus.subscribe('turn.step.retrying', (e) => {
+        this.mutateTurn((t) => {
+          t.phase = 'retrying';
+          t.stream = undefined;
+          t.retry = {
+            failedAttempt: e.failedAttempt,
+            nextAttempt: e.nextAttempt,
+            maxAttempts: e.maxAttempts,
+            delayMs: e.delayMs,
+            errorName: e.errorName,
+            statusCode: e.statusCode,
+          };
+        });
+      }),
+    );
+    this._register(
+      this.eventBus.subscribe('turn.step.completed', () => {
+        this.mutateTurn((t) => {
+          t.phase = 'running';
+          t.stream = undefined;
+          t.retry = undefined;
+        });
+      }),
+    );
+    this._register(
+      this.eventBus.subscribe('turn.step.interrupted', (e) => this.onStepInterrupted(e.turnId, e.reason)),
+    );
+    this._register(
+      this.eventBus.subscribe('turn.ended', (e) => this.onTurnEnded(e.turnId, e.reason)),
+    );
+    this._register(
+      this.eventBus.subscribe('permission.approval.requested', (e) =>
+        this.onApprovalRequested(e.toolCallId),
+      ),
+    );
+    this._register(
+      this.eventBus.subscribe('permission.approval.resolved', (e) =>
+        this.onApprovalResolved(e.toolCallId),
+      ),
+    );
+    this._register(
+      this.eventBus.subscribe('task.started', (e) => {
+        this.background.set(e.info.taskId, {
+          kind: e.info.kind,
+          id: e.info.taskId,
+          since: e.info.startedAt,
+        });
+        this.publish();
+      }),
+    );
+    this._register(
+      this.eventBus.subscribe('task.terminated', (e) => {
+        if (this.background.delete(e.info.taskId)) this.publish();
+      }),
+    );
+    this._register(
+      this.eventBus.subscribe('compaction.started', () => {
+        this.background.set(FULL_COMPACTION_BACKGROUND_ID, {
+          kind: 'compaction',
+          id: FULL_COMPACTION_BACKGROUND_ID,
+          since: Date.now(),
+        });
+        this.publish();
+      }),
+    );
+    this._register(
+      this.eventBus.subscribe('compaction.completed', () => {
+        this.onFullCompactionEnded();
+      }),
+    );
+    this._register(
+      this.eventBus.subscribe('compaction.cancelled', () => {
+        this.onFullCompactionEnded();
+      }),
+    );
+  }
+
+  state(): AgentActivityState {
+    return this.current;
+  }
+
+  override dispose(): void {
+    this.lifecycle = 'disposed';
+    this.publish();
+    super.dispose();
+  }
+
+  // -------------------------------------------------------------------------
+
+  private seedFromLoop(): void {
+    const status = this.loop.status();
+    if (status.state !== 'running' || status.activeTurnId === undefined) return;
+    this.turn = new MutableTurn(status.activeTurnId, USER_PROMPT_ORIGIN);
+    this.publish();
+  }
+
+  /** Seed the background slice from the task registry (restart-persistent
+   *  tasks may already be running when the view is created). */
+  private seedFromTasks(): void {
+    for (const info of this.tasks.list(true)) {
+      this.background.set(info.taskId, { kind: info.kind, id: info.taskId, since: info.startedAt });
+    }
+    if (this.background.size > 0) this.publish();
+  }
+
+  private seedFromFullCompaction(): void {
+    if (this.fullCompaction.compacting === null) return;
+    this.background.set(FULL_COMPACTION_BACKGROUND_ID, {
+      kind: 'compaction',
+      id: FULL_COMPACTION_BACKGROUND_ID,
+      since: Date.now(),
+    });
+    this.publish();
+  }
+
+  private onFullCompactionEnded(): void {
+    if (this.background.delete(FULL_COMPACTION_BACKGROUND_ID)) this.publish();
+  }
+
+  private onTurnStarted(turnId: number, origin?: PromptOrigin): void {
+    this.turn = new MutableTurn(turnId, origin ?? USER_PROMPT_ORIGIN);
+    // A fresh turn means there is no current outcome: drop the previous
+    // turn's terminal reason so consumers (the work_changed fold, REST
+    // session facts) stop reporting it while this turn runs. turn.ended
+    // publishes the new outcome when the turn finishes.
+    this.lastTurn = undefined;
+    this.publish();
+  }
+
+  private onTurnEnded(turnId: number, reason: TurnEndReason): void {
+    if (this.turn === undefined || this.turn.turnId !== turnId) {
+      // A turn the view never saw (e.g. seeded late) — still record the outcome.
+      this.lastTurn = { turnId, reason, at: Date.now() };
+      this.publish();
+      return;
+    }
+    this.lastTurn = { turnId, reason, durationMs: Date.now() - this.turn.since, at: Date.now() };
+    this.turn = undefined;
+    this.publish();
+  }
+
+  private onStepStarted(step: number): void {
+    this.mutateTurn((t) => {
+      t.step = step;
+      t.phase = 'running';
+      t.stream = undefined;
+      t.retry = undefined;
+    });
+  }
+
+  private onStepInterrupted(turnId: number, reason: string): void {
+    if (reason !== 'aborted' && reason !== 'max_steps' && reason !== 'error') return;
+    this.mutateTurn((t) => {
+      if (t.turnId !== turnId) return;
+      t.ending = true;
+      t.endingReason = reason;
+    });
+  }
+
+  private onDelta(stream: 'assistant' | 'thinking' | 'tool_call'): void {
+    this.mutateTurn((t) => {
+      t.phase = 'streaming';
+      t.stream = stream;
+      t.retry = undefined;
+    });
+  }
+
+  private onToolCallStarted(toolCallId: string, name: string): void {
+    this.mutateTurn((t) => {
+      t.phase = 'tool_call';
+      t.stream = undefined;
+      t.retry = undefined;
+      t.activeToolCalls.set(toolCallId, { toolCallId, name, since: Date.now() });
+    });
+  }
+
+  private onToolResult(toolCallId: string): void {
+    this.mutateTurn((t) => {
+      t.activeToolCalls.delete(toolCallId);
+      t.phase = t.activeToolCalls.size === 0 ? 'running' : 'tool_call';
+      t.stream = undefined;
+      t.retry = undefined;
+    });
+  }
+
+  private onApprovalRequested(toolCallId: string): void {
+    this.mutateTurn((t) => {
+      t.pendingApprovals.set(toolCallId, { approvalId: toolCallId, toolCallId, since: Date.now() });
+    });
+  }
+
+  private onApprovalResolved(toolCallId: string): void {
+    this.mutateTurn((t) => {
+      t.pendingApprovals.delete(toolCallId);
+    });
+  }
+
+  // -------------------------------------------------------------------------
+
+  private mutateTurn(mutate: (t: MutableTurn) => void): void {
+    if (this.turn === undefined) return;
+    mutate(this.turn);
+    this.publish();
+  }
+
+  private publish(): void {
+    const t = this.turn;
+    const next: AgentActivityState = {
+      lifecycle: this.lifecycle,
+      turn: t === undefined ? undefined : t.snapshot(),
+      lastTurn: this.lastTurn,
+      background: [...this.background.values()],
+    };
+    if (activityEqual(this.current, next)) return;
+    this.current = next;
+    this.eventBus.publish({ type: 'agent.activity.updated', ...next });
+  }
+}
+
+class MutableTurn {
+  phase: TurnPhase = 'running';
+  stream: ActivityTurnState['stream'];
+  step = 0;
+  ending = false;
+  endingReason: EndingReason | undefined;
+  retry: ActivityRetryState | undefined;
+  readonly pendingApprovals = new Map<string, ApprovalRef>();
+  readonly activeToolCalls = new Map<string, ToolCallRef>();
+  readonly since = Date.now();
+
+  constructor(
+    readonly turnId: number,
+    readonly origin: PromptOrigin,
+  ) {}
+
+  snapshot(): ActivityTurnState {
+    return {
+      turnId: this.turnId,
+      origin: this.origin,
+      phase: this.phase,
+      stream: this.stream,
+      step: this.step,
+      ending: this.ending,
+      endingReason: this.endingReason,
+      retry: this.retry,
+      pendingApprovals: [...this.pendingApprovals.values()],
+      activeToolCalls: [...this.activeToolCalls.values()],
+      since: this.since,
+    };
+  }
+}
+
+function activityEqual(a: AgentActivityState, b: AgentActivityState): boolean {
+  if (a.lifecycle !== b.lifecycle) return false;
+  if ((a.turn === undefined) !== (b.turn === undefined)) return false;
+  if (a.turn !== undefined && b.turn !== undefined) {
+    const ta = a.turn;
+    const tb = b.turn;
+    if (
+      ta.turnId !== tb.turnId ||
+      ta.phase !== tb.phase ||
+      ta.stream !== tb.stream ||
+      ta.step !== tb.step ||
+      ta.ending !== tb.ending ||
+      ta.endingReason !== tb.endingReason ||
+      ta.pendingApprovals.length !== tb.pendingApprovals.length ||
+      ta.activeToolCalls.length !== tb.activeToolCalls.length
+    ) {
+      return false;
+    }
+    if (ta.retry?.nextAttempt !== tb.retry?.nextAttempt) return false;
+  }
+  if ((a.lastTurn === undefined) !== (b.lastTurn === undefined)) return false;
+  if (a.lastTurn !== undefined && b.lastTurn !== undefined) {
+    if (a.lastTurn.turnId !== b.lastTurn.turnId || a.lastTurn.reason !== b.lastTurn.reason) {
+      return false;
+    }
+  }
+  if (a.background.length !== b.background.length) return false;
+  for (let i = 0; i < a.background.length; i++) {
+    if (a.background[i]!.id !== b.background[i]!.id || a.background[i]!.kind !== b.background[i]!.kind) {
+      return false;
+    }
+  }
+  return true;
+}
+
+registerScopedService(
+  LifecycleScope.Agent,
+  IAgentActivityView,
+  AgentActivityView,
+  InstantiationType.Delayed,
+  'activityView',
+);
diff --git a/packages/agent-core-v2/src/agent/contextInjector/contextInjectorService.ts b/packages/agent-core-v2/src/agent/contextInjector/contextInjectorService.ts
index b282b6746..0c0934a16 100644
--- a/packages/agent-core-v2/src/agent/contextInjector/contextInjectorService.ts
+++ b/packages/agent-core-v2/src/agent/contextInjector/contextInjectorService.ts
@@ -15,8 +15,7 @@ import { IAgentLoopService } from '#/agent/loop/loop';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
 import { IEventBus } from '#/app/event/eventBus';
 import type { ContextMessage } from '#/agent/contextMemory/types';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import {
   IAgentContextInjectorService,
   type ContextInjectionProvider,
@@ -38,7 +37,7 @@ export class AgentContextInjectorService extends Disposable implements IAgentCon
     @IAgentLoopService loopService: IAgentLoopService,
     @IAgentSystemReminderService private readonly reminders: IAgentSystemReminderService,
     @IEventBus private readonly eventBus: IEventBus,
-    @IAgentWireService wire: IWireService,
+    @IWireService wire: IWireService,
   ) {
     super();
     this._register(
@@ -52,12 +51,17 @@ export class AgentContextInjectorService extends Disposable implements IAgentCon
         this.isNewTurn = true;
       }),
     );
-    this._register(this.eventBus.subscribe('context.spliced', (e) => {
-      this.handleSplice(e);
-    }));
-    this._register(wire.onRestored(() => {
-      this.resyncPositions();
-    }));
+    this._register(
+      this.eventBus.subscribe('context.spliced', (e) => {
+        this.handleSplice(e);
+      }),
+    );
+    this._register(
+      wire.hooks.onDidRestore.register('context-injector', async (_ctx, next) => {
+        this.resyncPositions();
+        await next();
+      }),
+    );
   }
 
   register(
diff --git a/packages/agent-core-v2/src/agent/contextMemory/contextMemoryService.ts b/packages/agent-core-v2/src/agent/contextMemory/contextMemoryService.ts
index 0c8bfe87d..bbbde1547 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/contextMemoryService.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/contextMemoryService.ts
@@ -12,11 +12,11 @@
  * computed through `contextProjector` when the measured aggregate is
  * truncated, so a folded stored history never poisons the gauge); `append`
  * leaves the measured prefix untouched since
- * new messages are the unmeasured tail (see `contextSizeService`). Every
- * mutation still fires `onSpliced` from the live path only (replay rebuilds
- * the Model silently and never invokes these methods), so existing subscribers
- * (context-injector, task-notification) observe the same
- * splice-shaped change events regardless of which Op was persisted. Messages
+ * new messages are the unmeasured tail (see `contextSizeService`).
+ * Splice-shaped mutations publish `context.spliced` from the live path only
+ * (replay rebuilds the Model silently and never invokes these methods), so
+ * existing subscribers observe the same change regardless of which Op was
+ * persisted. Messages
  * are persisted without local ids — the on-disk record matches v1's field set
  * and public message ids are derived from the transcript index. Blob
  * dehydrate/rehydrate is declared on `ContextModel.blobs`. Bound at
@@ -26,13 +26,11 @@
 import { Disposable } from '#/_base/di/lifecycle';
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { estimateTokensForMessages } from '#/_base/utils/tokens';
 import { IEventBus } from '#/app/event/eventBus';
 import { IAgentContextProjectorService } from '#/agent/contextProjector/contextProjector';
 import { ContextSizeModel, contextSizeMeasured } from '#/agent/contextSize/contextSizeOps';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 import type { Op } from '#/wire/op';
-import type { IWireService } from '#/wire/wireService';
 
 import {
   IAgentContextMemoryService,
@@ -69,7 +67,7 @@ export class AgentContextMemoryService extends Disposable implements IAgentConte
   declare readonly _serviceBrand: undefined;
 
   constructor(
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
     @IAgentContextProjectorService private readonly projector: IAgentContextProjectorService,
   ) {
@@ -90,6 +88,7 @@ export class AgentContextMemoryService extends Disposable implements IAgentConte
   appendLoopEvent(event: LoopRecordedEvent): void {
     this.wire.dispatch(contextAppendLoopEvent({ event }));
   }
+
   clear(): void {
     const deleteCount = this.get().length;
     if (deleteCount === 0) return;
diff --git a/packages/agent-core-v2/src/agent/contextMemory/contextOps.ts b/packages/agent-core-v2/src/agent/contextMemory/contextOps.ts
index 5f630a250..7638a5c3d 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/contextOps.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/contextOps.ts
@@ -36,7 +36,7 @@ import { z } from 'zod';
 
 import type { ContentPart } from '#/app/llmProtocol/message';
 import { defineModel, type PartsTransformer } from '#/wire/model';
-import type { PersistedRecord } from '#/wire/wireService';
+import type { WireRecord } from '#/wire/record';
 
 import {
   buildContextCompactionShape,
@@ -70,9 +70,9 @@ async function dehydrateMessages(
 }
 
 async function dehydrateRecord(
-  record: PersistedRecord,
+  record: WireRecord,
   transform: PartsTransformer,
-): Promise<PersistedRecord> {
+): Promise<WireRecord> {
   if (record.type === 'context.append_message') {
     const message = record['message'] as ContextMessage | undefined;
     if (message === undefined) return record;
diff --git a/packages/agent-core-v2/src/agent/contextMemory/contextTranscript.ts b/packages/agent-core-v2/src/agent/contextMemory/contextTranscript.ts
index 92c179763..481dd5865 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/contextTranscript.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/contextTranscript.ts
@@ -29,7 +29,7 @@
  */
 
 import { type ContentPart, type ToolCall } from '#/app/llmProtocol/message';
-import type { PersistedRecord } from '#/wire/wireService';
+import type { WireRecord } from '#/wire/record';
 
 import {
   COMPACT_USER_MESSAGE_MAX_TOKENS,
@@ -49,6 +49,11 @@ export interface ContextTranscript {
   readonly foldedLength: number;
 }
 
+export interface ContextTranscriptReducer {
+  add(record: WireRecord): void;
+  result(): ContextTranscript;
+}
+
 interface MutableMessage {
   id?: string;
   role: ContextMessage['role'];
@@ -64,7 +69,13 @@ interface MutableEntry {
   time?: number;
 }
 
-export function reduceContextTranscript(records: Iterable<PersistedRecord>): ContextTranscript {
+export function reduceContextTranscript(records: Iterable<WireRecord>): ContextTranscript {
+  const reducer = createContextTranscriptReducer();
+  for (const record of records) reducer.add(record);
+  return reducer.result();
+}
+
+export function createContextTranscriptReducer(): ContextTranscriptReducer {
   const transcript: MutableEntry[] = [];
   let foldedLength = 0;
   let clearFloor = 0;
@@ -176,7 +187,7 @@ export function reduceContextTranscript(records: Iterable<PersistedRecord>): Con
     resetOpenState();
   };
 
-  for (const record of records) {
+  const add = (record: WireRecord): void => {
     switch (record.type) {
       case 'context.append_message': {
         const entry = toMutableEntry(record['message'] as ContextMessage, record.time);
@@ -212,12 +223,15 @@ export function reduceContextTranscript(records: Iterable<PersistedRecord>): Con
       default:
         break;
     }
-  }
+  };
 
   return {
-    entries: transcript.map((e) => e.message),
-    times: transcript.map((e) => e.time),
-    foldedLength,
+    add,
+    result: () => ({
+      entries: transcript.map((e) => e.message),
+      times: transcript.map((e) => e.time),
+      foldedLength,
+    }),
   };
 }
 
@@ -237,7 +251,7 @@ function toMutableEntry(message: ContextMessage, time: number | undefined): Muta
 }
 
 function recoverFoldedLength(
-  record: PersistedRecord,
+  record: WireRecord,
   transcript: readonly MutableEntry[],
   clearFloor: number,
   foldedLength: number,
@@ -258,7 +272,7 @@ function recoverFoldedLength(
   return keptUserMessages.length + 1;
 }
 
-function readCompactionSummaryText(record: PersistedRecord): string {
+function readCompactionSummaryText(record: WireRecord): string {
   const summary = record['summary'];
   if (typeof summary === 'string') return summary;
   const contextSummary = record['contextSummary'];
@@ -281,7 +295,7 @@ function textOfParts(content: readonly ContentPart[]): string {
   return text;
 }
 
-function readNumber(record: PersistedRecord, key: string): number | undefined {
+function readNumber(record: WireRecord, key: string): number | undefined {
   const value = record[key];
   return typeof value === 'number' ? value : undefined;
 }
diff --git a/packages/agent-core-v2/src/agent/contextMemory/loopEventFold.ts b/packages/agent-core-v2/src/agent/contextMemory/loopEventFold.ts
index c0271fd96..89b1af874 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/loopEventFold.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/loopEventFold.ts
@@ -9,7 +9,7 @@
  * the v2 live loop emits the same records (`LoopService` →
  * `ContextMemory.appendLoopEvent`), keeping the on-disk shape byte-compatible.
  * This fold turns them into assistant / tool messages — at live dispatch time
- * and again when `WireService.replay` restores a session. Without it, replay
+ * and again when `WireService.restore` restores an Agent. Without it, restore
  * would skip those records (no Op is registered for the type) and the restored
  * `ContextModel` — and every consumer built on it (`/messages`, `/snapshot`,
  * live resume) — would show only the user prompts.
diff --git a/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts b/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
index 48ac6dddd..11df04c4a 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
@@ -15,7 +15,7 @@
  * so REST consumers can still render the media after reload/resume.
  */
 
-import type { Message, MessageContent, MessageRole, ToolUseContent } from '@moonshot-ai/protocol';
+import type { Message, MessageContent, MessageRole, ToolUseContent } from './protocolMessage';
 
 import type { ContextMessage } from './types';
 
diff --git a/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts b/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
new file mode 100644
index 000000000..6db5d6572
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
@@ -0,0 +1,100 @@
+/**
+ * The wire `Message` shape — the legacy REST/streaming message format served
+ * on the `messages`, `snapshot`, and `sessions` (`:undo`) edge surfaces.
+ * Defined next to `messageProjection.ts`, which projects `ContextMessage`
+ * into this shape; consumed by the `messageLegacy` edge adapter and the
+ * transports.
+ */
+
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '#/_base/utils/isoDateTime';
+
+export const messageRoleSchema = z.enum(['user', 'assistant', 'tool', 'system']);
+export type MessageRole = z.infer<typeof messageRoleSchema>;
+
+export const textContentSchema = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+});
+export type TextContent = z.infer<typeof textContentSchema>;
+
+export const toolUseContentSchema = z.object({
+  type: z.literal('tool_use'),
+  tool_call_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  input: z.unknown(),
+});
+export type ToolUseContent = z.infer<typeof toolUseContentSchema>;
+
+export const toolResultContentSchema = z.object({
+  type: z.literal('tool_result'),
+  tool_call_id: z.string().min(1),
+  output: z.unknown(),
+  is_error: z.boolean().optional(),
+});
+export type ToolResultContent = z.infer<typeof toolResultContentSchema>;
+
+export const imageSourceSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('url'), url: z.string().min(1) }),
+  z.object({
+    kind: z.literal('base64'),
+    media_type: z.string().min(1),
+    data: z.string().min(1),
+  }),
+  z.object({ kind: z.literal('file'), file_id: z.string().min(1) }),
+]);
+export type ImageSource = z.infer<typeof imageSourceSchema>;
+
+export const imageContentSchema = z.object({
+  type: z.literal('image'),
+  source: imageSourceSchema,
+});
+export type ImageContent = z.infer<typeof imageContentSchema>;
+
+// Video uses the same source shape as image (url / base64 / uploaded file id).
+export const videoContentSchema = z.object({
+  type: z.literal('video'),
+  source: imageSourceSchema,
+});
+export type VideoContent = z.infer<typeof videoContentSchema>;
+
+export const fileContentSchema = z.object({
+  type: z.literal('file'),
+  file_id: z.string().min(1),
+  name: z.string(),
+  media_type: z.string().min(1),
+  size: z.number().int().nonnegative(),
+});
+export type FileContent = z.infer<typeof fileContentSchema>;
+
+export const thinkingContentSchema = z.object({
+  type: z.literal('thinking'),
+  thinking: z.string(),
+  signature: z.string().optional(),
+});
+export type ThinkingContent = z.infer<typeof thinkingContentSchema>;
+
+export const messageContentSchema = z.discriminatedUnion('type', [
+  textContentSchema,
+  toolUseContentSchema,
+  toolResultContentSchema,
+  imageContentSchema,
+  videoContentSchema,
+  fileContentSchema,
+  thinkingContentSchema,
+]);
+export type MessageContent = z.infer<typeof messageContentSchema>;
+
+export const messageSchema = z.object({
+  id: z.string().min(1),
+  session_id: z.string().min(1),
+  role: messageRoleSchema,
+  content: z.array(messageContentSchema),
+  created_at: isoDateTimeSchema,
+  prompt_id: z.string().min(1).optional(),
+  parent_message_id: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type Message = z.infer<typeof messageSchema>;
diff --git a/packages/agent-core-v2/src/agent/contextMemory/types.ts b/packages/agent-core-v2/src/agent/contextMemory/types.ts
index 10a1792b2..ebac0feb3 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/types.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/types.ts
@@ -1,7 +1,6 @@
 import type { ContentPart, Message } from '#/app/llmProtocol/message';
 
 import type { AgentTaskStatus } from '#/agent/task/task';
-import type { CronJobOrigin, CronMissedOrigin, ShellCommandOrigin } from '@moonshot-ai/protocol';
 
 export type SkillSource = 'project' | 'user' | 'extra' | 'builtin';
 
@@ -36,6 +35,14 @@ export interface InjectionOrigin {
   readonly variant: string;
 }
 
+export interface ShellCommandOrigin {
+  readonly kind: 'shell_command';
+  readonly phase: 'input' | 'output';
+  /** Only present on `phase: 'output'` — whether the command failed, so replay
+   *  can colour stderr red only for actual failures (not warnings). */
+  readonly isError?: boolean;
+}
+
 export interface CompactionSummaryOrigin {
   readonly kind: 'compaction_summary';
 }
@@ -52,6 +59,20 @@ export interface TaskOrigin {
   readonly notificationId: string;
 }
 
+export interface CronJobOrigin {
+  readonly kind: 'cron_job';
+  readonly jobId: string;
+  readonly cron: string;
+  readonly recurring: boolean;
+  readonly coalescedCount: number;
+  readonly stale: boolean;
+}
+
+export interface CronMissedOrigin {
+  readonly kind: 'cron_missed';
+  readonly count: number;
+}
+
 export interface HookResultOrigin {
   readonly kind: 'hook_result';
   readonly event: string;
diff --git a/packages/agent-core-v2/src/agent/contextSize/contextSizeService.ts b/packages/agent-core-v2/src/agent/contextSize/contextSizeService.ts
index d512844b1..241842f53 100644
--- a/packages/agent-core-v2/src/agent/contextSize/contextSizeService.ts
+++ b/packages/agent-core-v2/src/agent/contextSize/contextSizeService.ts
@@ -28,14 +28,12 @@ import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { estimateTokensForMessages } from '#/_base/utils/tokens';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
-import { ContextModel } from '#/agent/contextMemory/contextOps';
 import type { ContextMessage } from '#/agent/contextMemory/types';
 import { IEventBus } from '#/app/event/eventBus';
 import { IAgentContextProjectorService } from '#/agent/contextProjector/contextProjector';
 import type { Message } from '#/app/llmProtocol/message';
 import type { TokenUsage } from '#/app/llmProtocol/usage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 
 import { IAgentContextSizeService, type ContextSize, type ContextSizeMeasurement } from './contextSize';
 import { ContextSizeModel, type ContextSizeSnapshot, contextSizeMeasured } from './contextSizeOps';
@@ -50,7 +48,7 @@ export class AgentContextSizeService extends Disposable implements IAgentContext
 
   constructor(
     @IAgentContextMemoryService private readonly context: IAgentContextMemoryService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
     @IAgentContextProjectorService private readonly projector: IAgentContextProjectorService,
   ) {
@@ -60,8 +58,11 @@ export class AgentContextSizeService extends Disposable implements IAgentContext
     // measurement landing re-bases the measured prefix without touching the
     // history. Publishing the pair from one place keeps them mutually
     // consistent (raw >= projected) and in the same caliber as `getStatus()`.
-    this._register(this.wire.subscribe(ContextModel, () => this.publishSizes()));
-    this._register(this.wire.subscribe(ContextSizeModel, () => this.publishSizes()));
+    // The wire exposes no model-change subscription — instead every live
+    // `ContextModel` mutation publishes `context.spliced` (appends included),
+    // and measured-prefix updates land through `measured()` below (the op is
+    // live-only, so replay stays silent).
+    this._register(this.eventBus.subscribe('context.spliced', () => this.publishSizes()));
   }
 
   private publishSizes(): void {
@@ -86,12 +87,17 @@ export class AgentContextSizeService extends Disposable implements IAgentContext
   get(start?: number, end?: number): ContextSize {
     const context = this.context.get();
     const model = this.wire.getModel(ContextSizeModel);
+    // Defensive clamp: the measured prefix can never be longer than the live
+    // context. An op written against a mutated message array once inflated
+    // `model.length` past `context.length`, silently knocking every read off
+    // the measured path onto the per-message estimate branch.
+    const measuredLength = Math.min(model.length, context.length);
     const from = normalizeSliceIndex(start ?? 0, context.length);
     const to = normalizeSliceIndex(end ?? context.length, context.length);
-    const measuredEnd = Math.min(to, model.length);
-    const estimatedStart = Math.max(from, model.length);
+    const measuredEnd = Math.min(to, measuredLength);
+    const estimatedStart = Math.max(from, measuredLength);
     const measured =
-      from === 0 && measuredEnd === model.length
+      from === 0 && measuredEnd === measuredLength
         ? model.tokens
         : measuredSubRange(context, model.snapshots, from, measuredEnd);
     // Before the first measured exchange (e.g. right after a resume — the Op
@@ -139,25 +145,18 @@ export class AgentContextSizeService extends Disposable implements IAgentContext
   }
 
   measured(input: readonly Message[], output: readonly Message[], usage: TokenUsage): void {
-    // The loop opens a `partial` assistant at `step.begin` and settles it with
-    // the response content after the request returns: a trailing partial in
-    // `input` and the output message are the SAME stored message. Strip
-    // trailing partials from both sides so the match and the prefix length
-    // describe the settled storage. Counting the partial separately would
-    // inflate the prefix one past the stored context, knocking the
-    // whole-context read off the exact measured aggregate and onto a
-    // per-message estimate until the next append caught the length up — the
-    // footer gauge then swung between estimate and request caliber at every
-    // turn boundary.
-    const storedInput = stripTrailingPartials(input);
-    const storedContext = stripTrailingPartials(this.context.get());
-    // Only adopt the measurement when `input` still matches the live context.
-    // This rejects stale readings (e.g. the context was spliced, or the request
-    // used overridden messages) so a mismatched measurement cannot poison state.
-    if (!matchesContext(storedInput, storedContext)) return;
-    const length = storedInput.length + output.length;
+    const context = this.context.get();
+    if (!matchesContext(input, context)) return;
+    // The fold of the step's loop events creates the assistant message in the
+    // context BEFORE the exchange finishes (a skeleton at `step.begin`, filled
+    // by `content.part` folds during streaming), and `input` is that same live
+    // array — so it already includes `output` here. The measured prefix is the
+    // whole current context; `input.length + output.length` would count the
+    // folded output twice.
+    const length = context.length;
     const tokens = tokenUsageTotal(usage);
     this.wire.dispatch(contextSizeMeasured({ length, tokens }));
+    this.publishSizes();
   }
 
   latestMeasurement(): ContextSizeMeasurement | undefined {
@@ -206,18 +205,6 @@ function prefixTokens(
   return anchor.tokens + estimateTokensForMessages(context.slice(anchor.storageLength, end));
 }
 
-/**
- * Drop trailing in-progress (`partial`) messages — at most the open step's
- * assistant, which settles into the response message once the request returns.
- */
-function stripTrailingPartials<T extends { readonly partial?: boolean }>(
-  messages: readonly T[],
-): readonly T[] {
-  let end = messages.length;
-  while (end > 0 && messages[end - 1]!.partial === true) end -= 1;
-  return end === messages.length ? messages : messages.slice(0, end);
-}
-
 function matchesContext(input: readonly Message[], context: readonly ContextMessage[]): boolean {
   if (input.length !== context.length) return false;
   for (let index = 0; index < input.length; index += 1) {
diff --git a/packages/agent-core-v2/src/agent/externalHooks/externalHooksService.ts b/packages/agent-core-v2/src/agent/externalHooks/externalHooksService.ts
index 02f843161..5b4ac69da 100644
--- a/packages/agent-core-v2/src/agent/externalHooks/externalHooksService.ts
+++ b/packages/agent-core-v2/src/agent/externalHooks/externalHooksService.ts
@@ -38,7 +38,7 @@ import {
   IAgentPromptService,
   type PromptSubmitContext,
 } from '#/agent/prompt/prompt';
-import type { HookResultEvent, TurnEndedEvent } from '@moonshot-ai/protocol';
+import type { TurnEndedEvent } from '#/agent/loop/turnEvents';
 import { IEventBus } from '#/app/event/eventBus';
 import type { ExecutableToolResult } from '#/tool/toolContract';
 import type { ToolDidExecuteContext, ToolBeforeExecuteContext } from '#/agent/toolExecutor/toolHooks';
@@ -53,6 +53,14 @@ import {
   renderUserPromptHookResult,
 } from './user-prompt';
 
+export interface HookResultEvent {
+  readonly type: 'hook.result';
+  readonly turnId?: number;
+  readonly hookEvent: string;
+  readonly content: string;
+  readonly blocked?: boolean;
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'hook.result': HookResultEvent;
diff --git a/packages/agent-core-v2/src/agent/fullCompaction/compactionOps.ts b/packages/agent-core-v2/src/agent/fullCompaction/compactionOps.ts
index 9de43c597..858ec85c3 100644
--- a/packages/agent-core-v2/src/agent/fullCompaction/compactionOps.ts
+++ b/packages/agent-core-v2/src/agent/fullCompaction/compactionOps.ts
@@ -24,28 +24,42 @@
  * the in-flight worker promise — stays OUT of the Model (live-only service
  * members): none of it can be resumed, and a session never restores mid-flight.
  * A `running` phase stranded by a crash is reset to `idle` by the service's
- * `wire.onRestored` handler (mirroring `goal`'s post-replay normalization).
+ * `wire.hooks.onDidRestore` hook (mirroring `goal`'s post-replay normalization).
  *
  * The `compaction.*` events publish to `IEventBus` (`compaction.started` via the
  * `begin` Op's `toEvent`; the rest directly from the service); they are
  * declared here via interface-merge (`error` is already declared by `mcp`, so
  * it is not re-declared). The `full_compaction.*` record shapes are registered in
  * `PersistedOpMap` (`#/wire/types`, below) because the records still
- * ride the per-agent `wire.jsonl` log read by `wireRecord.restore()` /
- * `getRecords()`. Consumed by the Agent-scope `fullCompactionService`.
+ * ride the per-agent `wire.jsonl` journal restored by `IWireService`.
+ * Consumed by the Agent-scope `fullCompactionService`.
  */
 
 import { z } from 'zod';
 
 import { defineModel } from '#/wire/model';
-import type {
-  CompactionBlockedEvent,
-  CompactionCancelledEvent,
-  CompactionCompletedEvent,
-  CompactionStartedEvent,
-} from '@moonshot-ai/protocol';
 
-import type { CompactionBeginData } from './types';
+import type { CompactionBeginData, CompactionResult } from './types';
+
+export interface CompactionStartedEvent {
+  readonly type: 'compaction.started';
+  readonly trigger: 'manual' | 'auto';
+  readonly instruction?: string;
+}
+
+export interface CompactionBlockedEvent {
+  readonly type: 'compaction.blocked';
+  readonly turnId?: number;
+}
+
+export interface CompactionCancelledEvent {
+  readonly type: 'compaction.cancelled';
+}
+
+export interface CompactionCompletedEvent {
+  readonly type: 'compaction.completed';
+  readonly result: CompactionResult;
+}
 
 export type CompactionPhase = 'idle' | 'running' | 'cancelled' | 'completed';
 
diff --git a/packages/agent-core-v2/src/agent/fullCompaction/fullCompaction.ts b/packages/agent-core-v2/src/agent/fullCompaction/fullCompaction.ts
index 5747de367..5a005ea28 100644
--- a/packages/agent-core-v2/src/agent/fullCompaction/fullCompaction.ts
+++ b/packages/agent-core-v2/src/agent/fullCompaction/fullCompaction.ts
@@ -16,6 +16,7 @@ export interface FullCompactionTask {
   readonly promise: Promise<CompactionResult>;
   readonly trigger: CompactionSource;
   readonly tokenCount: number;
+  readonly traceId?: string;
 }
 
 export interface IAgentFullCompactionService {
diff --git a/packages/agent-core-v2/src/agent/fullCompaction/fullCompactionService.ts b/packages/agent-core-v2/src/agent/fullCompaction/fullCompactionService.ts
index 915974a6a..47b90c242 100644
--- a/packages/agent-core-v2/src/agent/fullCompaction/fullCompactionService.ts
+++ b/packages/agent-core-v2/src/agent/fullCompaction/fullCompactionService.ts
@@ -1,4 +1,4 @@
-import { Disposable, type IDisposable } from "#/_base/di/lifecycle";
+import { Disposable } from "#/_base/di/lifecycle";
 import { InstantiationType } from '#/_base/di/extensions';
 import { IInstantiationService } from '#/_base/di/instantiation';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
@@ -24,6 +24,7 @@ import { contextSizeMeasured } from '#/agent/contextSize/contextSizeOps';
 import { SPINE_FLAG_ID } from '#/agent/spine/flag';
 import { IAgentSpineService } from '#/agent/spine/spine';
 import { IAgentLLMRequesterService, type LLMRequestFinish } from '#/agent/llmRequester/llmRequester';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 import { retryBackoffDelays, sleepForRetry } from '#/_base/utils/retry';
 import { IAgentLoopService, type AfterStepContext, type LoopErrorContext } from '#/agent/loop/loop';
 import { isAbortError } from '#/_base/utils/abort';
@@ -35,7 +36,6 @@ import {
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { stripDynamicToolContext } from '#/agent/toolSelect/dynamicTools';
 import { IAgentToolSelectService } from '#/agent/toolSelect/toolSelect';
-import { IAgentActivityService } from '#/activity/activity';
 import { ISessionTodoService } from '#/session/todo/sessionTodo';
 import { renderTodoList, type TodoItem } from '#/session/todo/todoItem';
 import {
@@ -49,11 +49,10 @@ import type { Tool } from '#/app/llmProtocol/tool';
 import { inputTotal, type TokenUsage } from '#/app/llmProtocol/usage';
 import { IEventBus } from '#/app/event/eventBus';
 import { IFlagService } from '#/app/flag/flag';
-import type { CompactionFinishedEvent } from '#/app/telemetry/events';
+import type { CompactionFailedEvent, CompactionFinishedEvent } from '#/app/telemetry/events';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { ErrorCodes, Error2, isCodedError, isError2, toKimiErrorPayload, unwrapErrorCause } from "#/errors";
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import compactionInstructionTemplate from './compaction-instruction.md?raw';
 import {
   IAgentFullCompactionService,
@@ -102,14 +101,15 @@ type CompactionTelemetryProperties = Pick<
 type CompactionCancelReason = 'abort' | 'history_changed';
 
 interface ActiveCompaction extends FullCompactionTask {
+  trace?: LLMRequestTrace;
   blockedByTurn: boolean;
-  bgRegistration?: IDisposable;
   cancelReason?: CompactionCancelReason;
 }
 
 interface CompactionAttemptResult {
   readonly summary: string;
   readonly usage: TokenUsage | null;
+  readonly traceId?: string;
 }
 
 class CompactionTruncatedError extends Error {
@@ -163,9 +163,8 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
     @IInstantiationService private readonly instantiation: IInstantiationService,
     @ISessionTodoService private readonly todo: ISessionTodoService,
     @ITelemetryService private readonly telemetry: ITelemetryService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
-    @IAgentActivityService private readonly activity: IAgentActivityService,
     @ILogService private readonly log: ILogService,
     @IFlagService private readonly flags: IFlagService,
     @IAgentLoopService private readonly loopService: IAgentLoopService,
@@ -173,7 +172,12 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
   ) {
     super();
     this.strategy = new RuntimeCompactionStrategy(() => this.resolveModelContextWithEffectiveMax());
-    this._register(this.wire.onRestored(() => this.normalizeAfterReplay()));
+    this._register(
+      this.wire.hooks.onDidRestore.register('full-compaction', async (_ctx, next) => {
+        this.normalizeAfterReplay();
+        await next();
+      }),
+    );
     this._register(
       this.eventBus.subscribe('turn.started', () => this.resetForTurn()),
     );
@@ -317,7 +321,7 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
     if (history.length === 0) {
       throw new Error2(ErrorCodes.COMPACTION_UNABLE, 'No messages to compact in current history.');
     }
-    if (source === 'manual' && this.activity.lane() !== 'idle') {
+    if (source === 'manual' && this.loopService.status().state !== 'idle') {
       throw new Error2(
         ErrorCodes.COMPACTION_UNABLE,
         'Cannot compact while a turn is active. Wait for it to finish, then retry.',
@@ -347,20 +351,30 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
         promise,
         trigger,
         tokenCount,
+        get traceId() {
+          return this.trace?.traceId;
+        },
         blockedByTurn: false,
-        bgRegistration: this.activity.registerBackground('compaction', abortController),
       },
       resolve,
       reject,
     };
   }
 
+  /** Scope disposal is the fallback abort path; normal agent teardown aborts
+   *  and awaits the exposed task before disposing the scope. */
+  override dispose(): void {
+    if (this._compacting !== null && !this._compacting.abortController.signal.aborted) {
+      this._compacting.abortController.abort();
+    }
+    super.dispose();
+  }
+
   private cancelActive(active: ActiveCompaction, reason: CompactionCancelReason = 'abort'): boolean {
     if (this._compacting !== active) return false;
     active.cancelReason ??= reason;
     this.wire.dispatch(fullCompactionCancel({}));
     this._compacting = null;
-    active.bgRegistration?.dispose();
     if (!active.abortController.signal.aborted) {
       active.abortController.abort();
     }
@@ -372,7 +386,6 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
     if (this._compacting !== active) return false;
     this.wire.dispatch(fullCompactionComplete({}));
     this._compacting = null;
-    active.bgRegistration?.dispose();
     return true;
   }
 
@@ -640,17 +653,21 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
         const estimatedCompactionRequestTokens = this.estimateRequestTokens(messages);
 
         try {
-          attempt = collectSummary(
-            await this.llmRequester.request(
-              {
-                messages,
-                maxOutputSize: compactionMaxOutputSize,
-                source: { type: 'operation', requestKind: 'full_compaction' },
+          const request = this.llmRequester.start(
+            {
+              messages,
+              maxOutputSize: compactionMaxOutputSize,
+              source: {
+                type: 'operation',
+                requestKind: 'full_compaction',
+                logFields: { droppedCount },
               },
-              undefined,
-              signal,
-            ),
+            },
+            undefined,
+            signal,
           );
+          active.trace = request.trace;
+          attempt = collectSummary(await request.result);
           break;
         } catch (error) {
           const isContextOverflow = this.shouldRecoverFromContextOverflow(
@@ -736,6 +753,7 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
         retry_count: retryCount,
         round: 1,
         thinking_effort: thinkingEffort,
+        trace_id: attempt.traceId,
         ...usageTelemetry(attempt.usage),
       };
       this.telemetry.track2('compaction_finished', properties);
@@ -747,19 +765,21 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
         // own failure instead of letting them vanish silently. User aborts
         // stay untracked, as before.
         if (active.cancelReason === 'history_changed') {
-          this.telemetry.track2('compaction_failed', {
+          const properties: CompactionFailedEvent = {
             source: data.source,
             tokens_before: tokensBefore,
             duration_ms: Date.now() - startedAt,
             round: 1,
             retry_count: retryCount,
-            thinking_effort: this.profile.data().thinkingLevel,
+            thinking_effort: thinkingEffort,
             error_type: error instanceof Error ? error.name : 'Unknown',
-          });
+            trace_id: active.traceId,
+          };
+          this.telemetry.track2('compaction_failed', properties);
         }
         throw error;
       }
-      this.telemetry.track2('compaction_failed', {
+      const properties: CompactionFailedEvent = {
         source: data.source,
         tokens_before: tokensBefore,
         duration_ms: Date.now() - startedAt,
@@ -767,7 +787,9 @@ export class AgentFullCompactionService extends Disposable implements IAgentFull
         retry_count: retryCount,
         thinking_effort: thinkingEffort,
         error_type: error instanceof Error ? error.name : 'Unknown',
-      });
+        trace_id: findAPIStatusError(error)?.traceId ?? active.traceId,
+      };
+      this.telemetry.track2('compaction_failed', properties);
       if (
         isError2(error) &&
         (error.code === ErrorCodes.AUTH_LOGIN_REQUIRED ||
@@ -912,7 +934,7 @@ function collectSummary(finish: LLMRequestFinish): CompactionAttemptResult {
     );
   }
 
-  return { summary, usage: finish.usage };
+  return { summary, usage: finish.usage, traceId: finish.traceId };
 }
 
 function historySafeToCompact(
diff --git a/packages/agent-core-v2/src/agent/fullCompaction/types.ts b/packages/agent-core-v2/src/agent/fullCompaction/types.ts
index de13049c9..2d7f38f70 100644
--- a/packages/agent-core-v2/src/agent/fullCompaction/types.ts
+++ b/packages/agent-core-v2/src/agent/fullCompaction/types.ts
@@ -1,13 +1,32 @@
-import type { CompactionResult as ProtocolCompactionResult } from '@moonshot-ai/protocol';
-
-export interface CompactionResult extends ProtocolCompactionResult {
+export interface CompactionResult {
   summary: string;
   contextSummary?: string;
   compactedCount: number;
   tokensBefore: number;
   tokensAfter: number;
+  /**
+   * Number of real user messages kept verbatim ahead of the summary in the
+   * post-compaction live context. Recorded so the wire-transcript reducer can
+   * reproduce the live folded length without re-deriving it from the full
+   * transcript (which still holds the untruncated originals of messages the
+   * live context may have truncated, so the two would otherwise diverge).
+   * Optional for backward compatibility with older wire records.
+   */
   keptUserMessageCount?: number;
+  /**
+   * Of `keptUserMessageCount`, how many messages form the head segment (the
+   * oldest user input kept when the pool overflowed the budget). Present iff
+   * the selection split into head + tail, in which case the live context also
+   * holds one elision-marker message between the segments. Optional for
+   * backward compatibility with older wire records.
+   */
   keptHeadUserMessageCount?: number;
+  /**
+   * Oldest messages trimmed from the summarizer input when the compaction
+   * request overflowed the model window; not covered by the produced summary.
+   * Mirrors agent-core's `CompactionResult.droppedCount`; optional for backward
+   * compatibility.
+   */
   droppedCount?: number;
 }
 
diff --git a/packages/agent-core-v2/src/agent/goal/errors.ts b/packages/agent-core-v2/src/agent/goal/errors.ts
index 5f38075c9..ff59b94e9 100644
--- a/packages/agent-core-v2/src/agent/goal/errors.ts
+++ b/packages/agent-core-v2/src/agent/goal/errors.ts
@@ -13,6 +13,7 @@ export const GoalErrors = {
     GOAL_STATUS_INVALID: 'goal.status_invalid',
     GOAL_METADATA_RESERVED: 'goal.metadata_reserved',
     GOAL_NOT_RESUMABLE: 'goal.not_resumable',
+    GOAL_UNSUPPORTED_AGENT: 'goal.unsupported_agent',
   },
   info: {
     'goal.already_exists': {
@@ -43,7 +44,7 @@ export const GoalErrors = {
       title: 'Invalid goal status transition',
       retryable: false,
       public: true,
-      action: 'Use a status allowed for this actor (complete, blocked, or impossible).',
+      action: 'Only an active goal can be paused; resume a blocked goal with `/goal resume`.',
     },
     'goal.metadata_reserved': {
       title: 'Goal metadata is reserved',
@@ -55,7 +56,13 @@ export const GoalErrors = {
       title: 'Goal is not resumable',
       retryable: false,
       public: true,
-      action: 'Only paused goals can be resumed.',
+      action: 'Only paused or blocked goals can be resumed.',
+    },
+    'goal.unsupported_agent': {
+      title: 'Goals are unavailable for subagents',
+      retryable: false,
+      public: true,
+      action: 'Run goal lifecycle commands on the main agent.',
     },
   },
 } as const satisfies ErrorDomain;
diff --git a/packages/agent-core-v2/src/agent/goal/goal.ts b/packages/agent-core-v2/src/agent/goal/goal.ts
index 6c0ece352..1d1702c63 100644
--- a/packages/agent-core-v2/src/agent/goal/goal.ts
+++ b/packages/agent-core-v2/src/agent/goal/goal.ts
@@ -1,8 +1,9 @@
 /**
- * `goal` domain (L4) — per-agent goal lifecycle contract.
+ * `goal` domain (L4) — main-agent goal lifecycle contract.
  *
  * Defines the commands and snapshots used to create, inspect, update, and clear
- * the durable goal state. Bound at Agent scope.
+ * the durable goal state. Bound at Agent scope; subagent callers are rejected
+ * with `goal.unsupported_agent`.
  */
 import { createDecorator } from "#/_base/di/instantiation";
 import type {
@@ -18,6 +19,7 @@ export interface GoalReasonInput {
 }
 
 export interface ResumeGoalInput extends GoalReasonInput {
+  readonly continueIfPaused?: boolean;
   readonly continueIfBlocked?: boolean;
 }
 
@@ -25,6 +27,7 @@ export interface IAgentGoalService {
   readonly _serviceBrand: undefined;
 
   getGoal(): GoalToolResult;
+  isGoalToolTarget(turnId: number, goalId: string): boolean;
   createGoal(input: CreateGoalInput, actor?: GoalActor): Promise<GoalSnapshot>;
   pauseGoal(input?: GoalReasonInput, actor?: GoalActor): Promise<GoalSnapshot>;
   resumeGoal(input?: ResumeGoalInput, actor?: GoalActor): Promise<GoalSnapshot>;
diff --git a/packages/agent-core-v2/src/agent/goal/goalDeadlineScheduler.ts b/packages/agent-core-v2/src/agent/goal/goalDeadlineScheduler.ts
new file mode 100644
index 000000000..4591c2b1a
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/goal/goalDeadlineScheduler.ts
@@ -0,0 +1,19 @@
+/**
+ * `goal` domain (L4) — wall-clock deadline scheduling contract.
+ *
+ * Defines the App-scoped `IGoalDeadlineScheduler` used by per-agent goal
+ * services to measure active time and arm hard wall-clock budget deadlines.
+ */
+
+import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
+import type { IDisposable } from '#/_base/di/lifecycle';
+
+export interface IGoalDeadlineScheduler {
+  readonly _serviceBrand: undefined;
+
+  now(): number;
+  schedule(delayMs: number, callback: () => void): IDisposable;
+}
+
+export const IGoalDeadlineScheduler: ServiceIdentifier<IGoalDeadlineScheduler> =
+  createDecorator<IGoalDeadlineScheduler>('goalDeadlineScheduler');
diff --git a/packages/agent-core-v2/src/agent/goal/goalDeadlineSchedulerService.ts b/packages/agent-core-v2/src/agent/goal/goalDeadlineSchedulerService.ts
new file mode 100644
index 000000000..156fc26b7
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/goal/goalDeadlineSchedulerService.ts
@@ -0,0 +1,40 @@
+/**
+ * `goal` domain (L4) — `IGoalDeadlineScheduler` implementation.
+ *
+ * Measures monotonic elapsed time and schedules disposable one-shot deadlines
+ * with the host timer API. Bound at App scope.
+ */
+
+import { InstantiationType } from '#/_base/di/extensions';
+import { toDisposable, type IDisposable } from '#/_base/di/lifecycle';
+import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
+
+import { IGoalDeadlineScheduler } from './goalDeadlineScheduler';
+
+export class GoalDeadlineSchedulerService implements IGoalDeadlineScheduler {
+  declare readonly _serviceBrand: undefined;
+
+  now(): number {
+    return Number(process.hrtime.bigint() / 1_000_000n);
+  }
+
+  schedule(delayMs: number, callback: () => void): IDisposable {
+    let timeout: ReturnType<typeof setTimeout> | undefined = setTimeout(() => {
+      timeout = undefined;
+      callback();
+    }, Math.max(0, delayMs));
+    timeout.unref?.();
+    return toDisposable(() => {
+      if (timeout !== undefined) clearTimeout(timeout);
+      timeout = undefined;
+    });
+  }
+}
+
+registerScopedService(
+  LifecycleScope.App,
+  IGoalDeadlineScheduler,
+  GoalDeadlineSchedulerService,
+  InstantiationType.Delayed,
+  'goal',
+);
diff --git a/packages/agent-core-v2/src/agent/goal/goalOps.ts b/packages/agent-core-v2/src/agent/goal/goalOps.ts
index 3fbf3f286..953488d6d 100644
--- a/packages/agent-core-v2/src/agent/goal/goalOps.ts
+++ b/packages/agent-core-v2/src/agent/goal/goalOps.ts
@@ -5,17 +5,24 @@
  *
  * Declares the current goal as `GoalState | null` (initial `null`); `GoalState`
  * holds the persistent, replayable fields — identity, objective, status,
- * `turnsUsed` / `tokensUsed`, the accumulated `wallClockMs`, `budgetLimits`,
- * and `terminalReason`. The non-deterministic bits stay OUT of `apply`:
- * `goalId` is minted at the call site and carried in the `goal.create` payload;
- * the `wallClockMs` `Date.now()` accumulation is computed by the live service
- * when leaving `active` and carried in the `goal.update` payload; and
- * `wallClockResumedAt` is a live-only service field (never persisted, reset on
- * replay). Each `apply` returns the same reference when nothing changes so the
- * wire's reference-equality gate stays quiet. The `goal.updated` fact is
+ * `turnsUsed` / `tokensUsed`, the accumulated `wallClockMs`, the current
+ * active interval's epoch-ms `wallClockResumedAt`, `budgetLimits`, and
+ * `terminalReason`. The persistence contract charges an active interval from
+ * its persisted create/resume anchor through the first recovery clock read,
+ * then folds that interval into `wallClockMs` while recovery pauses the goal.
+ * This intentionally includes unobservable crash downtime: a monotonic clock
+ * cannot span processes, while learning the crash instant would require
+ * periodic durable writes. System-clock rollback is clamped to zero. The
+ * 1.4 -> 1.5 compatibility transform (also applied before sealing
+ * envelope-less logs) derives missing create/resume/checkpoint anchors from
+ * those records' existing epoch-ms `time` stamps. The
+ * non-deterministic values stay OUT of `apply`: `goalId` and the wall-clock
+ * anchor/totals are computed by the live service and carried in Op payloads.
+ * Each `apply` returns the same reference when nothing changes so the wire's
+ * reference-equality gate stays quiet. The `goal.updated` fact is
  * published live to `IEventBus` by the service (declared here via
- * interface-merge); `wire.replay` rebuilds the Model silently and the
- * service's `wire.onRestored`
+ * interface-merge); `wire.restore` rebuilds the Model silently and the
+ * service's `wire.hooks.onDidRestore`
  * forces a replayed `active` goal back to `paused`. Consumed by the Agent-scope
  * `goalService`.
  */
@@ -25,7 +32,6 @@ import { z } from 'zod';
 import { defineModel } from '#/wire/model';
 
 import type {
-  GoalActor,
   GoalBudgetLimits,
   GoalChange,
   GoalSnapshot,
@@ -40,6 +46,7 @@ export interface GoalState {
   readonly turnsUsed: number;
   readonly tokensUsed: number;
   readonly wallClockMs: number;
+  readonly wallClockResumedAt?: number;
   readonly budgetLimits: GoalBudgetLimits;
   readonly terminalReason?: string;
 }
@@ -48,6 +55,18 @@ export type GoalModelState = GoalState | null;
 
 export const GoalModel = defineModel<GoalModelState>('goal', () => null);
 
+const GoalStatusSchema = z.enum(['active', 'paused', 'blocked', 'complete']);
+
+const GoalActorSchema = z.enum(['user', 'model', 'runtime', 'system']);
+
+const GoalBudgetLimitsSchema = z
+  .object({
+    tokenBudget: z.number().finite().nonnegative().optional(),
+    turnBudget: z.number().finite().nonnegative().optional(),
+    wallClockBudgetMs: z.number().finite().nonnegative().optional(),
+  })
+  .strict();
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'goal.updated': {
@@ -67,11 +86,17 @@ declare module '#/wire/types' {
 }
 
 export const createGoal = GoalModel.defineOp('goal.create', {
-  schema: z.object({
-    goalId: z.string(),
-    objective: z.string(),
-    completionCriterion: z.string().optional(),
-  }),
+  schema: z
+    .object({
+      goalId: z.string(),
+      objective: z.string(),
+      completionCriterion: z.string().optional(),
+      wallClockResumedAt: z.number().finite().nonnegative().optional(),
+      status: GoalStatusSchema.optional(),
+      actor: GoalActorSchema.optional(),
+      budgetLimits: GoalBudgetLimitsSchema.optional(),
+    })
+    .strip(),
   apply: (_s, p) => ({
     goalId: p.goalId,
     objective: p.objective,
@@ -80,20 +105,25 @@ export const createGoal = GoalModel.defineOp('goal.create', {
     turnsUsed: 0,
     tokensUsed: 0,
     wallClockMs: 0,
+    wallClockResumedAt: p.wallClockResumedAt,
     budgetLimits: {},
   }),
 });
 
 export const updateGoal = GoalModel.defineOp('goal.update', {
-  schema: z.object({
-    status: z.custom<GoalStatus>().optional(),
-    reason: z.string().optional(),
-    turnsUsed: z.number().optional(),
-    tokensUsed: z.number().optional(),
-    wallClockMs: z.number().optional(),
-    budgetLimits: z.custom<GoalBudgetLimits>().optional(),
-    actor: z.custom<GoalActor>().optional(),
-  }),
+  schema: z
+    .object({
+      goalId: z.string().optional(),
+      status: GoalStatusSchema.optional(),
+      reason: z.string().optional(),
+      turnsUsed: z.number().finite().nonnegative().optional(),
+      tokensUsed: z.number().finite().nonnegative().optional(),
+      wallClockMs: z.number().finite().nonnegative().optional(),
+      wallClockResumedAt: z.number().finite().nonnegative().optional(),
+      budgetLimits: GoalBudgetLimitsSchema.optional(),
+      actor: GoalActorSchema.optional(),
+    })
+    .strip(),
   apply: (s, p) => {
     if (s === null) return null;
     let next: GoalState | undefined;
@@ -102,6 +132,8 @@ export const updateGoal = GoalModel.defineOp('goal.update', {
         ...(next ?? s),
         status: p.status,
         terminalReason: p.status === 'active' ? undefined : p.reason,
+        wallClockResumedAt:
+          p.status === 'active' ? p.wallClockResumedAt : undefined,
       };
     }
     if (p.turnsUsed !== undefined && p.turnsUsed !== s.turnsUsed) {
@@ -113,6 +145,13 @@ export const updateGoal = GoalModel.defineOp('goal.update', {
     if (p.wallClockMs !== undefined && p.wallClockMs !== s.wallClockMs) {
       next = { ...(next ?? s), wallClockMs: p.wallClockMs };
     }
+    if (
+      p.wallClockResumedAt !== undefined &&
+      (p.status ?? s.status) === 'active' &&
+      p.wallClockResumedAt !== s.wallClockResumedAt
+    ) {
+      next = { ...(next ?? s), wallClockResumedAt: p.wallClockResumedAt };
+    }
     if (p.budgetLimits !== undefined && p.budgetLimits !== s.budgetLimits) {
       next = { ...(next ?? s), budgetLimits: p.budgetLimits };
     }
diff --git a/packages/agent-core-v2/src/agent/goal/goalService.ts b/packages/agent-core-v2/src/agent/goal/goalService.ts
index a198e0c19..2a686a817 100644
--- a/packages/agent-core-v2/src/agent/goal/goalService.ts
+++ b/packages/agent-core-v2/src/agent/goal/goalService.ts
@@ -1,32 +1,39 @@
 /**
- * `goal` domain (L4) - `IAgentGoalService` implementation.
+ * `goal` domain (L4) — `IAgentGoalService` implementation.
  *
- * Owns the per-agent goal lifecycle; persists the goal in the `wire`
+ * Owns the main-agent goal lifecycle; persists the goal in the `wire`
  * `GoalModel` (`GoalState | null`) through the `goal.create` / `goal.update` /
  * `goal.clear` Ops (`wire.dispatch`), reads it through `wire.getModel`,
  * publishes `goal.updated` live to `IEventBus`, and forces a replayed `active`
- * goal back to `paused` via `wire.onRestored`. The accumulated `wallClockMs`
- * lives in the Model (set from each Op payload, never by `Date.now()` inside
- * `apply`); the `wallClockResumedAt` cursor is a live-only field, reset on
- * replay and (re)started on the live path. A `forked` wire Op clears the Model
+ * goal back to `paused` via `wire.hooks.onDidRestore`. The accumulated
+ * `wallClockMs` lives in the Model (set from each Op payload, never by
+ * `Date.now()` inside `apply`); the active interval's epoch-ms
+ * `wallClockResumedAt` anchor is
+ * persisted at create/resume boundaries so recovery can settle crash-spanning
+ * elapsed time without periodic writes. A `forked` wire Op clears the Model
  * at a fork boundary; the `goal.*` payload shapes are registered in
  * `PersistedOpMap` (`#/wire/types`) inside `goalOps` because they still ride
- * the shared wire log read by `getRecords()` and replayed into the Model.
+ * the Agent wire journal restored into the Model.
  * Injects reminders through
  * `contextInjector`, drives continuation turns by enqueueing `newTurn`
  * `StepRequest`s onto `loop` (the continuation message materializes when the
  * loop pops it), accounts live
- * turn usage through `usage`, writes system reminders through
- * `systemReminder`, registers model tools through `toolRegistry`, and reports
- * telemetry through `telemetry`. Bound at Agent scope.
+ * turn usage through `usage`, observes terminal goal tool results through
+ * `toolExecutor`, writes system reminders through `systemReminder`, reports
+ * telemetry through `telemetry`, and checks main-agent eligibility through
+ * `scopeContext`. Measures time and arms hard deadlines through `goal`'s
+ * App-scoped deadline scheduler. Bound at Agent scope.
+ * Subagent instances reject every goal command and do not install goal
+ * injection, accounting, budget, or continuation hooks.
  */
 
 import { randomUUID } from 'node:crypto';
 
-import type { TurnEndedEvent } from '@moonshot-ai/protocol';
-import { Disposable } from '#/_base/di/lifecycle';
+import type { TurnEndedEvent, TurnStartedEvent } from '#/agent/loop/turnEvents';
+import { Disposable, MutableDisposable, type IDisposable } from '#/_base/di/lifecycle';
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
+import { abortError } from '#/_base/utils/abort';
 import { isPlainRecord } from '#/_base/utils/canonical-args';
 import { IAgentContextInjectorService } from '#/agent/contextInjector/contextInjector';
 import type { ContextMessage, PromptOrigin } from '#/agent/contextMemory/types';
@@ -40,8 +47,10 @@ import {
 import { LOOP_CONTROL_SECTION, type LoopControl } from '#/agent/loop/configSection';
 import { ContinuationStepRequest, MessageStepRequest } from '#/agent/loop/stepRequest';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
+import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import type { ExecutableToolResult } from '#/tool/toolContract';
 import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
+import type { ToolBeforeExecuteContext } from '#/agent/toolExecutor/toolHooks';
 import { IAgentUsageService, type UsageRecordedContext } from '#/agent/usage/usage';
 import type { GoalBudgetProperties } from '#/app/telemetry/events';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
@@ -52,12 +61,12 @@ import {
   toKimiErrorPayload,
   type KimiErrorPayload,
 } from '#/errors';
-import { IAgentWireService } from '#/wire/tokens';
-import { defineDerivedModel } from '#/wire/model';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
+import { defineModel } from '#/wire/model';
 import { IEventBus } from '#/app/event/eventBus';
 
 import { IAgentGoalService, type GoalReasonInput, type ResumeGoalInput } from './goal';
+import { IGoalDeadlineScheduler } from './goalDeadlineScheduler';
 import { clearGoal, createGoal, GoalModel, updateGoal, type GoalState } from './goalOps';
 import type {
   CreateGoalInput,
@@ -115,6 +124,8 @@ const GOAL_BUDGET_STOP_REMINDER = [
 
 const GOAL_BUDGET_TOOLS_REJECTED_MESSAGE =
   'Goal budget exhausted; tool calls are rejected. Write your final message.';
+const GOAL_STALE_TOOL_RESULT =
+  'Goal changed since this turn started; ignored stale goal tool call.';
 
 const GOAL_CONTINUATION_PROMPT = [
   'Continue working toward the active goal.',
@@ -154,23 +165,26 @@ interface GoalForkNoticeState {
 
 interface PendingContinuation {
   readonly receipt: EnqueueReceipt;
+  readonly goalId: string;
   turnId?: number;
 }
 
-const GoalForkNoticeModel = defineDerivedModel<GoalForkNoticeState>(
+const GoalForkNoticeModel = defineModel<GoalForkNoticeState>(
   'goalForkNotice',
   () => ({ goalPresent: false, reminderPending: false }),
   {
-    'goal.create': (state) => ({ ...state, goalPresent: true }),
-    'goal.clear': (state) => ({ ...state, goalPresent: false }),
-    forked: (state) => ({
-      goalPresent: false,
-      reminderPending: state.goalPresent || state.reminderPending,
-    }),
-    'context.append_message': (state, payload: { message?: ContextMessage }) =>
-      state.reminderPending && isGoalForkClearedReminder(payload.message)
-        ? { ...state, reminderPending: false }
-        : state,
+    reducers: {
+      'goal.create': (state) => ({ ...state, goalPresent: true }),
+      'goal.clear': (state) => ({ ...state, goalPresent: false }),
+      forked: (state) => ({
+        goalPresent: false,
+        reminderPending: state.goalPresent || state.reminderPending,
+      }),
+      'context.append_message': (state, payload: { message?: ContextMessage }) =>
+        state.reminderPending && isGoalForkClearedReminder(payload.message)
+          ? { ...state, reminderPending: false }
+          : state,
+    },
   },
 );
 
@@ -181,21 +195,30 @@ function isGoalForkClearedReminder(message: ContextMessage | undefined): boolean
   );
 }
 
+function isGoalContinuationOrigin(origin: TurnStartedEvent['origin']): boolean {
+  return origin.kind === 'system_trigger' && origin.name === 'goal_continuation';
+}
+
 export class AgentGoalService extends Disposable implements IAgentGoalService {
   declare readonly _serviceBrand: undefined;
 
-  private wallClockResumedAt?: number;
   private liveTurnId?: number;
-  private readonly goalDrivenTurns = new Set<number>();
+  private readonly goalDrivenTurns = new Map<number, string>();
   private readonly countedGoalTurns = new Set<number>();
   private readonly goalStarterTurns = new Set<number>();
-  private readonly goalOutcomeToolResultTurns = new Set<number>();
+  private readonly goalOutcomeToolResultTurns = new Map<number, string>();
   private readonly goalOutcomeContinuationTurns = new Set<number>();
   private readonly budgetGraceTurns = new Set<number>();
+  private readonly pendingContinuationGoals = new Map<number, string>();
+  private readonly goalTurnTargets = new Map<number, string>();
+  private readonly exhaustedTurnBudgetGoals = new Map<number, string>();
+  private readonly wallClockDeadline = this._register(new MutableDisposable<IDisposable>());
+  private liveWallClockStartedAt?: number;
   private pendingContinuation?: PendingContinuation;
+  private resumeContinuation?: { readonly turnId: number; readonly goalId: string };
 
   constructor(
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
     @IAgentSystemReminderService private readonly reminders: IAgentSystemReminderService,
     @ITelemetryService private readonly telemetry: ITelemetryService,
@@ -204,8 +227,11 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     @IAgentToolExecutorService toolExecutor: IAgentToolExecutorService,
     @IAgentUsageService usageService: IAgentUsageService,
     @IConfigService private readonly config: IConfigService,
+    @IGoalDeadlineScheduler private readonly deadlineScheduler: IGoalDeadlineScheduler,
+    @IAgentScopeContext private readonly agentContext: IAgentScopeContext,
   ) {
     super();
+    if (!this.isSupportedAgent) return;
     this._register(
       new GoalInjection(
         {
@@ -214,10 +240,16 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
         dynamicInjector,
       ),
     );
-    this._register(this.wire.attach(GoalForkNoticeModel));
-    this._register(this.wire.onRestored(() => this.normalizeAfterReplay()));
     this._register(
-      this.eventBus.subscribe('turn.started', (e) => this.handleTurnLaunched(e.turnId)),
+      this.wire.hooks.onDidRestore.register('goal', async (_ctx, next) => {
+        this.normalizeAfterReplay();
+        await next();
+      }),
+    );
+    this._register(
+      this.eventBus.subscribe('turn.started', (e) => {
+        this.handleTurnLaunched(e.turnId, e.origin);
+      }),
     );
     this._register(
       usageService.onDidRecord((ctx) => this.handleUsageRecorded(ctx)),
@@ -236,6 +268,10 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     );
     this._register(
       toolExecutor.hooks.onBeforeExecuteTool.register('goal-budget-reject', async (ctx, next) => {
+        if (this.isStaleGoalToolCall(ctx)) {
+          ctx.decision = { syntheticResult: { output: GOAL_STALE_TOOL_RESULT } };
+          return;
+        }
         if (this.budgetGraceTurns.has(ctx.turnId)) {
           ctx.decision = {
             syntheticResult: { output: GOAL_BUDGET_TOOLS_REJECTED_MESSAGE },
@@ -247,49 +283,71 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     );
     this._register(
       toolExecutor.hooks.onDidExecuteTool.register('goal-outcome-tool-result', async (ctx, next) => {
-        if (isTerminalUpdateGoalResult(ctx.toolCall.name, ctx.args, ctx.result)) {
-          this.goalOutcomeToolResultTurns.add(ctx.turnId);
+        const goalId = this.goalTurnTarget(ctx.turnId);
+        if (
+          goalId !== undefined &&
+          isTerminalUpdateGoalResult(ctx.toolCall.name, ctx.args, ctx.result)
+        ) {
+          this.goalOutcomeToolResultTurns.set(ctx.turnId, goalId);
         }
         await next();
       }),
     );
     this._register(
       this.eventBus.subscribe('turn.ended', (e) => {
+        const goalId = this.goalTurnTarget(e.turnId);
         void this.handleTurnEnded(e.turnId, { reason: e.reason, error: e.error }).catch((error) =>
-          this.settleGoalAfterContinuationFailure(error),
+          this.settleGoalAfterContinuationFailure(error, goalId),
         );
       }),
     );
   }
 
+  private get isSupportedAgent(): boolean {
+    return this.agentContext.agentId === 'main';
+  }
+
+  private assertSupportedAgent(): void {
+    if (this.isSupportedAgent) return;
+    throw new Error2(
+      ErrorCodes.GOAL_UNSUPPORTED_AGENT,
+      'Goals are only supported by the main agent',
+      { details: { agentId: this.agentContext.agentId } },
+    );
+  }
+
   private get goalState(): GoalState | null {
     return this.wire.getModel(GoalModel) as GoalState | null;
   }
 
   getGoal(): GoalToolResult {
+    this.assertSupportedAgent();
     const state = this.goalState;
     return { goal: state === null ? null : this.toSnapshot(state) };
   }
 
-  getActiveGoal(): GoalSnapshot | null {
-    const state = this.goalState;
-    if (state === null || state.status !== 'active') return null;
-    return this.toSnapshot(state);
+  isGoalToolTarget(turnId: number, goalId: string): boolean {
+    this.assertSupportedAgent();
+    return this.goalTurnTargets.get(turnId) === goalId;
   }
 
   async createGoal(input: CreateGoalInput, actor: GoalActor = 'user'): Promise<GoalSnapshot> {
+    this.assertSupportedAgent();
     const objective = this.validateObjective(input.objective);
     this.prepareForGoalCreation(input.replace === true);
+    const wallClockResumedAt = Date.now();
     this.wire.dispatch(
       createGoal({
         goalId: randomUUID(),
         objective,
         completionCriterion: normalizeCompletionCriterion(input.completionCriterion),
+        wallClockResumedAt,
       }),
     );
-    this.wallClockResumedAt = Date.now();
-    this.adoptStarterTurn();
+    this.liveWallClockStartedAt = this.deadlineScheduler.now();
+    this.adoptStarterTurn(actor);
     const state = this.requireState();
+    this.refreshWallClockDeadline(state);
     this.emitGoalUpdated(this.toSnapshot(state));
     this.telemetry.track2('goal_created', { actor, replace: input.replace === true });
     return this.toSnapshot(state);
@@ -321,6 +379,7 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
   }
 
   async pauseGoal(input: GoalReasonInput = {}, actor: GoalActor = 'user'): Promise<GoalSnapshot> {
+    this.assertSupportedAgent();
     const state = this.requireState();
     if (state.status === 'paused') return this.toSnapshot(state);
     if (state.status !== 'active') {
@@ -336,12 +395,14 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     input: GoalReasonInput = {},
     actor: GoalActor = 'runtime',
   ): Promise<GoalSnapshot | null> {
+    this.assertSupportedAgent();
     const state = this.goalState;
     if (state === null || state.status !== 'active') return null;
     return this.applyLifecycle(state, 'paused', input.reason, actor);
   }
 
   async resumeGoal(input: ResumeGoalInput = {}, actor: GoalActor = 'user'): Promise<GoalSnapshot> {
+    this.assertSupportedAgent();
     const state = this.requireState();
     if (state.status === 'active') return this.toSnapshot(state);
     if (state.status !== 'paused' && state.status !== 'blocked') {
@@ -350,19 +411,24 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
         `Cannot resume a goal in status "${state.status}"`,
       );
     }
+    const continuePaused =
+      actor === 'user' && state.status === 'paused' && input.continueIfPaused === true;
     const shouldContinue =
-      state.status === 'blocked' && input.continueIfBlocked === true && actor === 'user';
+      continuePaused ||
+      (actor === 'user' && state.status === 'blocked' && input.continueIfBlocked === true);
     const snapshot = this.applyLifecycle(state, 'active', input.reason, actor);
     if (!shouldContinue) return snapshot;
     const budgetBlocked = this.blockIfBudgetReached(this.requireState());
     if (budgetBlocked !== null) return budgetBlocked;
     if (this.canLaunchContinuation()) {
       try {
-        this.launchContinuationTurn();
+        this.launchContinuationTurn(state.goalId);
       } catch (error) {
-        await this.settleGoalAfterContinuationFailure(error);
+        await this.settleGoalAfterContinuationFailure(error, state.goalId);
         throw error;
       }
+    } else if (continuePaused && this.liveTurnId !== undefined) {
+      this.resumeContinuation = { turnId: this.liveTurnId, goalId: state.goalId };
     }
     return snapshot;
   }
@@ -371,6 +437,7 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     input: { readonly budgetLimits: GoalBudgetLimits },
     actor: GoalActor = 'user',
   ): Promise<GoalSnapshot> {
+    this.assertSupportedAgent();
     const state = this.requireState();
     const budgetLimits = { ...state.budgetLimits, ...input.budgetLimits };
     this.wire.dispatch(updateGoal({ budgetLimits }));
@@ -380,12 +447,19 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
       actor,
       ...budgetTelemetryProperties(input.budgetLimits),
     });
-    return this.blockIfBudgetReached(next) ?? this.toSnapshot(next);
+    const blocked = this.blockIfBudgetReached(next);
+    if (blocked !== null) return blocked;
+    this.refreshWallClockDeadline(next);
+    return this.toSnapshot(next);
   }
 
   async cancelGoal(_input: GoalReasonInput = {}, actor: GoalActor = 'user'): Promise<GoalSnapshot> {
+    this.assertSupportedAgent();
     const state = this.requireState();
     const snapshot = this.toSnapshot(state);
+    if (state.status === 'active' && this.liveTurnId !== undefined) {
+      this.loopService.cancel(this.liveTurnId);
+    }
     this.clearInternal(actor);
     if (actor === 'user') {
       this.reminders.appendSystemReminder(GOAL_CANCELLED_REMINDER, {
@@ -400,9 +474,12 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     input: GoalReasonInput = {},
     actor: GoalActor = 'runtime',
   ): Promise<GoalSnapshot | null> {
+    this.assertSupportedAgent();
     const state = this.goalState;
     if (state === null || state.status !== 'active') return null;
-    const snapshot = this.applyLifecycle(state, 'blocked', input.reason, actor);
+    const snapshot = this.applyLifecycle(state, 'blocked', input.reason, actor, {
+      preserveLiveContinuation: true,
+    });
     return snapshot;
   }
 
@@ -410,6 +487,7 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     input: GoalReasonInput = {},
     actor: GoalActor = 'model',
   ): Promise<GoalSnapshot | null> {
+    this.assertSupportedAgent();
     const state = this.goalState;
     if (state === null || state.status !== 'active') return null;
     this.dispatchCompletion(state, input.reason, actor);
@@ -423,7 +501,6 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
 
   private dispatchCompletion(state: GoalState, reason: string | undefined, actor: GoalActor): void {
     const wallClockMs = this.settleWallClock(state);
-    this.wallClockResumedAt = undefined;
     this.wire.dispatch(updateGoal({ status: 'complete', reason, wallClockMs, actor }));
   }
 
@@ -443,16 +520,18 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
   }
 
   async pauseOnInterrupt(input: GoalReasonInput = {}): Promise<GoalSnapshot | null> {
+    this.assertSupportedAgent();
     return this.pauseActiveGoal(input, 'user');
   }
 
   async recordTokenUsage(tokenDelta: number): Promise<GoalSnapshot | null> {
+    this.assertSupportedAgent();
     return this.accountTokenUsage(tokenDelta);
   }
 
-  private accountTokenUsage(tokenDelta: number): GoalSnapshot | null {
+  private accountTokenUsage(tokenDelta: number, goalId?: string): GoalSnapshot | null {
     const state = this.goalState;
-    if (state === null || state.status !== 'active') return null;
+    if (state === null || state.status !== 'active' || !matchesGoal(state, goalId)) return null;
     const tokensUsed = state.tokensUsed + Math.max(0, tokenDelta);
     this.wire.dispatch(updateGoal({ tokensUsed }));
     const next = this.requireState();
@@ -460,45 +539,73 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
   }
 
   async incrementTurn(): Promise<GoalSnapshot | null> {
+    this.assertSupportedAgent();
+    return this.incrementGoalTurn();
+  }
+
+  private incrementGoalTurn(goalId?: string): GoalSnapshot | null {
     const state = this.goalState;
-    if (state === null || state.status !== 'active') return null;
+    if (state === null || state.status !== 'active' || !matchesGoal(state, goalId)) return null;
     const turnsUsed = state.turnsUsed + 1;
     this.wire.dispatch(updateGoal({ turnsUsed }));
     const next = this.requireState();
     this.emitGoalUpdated(this.toSnapshot(next));
     this.telemetry.track2('goal_continued', { turns_used: next.turnsUsed });
-    return this.blockIfBudgetReached(next) ?? this.toSnapshot(next);
+    return this.toSnapshot(next);
   }
 
-  private handleTurnLaunched(turnId: number): void {
+  private handleTurnLaunched(turnId: number, origin: TurnStartedEvent['origin']): void {
     this.liveTurnId = turnId;
-    const state = this.goalState;
-    if (state?.status === 'active' && this.blockIfBudgetReached(state) === null) {
-      this.goalDrivenTurns.add(turnId);
+    this.goalTurnTargets.delete(turnId);
+    this.exhaustedTurnBudgetGoals.delete(turnId);
+    if (!this.goalDrivenTurns.has(turnId)) {
+      const state = this.goalState;
+      const continuationGoalId = isGoalContinuationOrigin(origin)
+        ? this.pendingContinuationGoals.get(turnId)
+        : undefined;
+      if (continuationGoalId !== undefined && state?.goalId !== continuationGoalId) {
+        this.goalDrivenTurns.set(turnId, continuationGoalId);
+      } else if (state?.status === 'active' && this.blockIfBudgetReached(state) === null) {
+        this.goalDrivenTurns.set(turnId, state.goalId);
+      }
     }
+    this.pendingContinuationGoals.delete(turnId);
     this.goalOutcomeToolResultTurns.delete(turnId);
     this.goalOutcomeContinuationTurns.delete(turnId);
   }
 
-  private adoptStarterTurn(): void {
+  private adoptStarterTurn(actor: GoalActor): void {
     const turnId = this.liveTurnId;
-    if (turnId === undefined || this.goalDrivenTurns.has(turnId)) return;
-    this.goalDrivenTurns.add(turnId);
+    if (turnId === undefined) return;
+    const state = this.goalState;
+    if (state === null || state.status !== 'active') return;
+    const goalId = this.goalDrivenTurns.get(turnId);
+    if (actor === 'model') this.goalTurnTargets.set(turnId, state.goalId);
+    if (this.toSnapshot(state).budget.turnBudgetReached) {
+      this.exhaustedTurnBudgetGoals.set(turnId, state.goalId);
+    } else {
+      this.exhaustedTurnBudgetGoals.delete(turnId);
+    }
+    if (goalId !== undefined) return;
+    this.goalDrivenTurns.set(turnId, state.goalId);
     this.countedGoalTurns.add(turnId);
     this.goalStarterTurns.add(turnId);
   }
 
   private async handleBeforeStep(ctx: BeforeStepContext): Promise<void> {
-    if (!this.goalDrivenTurns.has(ctx.turnId)) return;
+    const goalId = this.goalDrivenTurns.get(ctx.turnId);
+    if (goalId === undefined) return;
     if (this.countedGoalTurns.has(ctx.turnId)) return;
     this.countedGoalTurns.add(ctx.turnId);
-    await this.incrementTurn();
+    this.incrementGoalTurn(goalId);
   }
 
   private handleUsageRecorded(ctx: UsageRecordedContext): void {
     const source = ctx.source;
-    if (source?.type !== 'turn' || !this.goalDrivenTurns.has(source.turnId)) return;
-    this.accountTokenUsage(ctx.usage.output);
+    if (source?.type !== 'turn') return;
+    const goalId = this.goalDrivenTurns.get(source.turnId);
+    if (goalId === undefined) return;
+    this.accountTokenUsage(ctx.usage.output, goalId);
   }
 
   private handleAfterStep(ctx: AfterStepContext): void {
@@ -507,11 +614,22 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
   }
 
   private stopAfterBudgetReached(ctx: AfterStepContext): boolean {
+    const goalId = this.goalTurnTarget(ctx.turnId);
     const state = this.goalState;
+    const budget = state === null ? null : this.toSnapshot(state).budget;
+    const turnBudgetBlocksCurrentTurn =
+      budget?.turnBudgetReached === true &&
+      (this.exhaustedTurnBudgetGoals.get(ctx.turnId) === goalId ||
+        (state?.status === 'blocked' &&
+          state.terminalReason?.startsWith(GOAL_BUDGET_BLOCK_PREFIX) === true));
     if (
-      !this.goalDrivenTurns.has(ctx.turnId) ||
+      goalId === undefined ||
       state === null ||
-      !this.toSnapshot(state).budget.overBudget
+      state.goalId !== goalId ||
+      budget === null ||
+      (!budget.tokenBudgetReached &&
+        !budget.wallClockBudgetReached &&
+        !turnBudgetBlocksCurrentTurn)
     ) {
       return false;
     }
@@ -534,7 +652,12 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
 
   private enqueueGoalOutcomeContinuation(ctx: AfterStepContext): void {
     if (this.goalOutcomeContinuationTurns.has(ctx.turnId)) return;
-    if (!this.goalOutcomeToolResultTurns.delete(ctx.turnId)) return;
+    const goalId = this.goalTurnTarget(ctx.turnId);
+    const outcomeGoalId = this.goalOutcomeToolResultTurns.get(ctx.turnId);
+    this.goalOutcomeToolResultTurns.delete(ctx.turnId);
+    if (goalId === undefined || outcomeGoalId !== goalId) return;
+    const state = this.goalState;
+    if (state !== null && state.goalId !== goalId) return;
     this.goalOutcomeContinuationTurns.add(ctx.turnId);
     const maxSteps = this.config.get<LoopControl>(LOOP_CONTROL_SECTION)?.maxStepsPerTurn;
     if (!hasStepBudgetRemaining(maxSteps, ctx.step)) return;
@@ -545,38 +668,63 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     turnId: number,
     result: Pick<TurnEndedEvent, 'reason' | 'error'>,
   ): Promise<void> {
-    const starterTurn = this.clearTurnTracking(turnId);
+    const { goalId, lifecycleGoalId, starterTurn } = this.clearTurnTracking(turnId);
+    const resumeContinuation = this.resumeContinuation;
+    if (resumeContinuation?.turnId === turnId) this.resumeContinuation = undefined;
+    if (resumeContinuation?.turnId === turnId && result.reason === 'cancelled') {
+      const state = this.goalState;
+      if (state === null || state.status !== 'active' || state.goalId !== resumeContinuation.goalId) {
+        return;
+      }
+      if (this.blockIfBudgetReached(state) !== null) return;
+      this.launchContinuationTurn(resumeContinuation.goalId);
+      return;
+    }
+    if (goalId === undefined || lifecycleGoalId === undefined) return;
     if (
       result.reason === 'blocked' ||
       result.reason === 'cancelled' ||
       result.reason === 'failed'
     ) {
-      await this.settleAbnormalTurn(result);
+      await this.settleAbnormalTurn(result, lifecycleGoalId);
       return;
     }
-    if (starterTurn) await this.incrementTurn();
+    if (starterTurn) this.incrementGoalTurn(goalId);
 
     const state = this.goalState;
-    if (state === null || state.status !== 'active') return;
+    if (state === null || state.status !== 'active' || state.goalId !== lifecycleGoalId) return;
     if (this.blockIfBudgetReached(state) !== null) return;
-    this.launchContinuationTurn();
+    this.launchContinuationTurn(lifecycleGoalId);
   }
 
-  private clearTurnTracking(turnId: number): boolean {
+  private clearTurnTracking(
+    turnId: number,
+  ): {
+    readonly goalId?: string;
+    readonly lifecycleGoalId?: string;
+    readonly starterTurn: boolean;
+  } {
     if (this.pendingContinuation?.turnId === turnId) this.pendingContinuation = undefined;
     if (this.liveTurnId === turnId) this.liveTurnId = undefined;
+    const goalId = this.goalDrivenTurns.get(turnId);
+    const lifecycleGoalId = this.goalTurnTarget(turnId);
     const starterTurn = this.goalStarterTurns.delete(turnId);
     this.goalDrivenTurns.delete(turnId);
     this.countedGoalTurns.delete(turnId);
     this.goalOutcomeToolResultTurns.delete(turnId);
     this.goalOutcomeContinuationTurns.delete(turnId);
     this.budgetGraceTurns.delete(turnId);
-    return starterTurn;
+    this.pendingContinuationGoals.delete(turnId);
+    this.goalTurnTargets.delete(turnId);
+    this.exhaustedTurnBudgetGoals.delete(turnId);
+    return { goalId, lifecycleGoalId, starterTurn };
   }
 
   private async settleAbnormalTurn(
     result: Pick<TurnEndedEvent, 'reason' | 'error'>,
+    goalId: string,
   ): Promise<boolean> {
+    if (!this.isActiveGoal(goalId)) return false;
     if (result.reason === 'blocked') {
       await this.markBlocked({ reason: 'Blocked by UserPromptSubmit hook' });
       return true;
@@ -592,7 +740,11 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     return false;
   }
 
-  private async settleGoalAfterContinuationFailure(error: unknown): Promise<void> {
+  private async settleGoalAfterContinuationFailure(
+    error: unknown,
+    goalId: string | undefined,
+  ): Promise<void> {
+    if (goalId === undefined || !this.isActiveGoal(goalId)) return;
     try {
       const reason = pauseReasonWithMessage(
         GOAL_CONTINUATION_FAILURE_PAUSE_PREFIX,
@@ -602,7 +754,8 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     } catch {}
   }
 
-  private launchContinuationTurn(): void {
+  private launchContinuationTurn(goalId: string): void {
+    if (!this.isActiveGoal(goalId)) return;
     if (this.pendingContinuation !== undefined) return;
     const message: ContextMessage = {
       role: 'user',
@@ -615,14 +768,18 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
       admission: 'newTurn',
     });
     const receipt = this.loopService.enqueue(request);
-    const pending: PendingContinuation = { receipt };
+    const pending: PendingContinuation = { receipt, goalId };
     this.pendingContinuation = pending;
     void receipt.assigned
       .then(({ turn }) => {
-        if (this.pendingContinuation === pending) pending.turnId = turn.id;
+        pending.turnId = turn.id;
+        if (!this.goalDrivenTurns.has(turn.id)) {
+          this.pendingContinuationGoals.set(turn.id, pending.goalId);
+        }
         return turn.result;
       })
       .finally(() => {
+        if (pending.turnId !== undefined) this.pendingContinuationGoals.delete(pending.turnId);
         if (this.pendingContinuation === pending) this.pendingContinuation = undefined;
       });
   }
@@ -633,18 +790,51 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     return status.state === 'idle' && !status.hasPendingRequests;
   }
 
-  private cancelPendingContinuation(preserveLiveContinuation = false): void {
+  private isActiveGoal(goalId: string): boolean {
+    const state = this.goalState;
+    return state?.status === 'active' && state.goalId === goalId;
+  }
+
+  private isStaleGoalToolCall(ctx: ToolBeforeExecuteContext): boolean {
+    const toolName = ctx.toolCall.name;
+    if (!isGoalMutationTool(toolName)) return false;
+    const goalId = this.goalTurnTarget(ctx.turnId);
+    if (goalId === undefined) return false;
+    return this.goalState?.goalId !== goalId;
+  }
+
+  private goalTurnTarget(turnId: number): string | undefined {
+    return this.goalTurnTargets.get(turnId) ?? this.goalDrivenTurns.get(turnId);
+  }
+
+  private cancelPendingContinuation(
+    preserveLiveContinuation = false,
+    reason?: unknown,
+  ): void {
     const pending = this.pendingContinuation;
     if (preserveLiveContinuation && pending?.turnId === this.liveTurnId) return;
     this.pendingContinuation = undefined;
-    pending?.receipt.abort();
+    const aborted =
+      reason === undefined ? pending?.receipt.abort() : pending?.receipt.abort(reason);
+    if (
+      pending !== undefined &&
+      !aborted &&
+      pending.turnId !== undefined
+    ) {
+      if (reason === undefined) {
+        this.loopService.cancel(pending.turnId);
+      } else {
+        this.loopService.cancel(pending.turnId, reason);
+      }
+    }
   }
 
   private normalizeAfterReplay(): void {
     this.appendForkClearedReminder();
+    this.wallClockDeadline.clear();
+    this.liveWallClockStartedAt = undefined;
     const state = this.goalState;
     if (state === null) return;
-    this.wallClockResumedAt = undefined;
     if (state.status === 'complete') {
       this.clearInternal('runtime', { emit: false, track: false });
       return;
@@ -676,8 +866,10 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     opts: { readonly emit?: boolean; readonly track?: boolean; readonly preserveLiveContinuation?: boolean } = {},
   ): void {
     if (this.goalState === null) return;
+    this.resumeContinuation = undefined;
     this.cancelPendingContinuation(opts.preserveLiveContinuation === true);
-    this.wallClockResumedAt = undefined;
+    this.wallClockDeadline.clear();
+    this.liveWallClockStartedAt = undefined;
     this.wire.dispatch(clearGoal({}));
     if (opts.emit !== false) this.emitGoalUpdated(null);
     if (opts.track !== false) this.telemetry.track2('goal_cleared', { actor });
@@ -688,17 +880,30 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     status: GoalStatus,
     reason: string | undefined,
     actor: GoalActor,
+    opts: {
+      readonly preserveLiveContinuation?: boolean;
+      readonly cancellationReason?: unknown;
+    } = {},
   ): GoalSnapshot {
     const wallClockMs = this.settleWallClock(state);
+    const wallClockResumedAt = status === 'active' ? Date.now() : undefined;
     if (status === 'active') {
-      this.wallClockResumedAt = Date.now();
-      this.adoptStarterTurn();
+      this.liveWallClockStartedAt = this.deadlineScheduler.now();
     } else if (state.status === 'active') {
-      this.cancelPendingContinuation();
-      this.wallClockResumedAt = undefined;
+      this.resumeContinuation = undefined;
+      this.cancelPendingContinuation(
+        opts.preserveLiveContinuation === true,
+        opts.cancellationReason,
+      );
+      this.wallClockDeadline.clear();
+      this.liveWallClockStartedAt = undefined;
     }
-    this.wire.dispatch(updateGoal({ status, reason, wallClockMs, actor }));
+    this.wire.dispatch(
+      updateGoal({ status, reason, wallClockMs, wallClockResumedAt, actor }),
+    );
     const next = this.requireState();
+    if (status === 'active') this.adoptStarterTurn(actor);
+    if (status === 'active') this.refreshWallClockDeadline(next);
     this.emitGoalUpdated(this.toSnapshot(next), { kind: 'lifecycle', status, reason, actor });
     this.trackStatusChanged(next, actor);
     return this.toSnapshot(next);
@@ -728,15 +933,27 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
   }
 
   private settleWallClock(state: GoalState): number {
-    if (state.status === 'active' && this.wallClockResumedAt !== undefined) {
-      return state.wallClockMs + Math.max(0, Date.now() - this.wallClockResumedAt);
+    if (state.status === 'active' && this.liveWallClockStartedAt !== undefined) {
+      return (
+        state.wallClockMs +
+        Math.max(0, this.deadlineScheduler.now() - this.liveWallClockStartedAt)
+      );
+    }
+    if (state.status === 'active' && state.wallClockResumedAt !== undefined) {
+      return state.wallClockMs + Math.max(0, Date.now() - state.wallClockResumedAt);
     }
     return state.wallClockMs;
   }
 
   private liveWallClockMs(state: GoalState): number {
-    if (state.status === 'active' && this.wallClockResumedAt !== undefined) {
-      return state.wallClockMs + Math.max(0, Date.now() - this.wallClockResumedAt);
+    if (state.status === 'active' && this.liveWallClockStartedAt !== undefined) {
+      return (
+        state.wallClockMs +
+        Math.max(0, this.deadlineScheduler.now() - this.liveWallClockStartedAt)
+      );
+    }
+    if (state.status === 'active' && state.wallClockResumedAt !== undefined) {
+      return state.wallClockMs + Math.max(0, Date.now() - state.wallClockResumedAt);
     }
     return state.wallClockMs;
   }
@@ -768,7 +985,48 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     if (state.status !== 'active') return null;
     const reason = goalBudgetBlockReason(this.toSnapshot(state).budget);
     if (reason === undefined) return null;
-    return this.applyLifecycle(state, 'blocked', reason, 'runtime');
+    return this.applyLifecycle(state, 'blocked', reason, 'runtime', {
+      preserveLiveContinuation: true,
+    });
+  }
+
+  private refreshWallClockDeadline(state: GoalState): void {
+    this.wallClockDeadline.clear();
+    const budgetMs = state.budgetLimits.wallClockBudgetMs;
+    if (
+      state.status !== 'active' ||
+      budgetMs === undefined ||
+      this.liveWallClockStartedAt === undefined
+    ) {
+      return;
+    }
+    const remainingMs = Math.max(0, budgetMs - this.liveWallClockMs(state));
+    this.wallClockDeadline.value = this.deadlineScheduler.schedule(remainingMs, () => {
+      this.handleWallClockDeadline();
+    });
+  }
+
+  private handleWallClockDeadline(): void {
+    this.wallClockDeadline.clear();
+    const state = this.goalState;
+    if (state === null || state.status !== 'active') return;
+    const budgetMs = state.budgetLimits.wallClockBudgetMs;
+    if (budgetMs === undefined) return;
+    if (this.liveWallClockMs(state) < budgetMs) {
+      this.refreshWallClockDeadline(state);
+      return;
+    }
+    const reason = goalBudgetBlockReason(this.toSnapshot(state).budget);
+    if (reason === undefined) return;
+    const cancellation = abortError(reason);
+    const liveTurnId = this.liveTurnId;
+    const pendingTurnId = this.pendingContinuation?.turnId;
+    this.applyLifecycle(state, 'blocked', reason, 'runtime', {
+      cancellationReason: cancellation,
+    });
+    if (liveTurnId !== undefined && liveTurnId !== pendingTurnId) {
+      this.loopService.cancel(liveTurnId, cancellation);
+    }
   }
 }
 
@@ -796,6 +1054,14 @@ function computeBudgetReport(state: GoalState, wallClockMs: number): GoalBudgetR
   };
 }
 
+function matchesGoal(state: GoalState, goalId: string | undefined): boolean {
+  return goalId === undefined || state.goalId === goalId;
+}
+
+function isGoalMutationTool(toolName: string): boolean {
+  return toolName === 'CreateGoal' || toolName === 'UpdateGoal' || toolName === 'SetGoalBudget';
+}
+
 function goalBudgetBlockReason(budget: GoalBudgetReport): string | undefined {
   const reached: string[] = [];
   if (budget.turnBudgetReached) {
diff --git a/packages/agent-core-v2/src/agent/goal/tools/create-goal.ts b/packages/agent-core-v2/src/agent/goal/tools/create-goal.ts
index 1581b7a71..5e5dd2fbc 100644
--- a/packages/agent-core-v2/src/agent/goal/tools/create-goal.ts
+++ b/packages/agent-core-v2/src/agent/goal/tools/create-goal.ts
@@ -7,7 +7,7 @@
 
 import { z } from 'zod';
 
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 
 import { toInputJsonSchema } from '#/tool/input-schema';
 import { IAgentPermissionModeService } from '#/agent/permissionMode/permissionMode';
@@ -46,11 +46,19 @@ export class CreateGoalTool implements BuiltinTool<CreateGoalToolInput> {
   ) {}
 
   resolveExecution(args: CreateGoalToolInput): ToolExecution {
+    const goalAtResolution = this.goal.getGoal().goal;
     return {
       description: 'Creating a goal',
       display: this.resolveGoalStartDisplay(args),
       approvalRule: this.name,
-      execute: async () => {
+      execute: async ({ turnId }) => {
+        const currentGoal = this.goal.getGoal().goal;
+        if (
+          currentGoal?.goalId !== goalAtResolution?.goalId &&
+          (currentGoal === null || !this.goal.isGoalToolTarget(turnId, currentGoal.goalId))
+        ) {
+          return { output: 'Goal not created: the current goal changed.' };
+        }
         const snapshot = await this.goal.createGoal(
           {
             objective: args.objective,
diff --git a/packages/agent-core-v2/src/agent/goal/tools/set-goal-budget.ts b/packages/agent-core-v2/src/agent/goal/tools/set-goal-budget.ts
index 76d61af80..d9b228823 100644
--- a/packages/agent-core-v2/src/agent/goal/tools/set-goal-budget.ts
+++ b/packages/agent-core-v2/src/agent/goal/tools/set-goal-budget.ts
@@ -14,7 +14,7 @@ import type { BuiltinTool, ToolExecution } from '#/tool/toolContract';
 import { registerTool } from '#/agent/toolRegistry/toolContribution';
 
 import { IAgentGoalService } from '#/agent/goal/goal';
-import type { GoalBudgetLimits } from '#/agent/goal/types';
+import type { GoalBudgetLimits, GoalSnapshot } from '#/agent/goal/types';
 import DESCRIPTION from './set-goal-budget.md?raw';
 
 const MIN_REASONABLE_TIME_BUDGET_MS = 1_000;
@@ -40,7 +40,11 @@ export class SetGoalBudgetTool implements BuiltinTool<SetGoalBudgetToolInput> {
   resolveExecution(args: SetGoalBudgetToolInput): ToolExecution {
     const normalizedArgs = normalizeBudgetInput(args);
     const budget = budgetLimitsFromInput(normalizedArgs);
-    const overBudgetAfterSet = budget !== null && this.wouldExceedBudget(budget);
+    const goalAtResolution = this.goal.getGoal().goal;
+    const overBudgetAfterSet =
+      budget !== null &&
+      goalAtResolution !== null &&
+      this.wouldExceedBudget(goalAtResolution, budget);
     return {
       description: `Setting goal budget: ${formatBudget(
         normalizedArgs.value,
@@ -48,10 +52,17 @@ export class SetGoalBudgetTool implements BuiltinTool<SetGoalBudgetToolInput> {
       )}`,
       stopBatchAfterThis: overBudgetAfterSet,
       approvalRule: this.name,
-      execute: async () => {
-        if (this.goal.getGoal().goal === null) {
+      execute: async ({ turnId }) => {
+        const currentGoal = this.goal.getGoal().goal;
+        if (currentGoal === null) {
           return { output: 'Goal budget not set: no current goal.' };
         }
+        if (
+          currentGoal.goalId !== goalAtResolution?.goalId &&
+          !this.goal.isGoalToolTarget(turnId, currentGoal.goalId)
+        ) {
+          return { output: 'Goal budget not set: the current goal changed.' };
+        }
         if (budget === null) {
           return {
             output:
@@ -75,9 +86,7 @@ export class SetGoalBudgetTool implements BuiltinTool<SetGoalBudgetToolInput> {
     };
   }
 
-  private wouldExceedBudget(newLimits: GoalBudgetLimits): boolean {
-    const goal = this.goal.getGoal().goal;
-    if (goal === null) return false;
+  private wouldExceedBudget(goal: GoalSnapshot, newLimits: GoalBudgetLimits): boolean {
     const current = goal.budget;
     const turnBudget = newLimits.turnBudget ?? current.turnBudget;
     const tokenBudget = newLimits.tokenBudget ?? current.tokenBudget;
diff --git a/packages/agent-core-v2/src/agent/goal/tools/update-goal.ts b/packages/agent-core-v2/src/agent/goal/tools/update-goal.ts
index 22bb95f5d..f058126b3 100644
--- a/packages/agent-core-v2/src/agent/goal/tools/update-goal.ts
+++ b/packages/agent-core-v2/src/agent/goal/tools/update-goal.ts
@@ -58,11 +58,18 @@ export class UpdateGoalTool implements BuiltinTool<UpdateGoalToolInput> {
       description: `Setting goal status: ${status}`,
       stopBatchAfterThis: status !== 'active' && goalIsActive,
       approvalRule: this.name,
-      execute: async () => {
+      execute: async ({ turnId }) => {
+        const goalAtExecution = this.goal.getGoal().goal;
+        if (goalAtExecution === null || (currentGoal === null && status === 'active')) {
+          return { output: missingGoalOutput(status) };
+        }
+        if (
+          goalAtExecution.goalId !== currentGoal?.goalId &&
+          !this.goal.isGoalToolTarget(turnId, goalAtExecution.goalId)
+        ) {
+          return { output: changedGoalOutput(status) };
+        }
         if (status === 'active') {
-          if (currentGoal === null) {
-            return { output: 'Goal not resumed: no current goal.' };
-          }
           await this.goal.resumeGoal({}, 'model');
           return { output: 'Goal resumed.' };
         }
@@ -93,6 +100,18 @@ function isUpdateGoalStatus(status: unknown): status is UpdateGoalToolInput['sta
   return status === 'active' || status === 'complete' || status === 'blocked';
 }
 
+function missingGoalOutput(status: UpdateGoalToolInput['status']): string {
+  if (status === 'active') return 'Goal not resumed: no current goal.';
+  if (status === 'complete') return 'Goal not completed: no active goal.';
+  return 'Goal not blocked: no active goal.';
+}
+
+function changedGoalOutput(status: UpdateGoalToolInput['status']): string {
+  if (status === 'active') return 'Goal not resumed: the current goal changed.';
+  if (status === 'complete') return 'Goal not completed: the current goal changed.';
+  return 'Goal not blocked: the current goal changed.';
+}
+
 registerTool(UpdateGoalTool, {
   when: (accessor) => accessor.get(IAgentScopeContext).agentId === 'main',
 });
diff --git a/packages/agent-core-v2/src/agent/llmRequester/llmRequester.ts b/packages/agent-core-v2/src/agent/llmRequester/llmRequester.ts
index 6232730e1..178bad412 100644
--- a/packages/agent-core-v2/src/agent/llmRequester/llmRequester.ts
+++ b/packages/agent-core-v2/src/agent/llmRequester/llmRequester.ts
@@ -4,6 +4,7 @@ import type { FinishReason } from '#/app/llmProtocol/finishReason';
 import type { Message, StreamedMessagePart } from '#/app/llmProtocol/message';
 import type { Tool } from '#/app/llmProtocol/tool';
 import type { TokenUsage } from '#/app/llmProtocol/usage';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 import type { LogContext } from '#/_base/log/log';
 
 export type LLMRequestLogFields = Readonly<LogContext>;
@@ -64,6 +65,8 @@ export interface LLMRequestFinish {
   rawFinishReason?: string;
   providerMessageId?: string;
   timing?: LLMStreamTiming;
+  /** Trace id of the request that produced this finish (Kimi `x-trace-id`). */
+  traceId?: string;
 }
 
 export type LLMRequestPartHandler = (part: StreamedMessagePart) => void | Promise<void>;
@@ -106,6 +109,10 @@ export type SystemPromptContribution = (
   context: SystemPromptContributionContext,
 ) => string;
 
+export interface LLMRequestTask {
+  readonly trace: LLMRequestTrace;
+  readonly result: Promise<LLMRequestFinish>;
+}
 export interface IAgentLLMRequesterService {
   readonly _serviceBrand: undefined;
 
@@ -124,6 +131,12 @@ export interface IAgentLLMRequesterService {
     id: string,
     contribution: SystemPromptContribution,
   ): IDisposable;
+
+  start(
+    overrides?: LLMRequestOverrides,
+    onPart?: LLMRequestPartHandler,
+    signal?: AbortSignal,
+  ): LLMRequestTask;
 }
 
 export const IAgentLLMRequesterService = createDecorator<IAgentLLMRequesterService>(
diff --git a/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts b/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
index a106071c2..a692df28e 100644
--- a/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
+++ b/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
@@ -17,9 +17,10 @@
  * handler, records `usage` through `IAgentUsageService`, resolves to an
  * `LLMRequestFinish` on the `finish` event, logs the request lifecycle
  * (config deduplicated by content, request/response/failure lines, plus
- * per-request fields) through `log`, records durable request-trace Ops
- * through `wire`, and reports provider failures through `telemetry`. Bound
- * at Agent scope.
+ * per-request fields) through `log`, publishes advisory model-capability
+ * warnings through `eventBus`, records durable request-trace Ops
+ * through `wire`, reports each request's `x-trace-id` to its caller, and
+ * reports provider failures through `telemetry`. Bound at Agent scope.
  */
 
 import { createHash } from 'node:crypto';
@@ -41,6 +42,7 @@ import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentToolSelectService } from '#/agent/toolSelect/toolSelect';
 import { IAgentUsageService } from '#/agent/usage/usage';
 import { IConfigService } from '#/app/config/config';
+import { IEventBus } from '#/app/event/eventBus';
 import {
   APIConnectionError,
   APIContextOverflowError,
@@ -66,22 +68,23 @@ import { applyCompletionBudget, resolveCompletionBudget } from '#/app/model/comp
 import type { Protocol } from '#/app/protocol/protocol';
 import type { ApiErrorEvent } from '#/app/telemetry/events';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 import type { PayloadOf } from '#/wire/types';
-import type { IWireService } from '#/wire/wireService';
 import { THINKING_SECTION, type ThinkingConfig } from '#/agent/profile/configSection';
 import { resolveThinkingKeep } from '#/agent/profile/thinking';
 
-import type {
-  LLMRequestFinish,
-  LLMRequestLogFields,
-  LLMRequestOverrides,
-  LLMRequestPartHandler,
-  LLMRequestSource,
-  LLMStreamTiming,
-  SystemPromptContribution,
+import {
+  IAgentLLMRequesterService,
+  type LLMRequestFinish,
+  type LLMRequestLogFields,
+  type LLMRequestOverrides,
+  type LLMRequestPartHandler,
+  type LLMRequestSource,
+  type LLMRequestTask,
+  type LLMStreamTiming,
+  type SystemPromptContribution,
 } from './llmRequester';
-import { IAgentLLMRequesterService } from './llmRequester';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 import {
   LlmRequestTraceModel,
   llmRequest,
@@ -145,6 +148,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
   private readonly turnConfigs = new Map<number, TurnRequestConfig>();
   private readonly mediaDegradedTurns = new Set<number>();
   private readonly mediaStrippedTurns = new Map<number, MediaStripSnapshot>();
+  private readonly emittedThinkingEffortWarnings = new Set<string>();
 
   constructor(
     @IAgentContextMemoryService private readonly context: IAgentContextMemoryService,
@@ -157,8 +161,9 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     @IConfigService private readonly config: IConfigService,
     @ILogService private readonly log: ILogService,
     @ITelemetryService private readonly telemetry: ITelemetryService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IFaultInjectionService private readonly faultInjection: IFaultInjectionService,
+    @IEventBus private readonly eventBus: IEventBus,
   ) {}
 
   registerSystemPromptContribution(
@@ -175,37 +180,56 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     overrides: LLMRequestOverrides = {},
     onPart: LLMRequestPartHandler = noopOnPart,
     signal?: AbortSignal,
+  ): Promise<LLMRequestFinish> {
+    return this.start(overrides, onPart, signal).result;
+  }
+
+  start(
+    overrides: LLMRequestOverrides = {},
+    onPart: LLMRequestPartHandler = noopOnPart,
+    signal?: AbortSignal,
+  ): LLMRequestTask {
+    const trace = new MutableLLMRequestTrace();
+    return {
+      trace,
+      result: this.requestWithTrace(trace, overrides, onPart, signal),
+    };
+  }
+
+  private async requestWithTrace(
+    trace: MutableLLMRequestTrace,
+    overrides: LLMRequestOverrides,
+    onPart: LLMRequestPartHandler,
+    signal: AbortSignal | undefined,
   ): Promise<LLMRequestFinish> {
     signal?.throwIfAborted();
-    return this.requestWithRetry(overrides, onPart, signal);
+    trace.set(undefined);
+    return this.requestWithRetry(trace, overrides, onPart, signal);
   }
 
   private async requestWithRetry(
+    trace: MutableLLMRequestTrace,
     overrides: LLMRequestOverrides,
     onPart: LLMRequestPartHandler,
     signal: AbortSignal | undefined,
   ): Promise<LLMRequestFinish> {
     const startedAt = Date.now();
     const maxAttempts = Math.max(overrides.retry?.maxAttempts ?? DEFAULT_MAX_RETRY_ATTEMPTS, 1);
-
-    if (maxAttempts <= 1) {
-      try {
-        return await this.executeRequestAttempt(overrides, onPart, signal, 1, maxAttempts);
-      } catch (error) {
-        this.logRequestFailure(error, overrides, signal, 1, maxAttempts);
-        this.trackApiError(error, startedAt, signal);
-        throw error;
-      }
-    }
-
     const delays = retryBackoffDelays(maxAttempts);
     for (let attempt = 1; ; attempt += 1) {
       try {
-        return await this.executeRequestAttempt(overrides, onPart, signal, attempt, maxAttempts);
+        return await this.executeRequestAttempt(
+          trace,
+          overrides,
+          onPart,
+          signal,
+          attempt,
+          maxAttempts,
+        );
       } catch (error) {
         if (attempt >= maxAttempts || !isRetryableGenerateError(error)) {
           this.logRequestFailure(error, overrides, signal, attempt, maxAttempts);
-          this.trackApiError(error, startedAt, signal);
+          trace.set(this.trackApiError(error, startedAt, signal, overrides.source, trace.traceId));
           throw error;
         }
 
@@ -224,6 +248,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
   }
 
   private async executeRequestAttempt(
+    trace: MutableLLMRequestTrace,
     overrides: LLMRequestOverrides,
     onPart: LLMRequestPartHandler,
     signal: AbortSignal | undefined,
@@ -235,7 +260,9 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
       overrides,
       attempt === 1 ? undefined : { attempt: `${String(attempt)}/${String(maxAttempts)}` },
     );
-    return this.runRequest(request, onPart, signal);
+    return this.runRequest(request, onPart, signal, (traceId) => {
+      trace.set(traceId);
+    });
   }
 
   private logRequestFailure(
@@ -259,10 +286,13 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     error: unknown,
     startedAt: number,
     signal: AbortSignal | undefined,
-  ): void {
-    if (isAbortError(error) || signal?.aborted === true) return;
+    source?: LLMRequestSource,
+    requestTraceId?: string,
+  ): string | undefined {
+    if (isAbortError(error) || signal?.aborted === true) return requestTraceId;
     const modelAlias = this.profile.data().modelAlias;
     const model = this.tryGetProvider();
+    const traceId = requestTraceId ?? apiTraceId(error);
     const properties: ApiErrorEvent = {
       error_type: apiErrorType(error),
       model: model?.id ?? modelAlias ?? 'unknown',
@@ -271,12 +301,18 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
       protocol: model?.protocol,
       retryable: isRetryableGenerateError(error),
       duration_ms: Math.max(0, Date.now() - startedAt),
+      trace_id: traceId,
     };
+    if (source?.type === 'turn') {
+      properties['turn_id'] = source.turnId;
+      if (source.step !== undefined) properties['step_no'] = source.step;
+    }
     const statusCode = apiStatusCode(error);
     if (statusCode !== undefined) properties['status_code'] = statusCode;
     const currentTurn = this.usage.status().currentTurn;
     if (currentTurn !== undefined) properties['input_tokens'] = inputTotal(currentTurn);
     this.telemetry.track2('api_error', properties);
+    return traceId;
   }
 
   private tryGetProvider(): Model | undefined {
@@ -291,6 +327,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     request: ResolvedLLMRequest,
     onPart: LLMRequestPartHandler,
     signal: AbortSignal | undefined,
+    onRequestTrace: (traceId: string | undefined) => void,
   ): Promise<LLMRequestFinish> {
     let mediaStripSnapshot = this.mediaStripSnapshotForTurn(request.source);
     const requestInput = (projection: RequestProjection) => {
@@ -315,11 +352,13 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     };
 
     const run = async (projection: RequestProjection): Promise<LLMRequestFinish> => {
+      onRequestTrace(undefined);
       const input = requestInput(projection);
       const fields =
         projection === 'normal'
           ? request.logFields
           : { ...request.logFields, projection };
+      this.warnAboutAnthropicThinkingEffort(request);
       const logInput: LLMRequestLogInput = {
         protocol: request.model.protocol,
         modelName: request.model.name,
@@ -344,7 +383,12 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
       let timing: LLMStreamTiming | undefined;
       let finish: Extract<ModelRequestEvent, { type: 'finish' }> | undefined;
 
-      for await (const event of request.model.request(input, signal)) {
+      const setTraceId = (traceId: string | null | undefined): void => {
+        const normalized = traceId ?? undefined;
+        onRequestTrace(normalized);
+      };
+
+      for await (const event of request.model.request(input, signal, { onTraceId: setTraceId })) {
         switch (event.type) {
           case 'part':
             await onPart(event.part);
@@ -355,6 +399,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
           case 'finish':
             finish = event;
             message = event.message;
+            setTraceId(event.traceId);
             break;
           case 'timing': {
             const { type: _type, ...streamTiming } = event;
@@ -380,6 +425,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
         rawFinishReason: finish.rawFinishReason,
         providerMessageId: finish.id,
         timing,
+        traceId: finish.traceId,
       };
     };
 
@@ -456,6 +502,45 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     }
   }
 
+  private warnAboutAnthropicThinkingEffort(request: ResolvedLLMRequest): void {
+    if (request.model.protocol !== 'anthropic') return;
+    const effort = request.thinkingEffort;
+    if (effort === 'on') return;
+
+    let code: string;
+    let message: string;
+    let knownEfforts: string | undefined;
+    if (effort === 'off') {
+      if (!request.model.alwaysThinking) return;
+      code = 'anthropic-thinking-cannot-disable';
+      message = `Model "${request.model.name}" declares always-on thinking. The configured effort "off" will be sent unchanged to the Anthropic-compatible backend.`;
+    } else {
+      const supportEfforts = request.model.supportEfforts?.filter((value) => value.length > 0);
+      if (supportEfforts === undefined || supportEfforts.length === 0) return;
+      if (supportEfforts.includes(effort)) return;
+      code = 'anthropic-thinking-effort-not-listed';
+      knownEfforts = supportEfforts.join(',');
+      message = `Thinking effort "${effort}" is not listed for model "${request.model.name}" (known: ${supportEfforts.join(', ')}). The configured value will be sent unchanged to the Anthropic-compatible backend.`;
+    }
+
+    const key = [code, request.modelAlias, request.model.name, effort, knownEfforts].join('\u0000');
+    if (this.emittedThinkingEffortWarnings.has(key)) return;
+    this.emittedThinkingEffortWarnings.add(key);
+    try {
+      this.log.warn(message, {
+        modelAlias: request.modelAlias,
+        model: request.model.name,
+        effort,
+        knownEfforts,
+      });
+    } catch {
+    }
+    try {
+      this.eventBus.publish({ type: 'warning', code, message });
+    } catch {
+    }
+  }
+
   private isRecoveryTurn(set: ReadonlySet<number>, source: LLMRequestSource | undefined): boolean {
     if (source?.type !== 'turn') return false;
     return set.has(source.turnId);
@@ -668,6 +753,14 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
   }
 }
 
+class MutableLLMRequestTrace implements LLMRequestTrace {
+  traceId: string | undefined;
+
+  set(traceId: string | undefined): void {
+    this.traceId = traceId;
+  }
+}
+
 function logFieldsForSource(
   source: LLMRequestSource | undefined,
   extraFields?: LLMRequestLogFields,
@@ -773,6 +866,19 @@ function apiStatusCode(error: unknown): number | undefined {
   return undefined;
 }
 
+function apiTraceId(error: unknown): string | undefined {
+  const raw = unwrapErrorCause(error);
+  if (raw instanceof APIStatusError && raw.traceId !== null) return raw.traceId;
+  if (typeof error === 'object' && error !== null) {
+    const details = (error as Record<string, unknown>)['details'];
+    if (typeof details === 'object' && details !== null) {
+      const traceId = (details as Record<string, unknown>)['traceId'];
+      if (typeof traceId === 'string') return traceId;
+    }
+  }
+  return undefined;
+}
+
 registerScopedService(
   LifecycleScope.Agent,
   IAgentLLMRequesterService,
diff --git a/packages/agent-core-v2/src/agent/loop/errors.ts b/packages/agent-core-v2/src/agent/loop/errors.ts
index d1dd4075d..8392e279d 100644
--- a/packages/agent-core-v2/src/agent/loop/errors.ts
+++ b/packages/agent-core-v2/src/agent/loop/errors.ts
@@ -4,6 +4,9 @@
  * `context.overflow` used to live here; it moved to `ProtocolErrors` because
  * the translation that raises it happens at the `protocol` boundary. The
  * wire code string is unchanged.
+ *
+ * `turn.agent_busy` is the legacy turn-domain code kept for its last thrower
+ * (skill activation while a turn is active); the wire string is unchanged.
  */
 
 import { registerErrorDomain, type ErrorDomain } from '#/_base/errors/codes';
@@ -11,7 +14,9 @@ import { registerErrorDomain, type ErrorDomain } from '#/_base/errors/codes';
 export const LoopErrors = {
   codes: {
     LOOP_MAX_STEPS_EXCEEDED: 'loop.max_steps_exceeded',
+    TURN_AGENT_BUSY: 'turn.agent_busy',
   },
+  retryable: ['turn.agent_busy'],
   info: {
     'loop.max_steps_exceeded': {
       title: 'Loop max steps exceeded',
diff --git a/packages/agent-core-v2/src/agent/loop/loop.ts b/packages/agent-core-v2/src/agent/loop/loop.ts
index b1895c651..c7ff6852a 100644
--- a/packages/agent-core-v2/src/agent/loop/loop.ts
+++ b/packages/agent-core-v2/src/agent/loop/loop.ts
@@ -128,6 +128,7 @@ export interface AgentLoopStatus {
   readonly activeTurnId?: number;
   readonly pendingTurnIds: readonly number[];
   readonly hasPendingRequests: boolean;
+  readonly activeTraceId?: string;
 }
 
 export interface StepEnqueueOptions {
@@ -145,6 +146,10 @@ export interface IAgentLoopService {
 
   cancel(turnId?: number, reason?: unknown): boolean;
 
+  /** Resolves once no turn is active and none are queued — the disposal drain
+   *  awaited by `agentLifecycle.remove`. */
+  settled(): Promise<void>;
+
   hasPendingRequests(): boolean;
 
   registerLoopErrorHandler(
diff --git a/packages/agent-core-v2/src/agent/loop/loopService.ts b/packages/agent-core-v2/src/agent/loop/loopService.ts
index e77307b5e..fce65bfec 100644
--- a/packages/agent-core-v2/src/agent/loop/loopService.ts
+++ b/packages/agent-core-v2/src/agent/loop/loopService.ts
@@ -2,11 +2,12 @@
  * `loop` domain (L4) — `IAgentLoopService` implementation.
  *
  * Owns a FIFO of Turn jobs, each with its own `StepRequestQueue`. Admission
- * reserves a stable Turn handle immediately; the head job alone takes the
- * activity lease, records `turn.prompt`, publishes `turn.started`, and drains
- * its Steps. Ending publishes `turn.ended` after `lease.end()` and pumps the
- * next queued Turn. Requests without an active Turn remain in the Loop-owned
- * pending-input queue and bind to the next admitted Turn.
+ * reserves a stable Turn handle immediately; the head job alone books the
+ * agent's work span with the session lifecycle, records `turn.prompt`,
+ * publishes `turn.started`, and drains its Steps. Ending unbooks the work span,
+ * then publishes `turn.ended` and pumps the next queued Turn. Requests without
+ * an active Turn remain in the Loop-owned pending-input queue and bind to the
+ * next admitted Turn.
  *
  * The run drains the queue one batch per step: each batch's driver request
  * (plus any mergeable requests folded into it) materializes its context
@@ -36,17 +37,8 @@ import { Disposable, toDisposable, type IDisposable } from '#/_base/di/lifecycle
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { abortError, isAbortError, isUserCancellation, userCancellationReason } from '#/_base/utils/abort';
 import { toErrorMessage } from '#/_base/errors/errorMessage';
-import type {
-  AssistantDeltaEvent,
-  ThinkingDeltaEvent,
-  ToolCallDeltaEvent,
-  TurnEndedEvent,
-  TurnStartedEvent,
-  TurnStepCompletedEvent,
-  TurnStepInterruptedEvent,
-  TurnStepStartedEvent,
-} from '@moonshot-ai/protocol';
 import { IAgentLLMRequesterService, type LLMRequestFinish } from '#/agent/llmRequester/llmRequester';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
 import { IConfigService } from '#/app/config/config';
 import { IEventBus } from '#/app/event/eventBus';
@@ -56,8 +48,6 @@ import { type TokenUsage } from '#/app/llmProtocol/usage';
 import { BugIndicatingError, ErrorCodes, Error2, isError2, toKimiErrorPayload } from '#/errors';
 import { OrderedHookSlot } from '#/hooks';
 
-import type { ActivityLease } from '#/activity/activity';
-import { IAgentActivityService } from '#/activity/activity';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import { IAgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContext';
 import type {
@@ -66,8 +56,7 @@ import type {
   TurnStartedEvent as TurnStartedTelemetryEvent,
 } from '#/app/telemetry/events';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import { LOOP_CONTROL_SECTION, type LoopControl } from './configSection';
 import {
   createMaxStepsExceededError,
@@ -93,19 +82,10 @@ import {
 } from './stepRequest';
 import { StepRequestQueue, type StepRequestBatch } from './stepRequestQueue';
 import { cancelTurn, promptTurn, TurnModel } from './turnOps';
-
-declare module '#/app/event/eventBus' {
-  interface DomainEventMap {
-    'turn.started': TurnStartedEvent;
-    'turn.ended': TurnEndedEvent;
-    'turn.step.started': TurnStepStartedEvent;
-    'turn.step.completed': TurnStepCompletedEvent;
-    'turn.step.interrupted': TurnStepInterruptedEvent;
-    'assistant.delta': AssistantDeltaEvent;
-    'thinking.delta': ThinkingDeltaEvent;
-    'tool.call.delta': ToolCallDeltaEvent;
-  }
-}
+// Loads the `DomainEventMap` augmentation for the `turn.*` / delta events this
+// service publishes (the augmentation lives with the event definitions;
+// without an import it would not enter every consumer's program).
+import './turnEvents';
 
 export type LoopInterruptReason = 'aborted' | 'max_steps' | 'error';
 
@@ -123,6 +103,9 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   private readonly pendingTurns: TurnJob[] = [];
   private activeTurnJob: TurnJob | undefined;
   private nextReservedTurnId: number | undefined;
+  private readonly settleWaiters: Array<() => void> = [];
+  private activeRequestTrace: LLMRequestTrace | undefined;
+  private lastRequestTraceId: string | undefined;
   private disposing = false;
 
   constructor(
@@ -131,8 +114,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     @IEventBus private readonly eventBus: IEventBus,
     @IAgentToolExecutorService private readonly toolExecutor: IAgentToolExecutorService,
     @IConfigService private readonly config: IConfigService,
-    @IAgentActivityService private readonly activity: IAgentActivityService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @ITelemetryService private readonly telemetry: ITelemetryService,
     @IAgentTelemetryContextService private readonly telemetryContext: IAgentTelemetryContextService,
   ) {
@@ -149,6 +131,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
       request.abort();
       this.rejectAssignment(request, reason);
     }
+    this.maybeSettle();
     super.dispose();
   }
 
@@ -204,6 +187,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
       activeTurnId: this.activeTurnJob?.turn.id,
       pendingTurnIds: this.pendingTurns.map((job) => job.turn.id),
       hasPendingRequests: this.hasPendingRequests(),
+      activeTraceId: this.activeRequestTrace?.traceId,
     };
   }
 
@@ -216,10 +200,11 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   }
 
   private cancelActiveTurn(turnId: number | undefined, cancellation: unknown): boolean {
-    const turn = this.activeTurnJob?.turn;
-    if (turn === undefined || (turnId !== undefined && turn.id !== turnId)) return false;
+    const job = this.activeTurnJob;
+    if (job === undefined || (turnId !== undefined && job.turn.id !== turnId)) return false;
     this.wire.dispatch(cancelTurn({ turnId }));
-    return this.activity.cancel(cancellation);
+    job.controller.abort(cancellation);
+    return true;
   }
 
   private cancelQueuedTurn(turnId: number, cancellation: unknown): boolean {
@@ -233,6 +218,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     job.turn.state = 'cancelled';
     job.ready.reject(cancellation instanceof Error ? cancellation : abortError('Turn cancelled'));
     job.result.resolve({ type: 'cancelled', steps: 0, reason: cancellation });
+    this.maybeSettle();
     return true;
   }
 
@@ -244,6 +230,22 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     );
   }
 
+  settled(): Promise<void> {
+    if (this.activeTurnJob === undefined && this.pendingTurns.length === 0) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      this.settleWaiters.push(resolve);
+    });
+  }
+
+  private maybeSettle(): void {
+    if (this.activeTurnJob !== undefined || this.pendingTurns.length > 0) return;
+    if (this.settleWaiters.length === 0) return;
+    const waiters = this.settleWaiters.splice(0);
+    for (const resolve of waiters) resolve();
+  }
+
   private createPendingTurn(request: StepRequest, seed: TurnSeed): TurnJob {
     const id = this.reserveTurnId();
     const controller = new AbortController();
@@ -344,47 +346,53 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   private pumpTurns(): void {
     if (this.disposing || this.activeTurnJob !== undefined) return;
     const job = this.pendingTurns.shift();
-    if (job === undefined) return;
+    if (job === undefined) {
+      this.maybeSettle();
+      return;
+    }
     this.startTurn(job);
   }
 
   private startTurn(job: TurnJob): void {
-    const lease = this.activity.begin('turn', { origin: job.seed.origin, turnId: job.turn.id });
-    this.wire.dispatch(promptTurn({ input: job.seed.input, origin: lease.origin }));
+    const origin = job.seed.origin;
+    // The loop owns the turn's abort channel outright (job.controller) and
+    // reports to no one — busy is derived from its events, never registered.
+    this.wire.dispatch(promptTurn({ input: job.seed.input, origin }));
     job.turn.state = 'running';
-    job.turn.signal = lease.signal;
     this.activeTurnJob = job;
-    this.eventBus.publish({ type: 'turn.started', turnId: job.turn.id, origin: lease.origin });
-    void this.runTurn(job.turn, lease, job.ready).then(job.result.resolve, job.result.reject);
+    this.eventBus.publish({ type: 'turn.started', turnId: job.turn.id, origin });
+    void this.runTurn(job.turn, job.ready).then(job.result.resolve, job.result.reject);
   }
 
   private async runTurn(
     turn: Turn,
-    lease: ActivityLease,
     ready: ReturnType<typeof createControlledPromise<void>>,
   ): Promise<TurnResult> {
     const startedAt = Date.now();
+    this.telemetryContext.set({ turn_id: turn.id });
     const telemetryContext = this.telemetryContext.get();
     const turnTelemetry = this.telemetry.withContext(telemetryContext);
     const { mode, provider_type, protocol } = telemetryContext;
     let result: TurnResult | undefined;
     try {
-      const started: TurnStartedTelemetryEvent = { mode, provider_type, protocol };
+      const started: TurnStartedTelemetryEvent = { turn_id: turn.id, mode, provider_type, protocol };
       turnTelemetry.track2('turn_started', started);
       result = await this.run({
         turnId: turn.id,
-        signal: lease.signal,
+        signal: turn.signal,
         onStarted: () => ready.resolve(),
       });
       return result;
     } catch (error) {
-      result = this.resultFromTurnError(lease, error);
+      result = this.resultFromTurnError(turn, error);
       return result;
     } finally {
       this.settleTurnReady(ready, result);
       this.releaseActiveTurn(turn, result);
-      const outcome = result?.type ?? 'failed';
-      lease.end(outcome, result?.type === 'failed' ? { error: result.error } : undefined);
+      const traceId =
+        result?.type === 'completed'
+          ? this.lastRequestTraceId
+          : this.activeRequestTrace?.traceId;
       if (result !== undefined) {
         const error = result.type === 'failed' ? toKimiErrorPayload(result.error) : undefined;
         this.eventBus.publish({
@@ -397,30 +405,37 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
         if (error !== undefined) this.eventBus.publish({ type: 'error', ...error });
         if (result.type !== 'completed') {
           const interrupted: TurnInterruptedEvent = {
+            turn_id: turn.id,
             at_step: result.steps,
             mode,
             interrupt_reason: interruptReasonFor(result),
             provider_type,
             protocol,
+            trace_id: traceId,
           };
           turnTelemetry.track2('turn_interrupted', interrupted);
         }
       }
       const ended: TurnEndedTelemetryEvent = {
+        turn_id: turn.id,
         reason: result?.type ?? 'failed',
         duration_ms: Date.now() - startedAt,
         mode,
         provider_type,
         protocol,
+        trace_id: traceId,
       };
       turnTelemetry.track2('turn_ended', ended);
+      this.activeRequestTrace = undefined;
+      this.lastRequestTraceId = undefined;
       this.pumpTurns();
     }
   }
 
-  private resultFromTurnError(lease: ActivityLease, error: unknown): TurnResult {
-    if (!lease.signal.aborted) return { type: 'failed', error, steps: 0 };
-    return { type: 'cancelled', steps: 0, reason: lease.signal.reason ?? error };
+  private resultFromTurnError(turn: Turn, error: unknown): TurnResult {
+    const signal = turn.signal;
+    if (!signal?.aborted) return { type: 'failed', error, steps: 0 };
+    return { type: 'cancelled', steps: 0, reason: signal.reason ?? error };
   }
 
   private settleTurnReady(
@@ -676,13 +691,17 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     stepUuid: string,
     onStarted: ((step: number) => void) | undefined,
   ): Promise<StepExecutionResult> {
+    this.activeRequestTrace = undefined;
     await this.hooks.onWillBeginStep.run({ turnId, step: currentStep, signal });
     const markStepStarted = this.beginStep(turnId, signal, currentStep, stepUuid, onStarted);
-    const response = await this.llmRequester.request(
+    const request = this.llmRequester.start(
       { source: { type: 'turn', turnId, step: currentStep } },
       this.createStreamPartHandler(turnId, markStepStarted),
       signal,
     );
+    this.activeRequestTrace = request.trace;
+    const response = await request.result;
+    this.lastRequestTraceId = request.trace.traceId;
     this.appendResponseContent(turnId, currentStep, stepUuid, response);
     const finishReason = await this.executeStepTools(
       turnId,
@@ -690,6 +709,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
       currentStep,
       stepUuid,
       response,
+      request.trace,
     );
     this.finishStep(turnId, signal, currentStep, stepUuid, response, finishReason, markStepStarted);
     const hookStopTurn = await this.runAfterStep(
@@ -749,6 +769,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     currentStep: number,
     stepUuid: string,
     response: LLMRequestFinish,
+    trace: LLMRequestTrace,
   ): Promise<FinishReason> {
     let finishReason = response.providerFinishReason ?? 'completed';
     if (response.message.toolCalls.length === 0) {
@@ -759,6 +780,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     for await (const toolResult of this.toolExecutor.execute(response.message.toolCalls, {
       signal,
       turnId,
+      trace,
       onToolCall: ({ toolCallId, name, args }) => {
         const callUuid = randomUUID();
         toolCallUuids.set(toolCallId, callUuid);
diff --git a/packages/agent-core-v2/src/agent/loop/turnEvents.ts b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
new file mode 100644
index 000000000..9f9db2aef
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
@@ -0,0 +1,103 @@
+/**
+ * `loop` domain — the `turn.*` / delta event payloads published through
+ * `IEventBus` as a turn runs. These are the loop's share of the agent event
+ * stream; consumers (transports, replay, telemetry) subscribe by `type`.
+ */
+
+import type { KimiErrorPayload } from '#/_base/errors/serialize';
+import type { PromptOrigin } from '#/agent/contextMemory/types';
+import type { FinishReason } from '#/app/llmProtocol/finishReason';
+import type { TokenUsage } from '#/app/llmProtocol/usage';
+
+/** Why a turn ended. `blocked` folds into `failed` at the wire edge. */
+export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked';
+
+export interface TurnStartedEvent {
+  readonly type: 'turn.started';
+  readonly turnId: number;
+  readonly origin: PromptOrigin;
+}
+
+export interface TurnEndedEvent {
+  readonly type: 'turn.ended';
+  readonly turnId: number;
+  readonly reason: TurnEndReason;
+  readonly error?: KimiErrorPayload;
+  readonly durationMs?: number;
+}
+
+export interface TurnStepStartedEvent {
+  readonly type: 'turn.step.started';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string;
+}
+
+export interface TurnStepCompletedEvent {
+  readonly type: 'turn.step.completed';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string;
+  readonly usage?: TokenUsage;
+  readonly finishReason?: string;
+  readonly llmFirstTokenLatencyMs?: number;
+  readonly llmStreamDurationMs?: number;
+  /**
+   * Split of `llmFirstTokenLatencyMs`: in-process request-building time on the
+   * client vs. network + API-server time to the first token. Both omitted when
+   * the provider does not report the client/server boundary.
+   */
+  readonly llmRequestBuildMs?: number;
+  readonly llmServerFirstTokenMs?: number;
+  /**
+   * Split of `llmStreamDurationMs` (the decode window): time awaiting parts from
+   * the provider vs. time processing parts in-process. Both omitted when the
+   * provider stream did not report decode accounting.
+   */
+  readonly llmServerDecodeMs?: number;
+  readonly llmClientConsumeMs?: number;
+  readonly providerFinishReason?: FinishReason;
+  readonly rawFinishReason?: string;
+}
+
+export interface TurnStepInterruptedEvent {
+  readonly type: 'turn.step.interrupted';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string;
+  readonly reason: string;
+  readonly message?: string;
+}
+
+export interface AssistantDeltaEvent {
+  readonly type: 'assistant.delta';
+  readonly turnId: number;
+  readonly delta: string;
+}
+
+export interface ThinkingDeltaEvent {
+  readonly type: 'thinking.delta';
+  readonly turnId: number;
+  readonly delta: string;
+}
+
+export interface ToolCallDeltaEvent {
+  readonly type: 'tool.call.delta';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly name?: string;
+  readonly argumentsPart?: string;
+}
+
+declare module '#/app/event/eventBus' {
+  interface DomainEventMap {
+    'turn.started': TurnStartedEvent;
+    'turn.ended': TurnEndedEvent;
+    'turn.step.started': TurnStepStartedEvent;
+    'turn.step.completed': TurnStepCompletedEvent;
+    'turn.step.interrupted': TurnStepInterruptedEvent;
+    'assistant.delta': AssistantDeltaEvent;
+    'thinking.delta': ThinkingDeltaEvent;
+    'tool.call.delta': ToolCallDeltaEvent;
+  }
+}
diff --git a/packages/agent-core-v2/src/agent/loop/turnOps.ts b/packages/agent-core-v2/src/agent/loop/turnOps.ts
index 8cad5371a..efe8ed982 100644
--- a/packages/agent-core-v2/src/agent/loop/turnOps.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnOps.ts
@@ -15,8 +15,8 @@
  * observed in a replayed loop event — the v1 `observeRestoredTurnId`
  * semantics. The `turn.started` / `turn.ended` / `error` signals are not part
  * of this Op set and remain on their existing path (published by the loop
- * service around a run). Consumed by the Agent-scope `loopService` and by the
- * `activity` kernel (which reads the next turn id on admission).
+ * service around a run). Consumed by the Agent-scope `loopService` (which
+ * reads the next turn id on admission).
  */
 
 import { z } from 'zod';
diff --git a/packages/agent-core-v2/src/agent/mcp/mcpService.ts b/packages/agent-core-v2/src/agent/mcp/mcpService.ts
index b70eaef2c..b4d13c00d 100644
--- a/packages/agent-core-v2/src/agent/mcp/mcpService.ts
+++ b/packages/agent-core-v2/src/agent/mcp/mcpService.ts
@@ -5,12 +5,8 @@ import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import type { Tool as KosongTool } from '#/app/llmProtocol/tool';
 
 import { Disposable, type IDisposable } from "#/_base/di/lifecycle";
+import type { KimiErrorPayload } from '#/_base/errors/serialize';
 import { ErrorCodes, makeErrorPayload } from "#/errors";
-import type {
-  ErrorEvent,
-  McpServerStatusEvent,
-  ToolListUpdatedEvent,
-} from '@moonshot-ai/protocol';
 import { IEventBus } from '#/app/event/eventBus';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { sessionMediaOriginalsDir } from '#/agent/media/image-originals';
@@ -24,14 +20,38 @@ import type { McpServerEntry } from './connection-manager';
 import { IAgentMcpService } from './mcp';
 import { qualifyMcpToolName } from './tool-naming';
 import type { MCPClient, MCPToolDefinition } from './types';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import {
   McpDiscoveryModel,
   mcpToolsDiscovered,
   type McpToolCollision,
 } from './mcpDiscoveryOps';
 
+export interface ErrorEvent extends KimiErrorPayload {
+  readonly type: 'error';
+}
+
+export interface McpServerStatusPayload {
+  readonly name: string;
+  readonly transport: 'stdio' | 'http' | 'sse';
+  readonly status: 'pending' | 'connected' | 'failed' | 'disabled' | 'needs-auth';
+  readonly toolCount: number;
+  readonly error?: string;
+}
+
+export interface McpServerStatusEvent {
+  readonly type: 'mcp.server.status';
+  readonly server: McpServerStatusPayload;
+}
+
+export type ToolListUpdatedReason = 'mcp.connected' | 'mcp.disconnected' | 'mcp.failed';
+
+export interface ToolListUpdatedEvent {
+  readonly type: 'tool.list.updated';
+  readonly reason: ToolListUpdatedReason;
+  readonly serverName: string;
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'mcp.server.status': McpServerStatusEvent;
@@ -58,7 +78,7 @@ export class AgentMcpService extends Disposable implements IAgentMcpService {
     @IAgentToolRegistryService private readonly registry: IAgentToolRegistryService,
     @IEventBus private readonly eventBus: IEventBus,
     @IAgentToolExecutorService toolExecutor: IAgentToolExecutorService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @ITelemetryService private readonly telemetry: ITelemetryService,
   ) {
     super();
@@ -72,8 +92,12 @@ export class AgentMcpService extends Disposable implements IAgentMcpService {
         },
       ),
     );
-    this._register(this.wire.onRestored(() => this.flushPendingDiscoveries()));
-    this._register(this.wire.onEmission(() => this.flushPendingDiscoveries()));
+    this._register(
+      this.wire.hooks.onDidRestore.register('mcp', async (_ctx, next) => {
+        this.flushPendingDiscoveries();
+        await next();
+      }),
+    );
   }
 
   get oauthService() {
diff --git a/packages/agent-core-v2/src/agent/mcp/tools/auth.ts b/packages/agent-core-v2/src/agent/mcp/tools/auth.ts
index f53d18f73..69df9c4e2 100644
--- a/packages/agent-core-v2/src/agent/mcp/tools/auth.ts
+++ b/packages/agent-core-v2/src/agent/mcp/tools/auth.ts
@@ -32,13 +32,20 @@ import {
   type ExecutableToolResult,
 } from '#/tool/toolContract';
 import { toInputJsonSchema } from '#/tool/input-schema';
-import {
-  MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE,
-  type McpOAuthAuthorizationUrlUpdateData,
-} from '@moonshot-ai/protocol';
 import { AlreadyAuthorizedError, type McpOAuthService } from '#/agent/mcp/oauth/service';
 import { qualifyMcpToolName } from '#/agent/mcp/tool-naming';
 
+/**
+ * `ToolUpdate.customKind` emitted by the MCP auth tool when the OAuth
+ * authorization URL is ready; clients render it as an actionable login link.
+ */
+export const MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE = 'mcp.oauth.authorization_url';
+
+export interface McpOAuthAuthorizationUrlUpdateData {
+  readonly serverName: string;
+  readonly authorizationUrl: string;
+}
+
 const DEFAULT_AUTH_TIMEOUT_MS = 15 * 60 * 1000;
 
 const AUTH_TOOL_TOOL_NAME = 'authenticate';
diff --git a/packages/agent-core-v2/src/agent/permissionGate/permissionGateService.ts b/packages/agent-core-v2/src/agent/permissionGate/permissionGateService.ts
index 59b1030b9..272a61819 100644
--- a/packages/agent-core-v2/src/agent/permissionGate/permissionGateService.ts
+++ b/packages/agent-core-v2/src/agent/permissionGate/permissionGateService.ts
@@ -23,7 +23,7 @@ import { IEventBus } from '#/app/event/eventBus';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { ISessionApprovalService } from "#/session/approval/approval";
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 import {
   IAgentPermissionGate,
 } from './permissionGate';
@@ -181,6 +181,7 @@ export class AgentPermissionGate extends Disposable implements IAgentPermissionG
           duration_ms: Date.now() - startedAt,
           session_cache_written: false,
           has_feedback: false,
+          trace_id: context.trace?.traceId,
         });
         this.eventBus.publish({
           type: 'permission.approval.resolved',
@@ -227,6 +228,7 @@ export class AgentPermissionGate extends Disposable implements IAgentPermissionG
       duration_ms: Date.now() - startedAt,
       session_cache_written: sessionApprovalRule !== undefined,
       has_feedback: response.feedback !== undefined && response.feedback.length > 0,
+      trace_id: context.trace?.traceId,
     });
 
     const resolved = result.resolveApproval?.(response);
diff --git a/packages/agent-core-v2/src/agent/permissionMode/permissionModeOps.ts b/packages/agent-core-v2/src/agent/permissionMode/permissionModeOps.ts
index d17fb9670..a55268a08 100644
--- a/packages/agent-core-v2/src/agent/permissionMode/permissionModeOps.ts
+++ b/packages/agent-core-v2/src/agent/permissionMode/permissionModeOps.ts
@@ -2,11 +2,10 @@
  * `permissionMode` domain (L3) — wire Model (`PermissionModeModel`) and the
  * `permission.set_mode` Op (`setMode`) for the agent's permission mode.
  *
- * Declares the mode as a scalar `wire` Model (initial `manual`) plus the single
- * Op that replaces it; `defineOp` registers the Op into the global registry at
- * import, so `wire.dispatch(setMode({ mode }))` mutates the model and
- * `wire.replay` rebuilds it from persisted records (skipping every other record
- * type). Consumed by the Agent-scope `permissionModeService`.
+ * Declares the mode as a scalar `wire` Model (initial `manual`) plus a replay
+ * marker that distinguishes an explicit persisted mode from the default. The
+ * single Op replaces the mode and sets that marker. Consumed by the Agent-scope
+ * `permissionModeService` and session bootstrap.
  */
 
 import { z } from 'zod';
@@ -15,6 +14,11 @@ import type { PermissionMode } from '#/agent/permissionPolicy/types';
 import { defineModel } from '#/wire/model';
 
 export const PermissionModeModel = defineModel<PermissionMode>('permissionMode', () => 'manual');
+export const PermissionModeConfiguredModel = defineModel<boolean>(
+  'permissionMode.configured',
+  () => false,
+  { reducers: { 'permission.set_mode': () => true } },
+);
 
 declare module '#/wire/types' {
   interface PersistedOpMap {
diff --git a/packages/agent-core-v2/src/agent/permissionMode/permissionModeService.ts b/packages/agent-core-v2/src/agent/permissionMode/permissionModeService.ts
index e6f5eee37..81f7acce7 100644
--- a/packages/agent-core-v2/src/agent/permissionMode/permissionModeService.ts
+++ b/packages/agent-core-v2/src/agent/permissionMode/permissionModeService.ts
@@ -4,9 +4,9 @@
  * Holds the agent's permission mode (`manual` / `auto`) in the `wire`
  * `PermissionModeModel`, mutating it only through the `permission.set_mode` Op
  * (`wire.dispatch(setMode({ mode }))`) and reading it through `wire.getModel`.
- * The `onDidChangeMode` event is driven by a `wire.subscribe` on that model
- * (firing only on actual changes), and mode-aware reminders are registered
- * through the permission-mode injection helper. Bound at Agent scope.
+ * `setMode` emits `onDidChangeMode` after an actual change, and mode-aware
+ * reminders are registered through the permission-mode injection helper. Bound
+ * at Agent scope.
  */
 
 import type { PermissionMode } from '#/agent/permissionPolicy/types';
@@ -16,10 +16,13 @@ import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { Emitter, type Event } from '#/_base/event';
 import { PermissionModeInjection } from '#/agent/permissionMode/injection/permissionModeInjection';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import { IAgentPermissionModeService, type PermissionModeChangedContext } from './permissionMode';
-import { PermissionModeModel, setMode } from './permissionModeOps';
+import {
+  PermissionModeConfiguredModel,
+  PermissionModeModel,
+  setMode,
+} from './permissionModeOps';
 
 export class AgentPermissionModeService extends Disposable implements IAgentPermissionModeService {
   declare readonly _serviceBrand: undefined;
@@ -28,16 +31,10 @@ export class AgentPermissionModeService extends Disposable implements IAgentPerm
   readonly onDidChangeMode: Event<PermissionModeChangedContext> = this._onDidChangeMode.event;
 
   constructor(
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IInstantiationService instantiation: IInstantiationService,
   ) {
     super();
-    this._register(
-      wire.subscribe(PermissionModeModel, (mode, previousMode) => {
-        if (mode === previousMode) return;
-        this._onDidChangeMode.fire({ mode, previousMode });
-      }),
-    );
     this._register(instantiation.createInstance(PermissionModeInjection, this));
   }
 
@@ -46,7 +43,11 @@ export class AgentPermissionModeService extends Disposable implements IAgentPerm
   }
 
   setMode(mode: PermissionMode): void {
+    const previousMode = this.mode;
+    const changed = mode !== previousMode;
+    if (!changed && this.wire.getModel(PermissionModeConfiguredModel)) return;
     this.wire.dispatch(setMode({ mode }));
+    if (changed) this._onDidChangeMode.fire({ mode, previousMode });
   }
 }
 
diff --git a/packages/agent-core-v2/src/agent/permissionPolicy/types.ts b/packages/agent-core-v2/src/agent/permissionPolicy/types.ts
index a1a8d6441..db2beb626 100644
--- a/packages/agent-core-v2/src/agent/permissionPolicy/types.ts
+++ b/packages/agent-core-v2/src/agent/permissionPolicy/types.ts
@@ -1,5 +1,5 @@
 import type { PrepareToolExecutionResult, ResolvedToolExecutionHookContext } from '#/agent/toolExecutor/toolHooks';
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 import type { PermissionRule } from '#/agent/permissionRules/permissionRules';
 
 export type PermissionMode = 'manual' | 'yolo' | 'auto';
diff --git a/packages/agent-core-v2/src/agent/permissionRules/permissionRules.ts b/packages/agent-core-v2/src/agent/permissionRules/permissionRules.ts
index 92ad3240a..fe640a14c 100644
--- a/packages/agent-core-v2/src/agent/permissionRules/permissionRules.ts
+++ b/packages/agent-core-v2/src/agent/permissionRules/permissionRules.ts
@@ -1,5 +1,5 @@
 import { createDecorator } from "#/_base/di/instantiation";
-import type { ApprovalResponse } from "@moonshot-ai/protocol";
+import type { ApprovalResponse } from "#/session/approval/approval";
 
 export interface PermissionApprovalResultRecord {
   readonly turnId: number;
diff --git a/packages/agent-core-v2/src/agent/permissionRules/permissionRulesService.ts b/packages/agent-core-v2/src/agent/permissionRules/permissionRulesService.ts
index 2a2fdcd2d..16caea70f 100644
--- a/packages/agent-core-v2/src/agent/permissionRules/permissionRulesService.ts
+++ b/packages/agent-core-v2/src/agent/permissionRules/permissionRulesService.ts
@@ -11,8 +11,7 @@
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import {
   IAgentPermissionRulesService,
   type PermissionApprovalResultRecord,
@@ -27,7 +26,7 @@ import {
 export class AgentPermissionRulesService implements IAgentPermissionRulesService {
   declare readonly _serviceBrand: undefined;
 
-  constructor(@IAgentWireService private readonly wire: IWireService) {}
+  constructor(@IWireService private readonly wire: IWireService) {}
 
   get rules(): readonly PermissionRule[] {
     return [...this.wire.getModel(PermissionRulesModel).rules];
diff --git a/packages/agent-core-v2/src/agent/plan/planService.ts b/packages/agent-core-v2/src/agent/plan/planService.ts
index ff3a4ecc6..9c63cec35 100644
--- a/packages/agent-core-v2/src/agent/plan/planService.ts
+++ b/packages/agent-core-v2/src/agent/plan/planService.ts
@@ -21,8 +21,7 @@ import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import { IAgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContext';
 import { IHostFileSystem } from '#/os/interface/hostFileSystem';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import {
   IAgentPlanService,
   type PlanData,
@@ -43,13 +42,18 @@ export class AgentPlanService extends Disposable implements IAgentPlanService {
     @IHostFileSystem private readonly hostFs: IHostFileSystem,
     @IAgentContextInjectorService dynamicInjector: IAgentContextInjectorService,
     @IAgentTelemetryContextService private readonly telemetryContext: IAgentTelemetryContextService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @ISessionContext private readonly sessionCtx: ISessionContext,
     @IAgentScopeContext private readonly agentCtx: IAgentScopeContext,
   ) {
     super();
 
-    this._register(this.wire.onRestored(() => this.restoreTelemetryMode()));
+    this._register(
+      this.wire.hooks.onDidRestore.register('plan', async (_ctx, next) => {
+        this.restoreTelemetryMode();
+        await next();
+      }),
+    );
 
     this._register(new PlanModeInjection(dynamicInjector, this, this.context));
   }
diff --git a/packages/agent-core-v2/src/agent/plan/tools/exit-plan-mode.ts b/packages/agent-core-v2/src/agent/plan/tools/exit-plan-mode.ts
index a4484132b..34810c5fe 100644
--- a/packages/agent-core-v2/src/agent/plan/tools/exit-plan-mode.ts
+++ b/packages/agent-core-v2/src/agent/plan/tools/exit-plan-mode.ts
@@ -15,7 +15,7 @@
  * keeps the user-approved output and the `approved` outcome.
  */
 
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 import { z } from 'zod';
 
 import type { BuiltinTool, ExecutableToolResult, ToolExecution } from '#/tool/toolContract';
diff --git a/packages/agent-core-v2/src/agent/profile/profile.ts b/packages/agent-core-v2/src/agent/profile/profile.ts
index 5a5f32985..10aac3a64 100644
--- a/packages/agent-core-v2/src/agent/profile/profile.ts
+++ b/packages/agent-core-v2/src/agent/profile/profile.ts
@@ -4,7 +4,7 @@ import type { ThinkingEffort } from '#/app/llmProtocol/thinkingEffort';
 import type { Model } from '#/app/model/modelInstance';
 
 import { createDecorator } from "#/_base/di/instantiation";
-import type { ErrorCode } from '#/_base/errors/codes';
+import type { ErrorCode } from '#/errors';
 import { Error2 } from '#/_base/errors/errors';
 import type { ToolSource } from '#/tool/toolContract';
 import type { Hooks } from '#/hooks';
diff --git a/packages/agent-core-v2/src/agent/profile/profileService.ts b/packages/agent-core-v2/src/agent/profile/profileService.ts
index 574425c1b..be62ee738 100644
--- a/packages/agent-core-v2/src/agent/profile/profileService.ts
+++ b/packages/agent-core-v2/src/agent/profile/profileService.ts
@@ -59,12 +59,10 @@ import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceCo
 import { ISessionSkillCatalog } from '#/session/sessionSkillCatalog/skillCatalog';
 import type { ResolvedAgentProfile, SystemPromptContext } from '#/agent/profile/profile';
 
-import type { WarningEvent } from '@moonshot-ai/protocol';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { IAgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContext';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 import type { PayloadOf } from '#/wire/types';
-import type { IWireService } from '#/wire/wireService';
 import { IEventBus } from '#/app/event/eventBus';
 import { prepareSystemPromptContext } from './context';
 import type {
@@ -90,6 +88,12 @@ import {
   type ProfileModelState,
 } from './profileOps';
 
+export interface WarningEvent {
+  readonly type: 'warning';
+  readonly message: string;
+  readonly code?: string;
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     warning: WarningEvent;
@@ -108,6 +112,7 @@ export class AgentProfileService implements IAgentProfileService {
   // by model alias: an overflow proves the real window smaller than the
   // catalogued capability, so the effective max clamps down to it.
   private readonly observedMaxContextTokensByModel = new Map<string, number>();
+  private readonly emittedThinkingEffortWarnings = new Set<string>();
 
   private get activeToolNames(): ActiveToolsState {
     return (
@@ -119,7 +124,7 @@ export class AgentProfileService implements IAgentProfileService {
   private activeProfile: ResolvedAgentProfile | undefined;
 
   constructor(
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
     @ITelemetryService private readonly telemetry: ITelemetryService,
     @IAgentTelemetryContextService private readonly telemetryContext: IAgentTelemetryContextService,
@@ -457,11 +462,44 @@ export class AgentProfileService implements IAgentProfileService {
       const protocol = this.tryResolveRawModel()?.protocol;
       this.telemetryContext.set({ provider_type: protocol, protocol });
     }
+    if (changed.modelAlias !== undefined || changed.thinkingLevel !== undefined) {
+      this.warnAboutAnthropicThinkingEffort();
+    }
     this.emitStatusUpdated(
       changed.modelAlias !== undefined || changed.thinkingLevel !== undefined,
     );
   }
 
+  private warnAboutAnthropicThinkingEffort(): void {
+    try {
+      const model = this.tryResolveRawModel();
+      if (model?.protocol !== 'anthropic') return;
+      const effort = this.getEffectiveThinkingLevel();
+      if (effort === 'on') return;
+
+      let code: string;
+      let message: string;
+      let knownEfforts = '';
+      if (effort === 'off') {
+        if (!model.alwaysThinking) return;
+        code = 'anthropic-thinking-cannot-disable';
+        message = `Model "${model.name}" declares always-on thinking. The configured effort "off" will be sent unchanged to the Anthropic-compatible backend.`;
+      } else {
+        const efforts = model.supportEfforts?.filter((value) => value.length > 0);
+        if (efforts === undefined || efforts.length === 0 || efforts.includes(effort)) return;
+        knownEfforts = efforts.join(',');
+        code = 'anthropic-thinking-effort-not-listed';
+        message = `Thinking effort "${effort}" is not listed for model "${model.name}" (known: ${efforts.join(', ')}). The configured value will be sent unchanged to the Anthropic-compatible backend.`;
+      }
+
+      const key = [code, model.id, model.name, effort, knownEfforts].join('\u0000');
+      if (this.emittedThinkingEffortWarnings.has(key)) return;
+      this.emittedThinkingEffortWarnings.add(key);
+      this.eventBus.publish({ type: 'warning', code, message });
+    } catch {
+    }
+  }
+
   private setActiveTools(names: readonly string[]): void {
     this.activeToolNamesOverlay = undefined;
     this.wire.dispatch(setActiveTools({ names: [...names] }));
diff --git a/packages/agent-core-v2/src/agent/profile/thinking.ts b/packages/agent-core-v2/src/agent/profile/thinking.ts
index 0cf9066b4..4cb39e506 100644
--- a/packages/agent-core-v2/src/agent/profile/thinking.ts
+++ b/packages/agent-core-v2/src/agent/profile/thinking.ts
@@ -15,21 +15,28 @@ import {
 
 import type { ThinkingConfig } from './configSection';
 
-type ThinkingModel = ModelThinkingMetadata & { readonly providerType?: string };
+type ThinkingModel = ModelThinkingMetadata & {
+  readonly protocol?: string;
+  readonly providerType?: string;
+};
+
+function usesKimiThinkingSemantics(model: ThinkingModel | undefined): boolean {
+  return model?.protocol === 'kimi';
+}
 
 export function resolveThinkingEffort(
   requested: string | undefined,
   defaults: ThinkingConfig | undefined,
   model?: ThinkingModel,
 ): ThinkingEffort {
-  return resolveThinkingEffortForModel(requested, defaults, model, model?.providerType === 'kimi');
+  return resolveThinkingEffortForModel(requested, defaults, model, usesKimiThinkingSemantics(model));
 }
 
 export function supportsThinkingEffort(
   effort: ThinkingEffort,
   model: ThinkingModel | undefined,
 ): boolean {
-  return modelSupportsThinkingEffort(effort, model, model?.providerType === 'kimi');
+  return modelSupportsThinkingEffort(effort, model, usesKimiThinkingSemantics(model));
 }
 
 const KEEP_OFF_VALUES = new Set(['0', 'false', 'no', 'off', 'none', 'null']);
diff --git a/packages/agent-core-v2/src/agent/prompt/promptService.ts b/packages/agent-core-v2/src/agent/prompt/promptService.ts
index 3c0ed743b..52d70fe68 100644
--- a/packages/agent-core-v2/src/agent/prompt/promptService.ts
+++ b/packages/agent-core-v2/src/agent/prompt/promptService.ts
@@ -27,8 +27,7 @@ import type { ContentPart } from '#/app/llmProtocol/message';
 import { IEventBus } from '#/app/event/eventBus';
 import { ErrorCodes, Error2 } from '#/errors';
 import { OrderedHookSlot } from '#/hooks';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 
 import {
   IAgentPromptService,
@@ -73,7 +72,7 @@ export class AgentPromptService implements IAgentPromptService {
     @IInstantiationService private readonly instantiation: IInstantiationService,
     @IAgentLoopService private readonly loop: IAgentLoopService,
     @IAgentToolExecutorService toolExecutor: IAgentToolExecutorService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
   ) {
     toolExecutor.hooks.onDidExecuteTool.register('prompt-service-delivery', async (ctx, next) => {
diff --git a/packages/agent-core-v2/src/agent/questionTools/tools/ask-user.ts b/packages/agent-core-v2/src/agent/questionTools/tools/ask-user.ts
index bdc67f6ca..dfb62d085 100644
--- a/packages/agent-core-v2/src/agent/questionTools/tools/ask-user.ts
+++ b/packages/agent-core-v2/src/agent/questionTools/tools/ask-user.ts
@@ -15,7 +15,7 @@ import { toInputJsonSchema } from '#/tool/input-schema';
 import { isAbortError } from '#/_base/utils/abort';
 import { IAgentTaskService } from '#/agent/task/task';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
-import type { QuestionAnsweredEvent } from '#/app/telemetry/events';
+import type { QuestionAnsweredEvent, QuestionDismissedEvent } from '#/app/telemetry/events';
 import type {
   BuiltinTool,
   ExecutableToolContext,
@@ -153,7 +153,7 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
 
   private async execution(
     args: AskUserQuestionInput,
-    { toolCallId, signal, turnId }: ExecutableToolContext,
+    { toolCallId, signal, turnId, trace }: ExecutableToolContext,
   ): Promise<ExecutableToolResult> {
     const uniquenessError = questionUniquenessError(args.questions);
     if (uniquenessError !== null) {
@@ -161,10 +161,10 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
     }
 
     if (args.background === true) {
-      return this.executeInBackground(args, { toolCallId, turnId, signal });
+      return this.executeInBackground(args, { toolCallId, turnId, signal, trace });
     }
 
-    return this.executeQuestion(args, { toolCallId, turnId, signal });
+    return this.executeQuestion(args, { toolCallId, turnId, signal, trace });
   }
 
   private inputSchema(): z.ZodType<AskUserQuestionInput> {
@@ -177,7 +177,8 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
       toolCallId,
       signal,
       turnId,
-    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'turnId'>,
+      trace,
+    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'turnId' | 'trace'>,
   ): ExecutableToolResult {
     if (signal.aborted) {
       signal.throwIfAborted();
@@ -188,7 +189,7 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
     try {
       taskId = this.tasks.registerTask(
         new QuestionBackgroundTask(
-          (taskSignal) => this.executeQuestion(args, { toolCallId, turnId, signal: taskSignal }),
+          (taskSignal) => this.executeQuestion(args, { toolCallId, turnId, signal: taskSignal, trace }),
           description,
           { questionCount: args.questions.length, toolCallId },
         ),
@@ -213,7 +214,6 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
         'next_step: Use TaskOutput with this task_id for a non-blocking status/answer snapshot.\n' +
         'next_step: Use TaskStop only if the question should be cancelled.\n' +
         'human_shell_hint: The pending question is also visible in /tasks.',
-      message: `Started ${taskId}`,
     };
   }
 
@@ -223,7 +223,8 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
       toolCallId,
       signal,
       turnId,
-    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'turnId'>,
+      trace,
+    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'turnId' | 'trace'>,
   ): Promise<ExecutableToolResult> {
     try {
       const result = await this.question.request(
@@ -245,11 +246,17 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
 
       const normalized = normalizeQuestionResult(result);
       if (normalized === null || Object.keys(normalized.answers).length === 0) {
-        this.telemetry.track2('question_dismissed');
+        const properties: QuestionDismissedEvent = {
+          trace_id: trace?.traceId,
+        };
+        this.telemetry.track2('question_dismissed', properties);
         return dismissedQuestionResult();
       }
 
-      const properties: QuestionAnsweredEvent = { answered: Object.keys(normalized.answers).length };
+      const properties: QuestionAnsweredEvent = {
+        answered: Object.keys(normalized.answers).length,
+        trace_id: trace?.traceId,
+      };
       if (normalized.method !== undefined) properties.method = normalized.method;
       this.telemetry.track2('question_answered', properties);
       return {
diff --git a/packages/agent-core-v2/src/agent/replayBuilder/agentReplayService.ts b/packages/agent-core-v2/src/agent/replayBuilder/agentReplayService.ts
deleted file mode 100644
index a7f5531f1..000000000
--- a/packages/agent-core-v2/src/agent/replayBuilder/agentReplayService.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * `replayBuilder` domain — `IAgentReplayService`, the agent-scope owner of
- * the `ReplayTimelineModel` derived-model attachment.
- *
- * A derived model only folds Ops that pass through the wire *after* it is
- * attached (`IWireService.attach` starts from `initial`), so the attach must
- * land before session resume replays the persisted wire log — otherwise a
- * resumed session's timeline stays empty and the TUI cannot rehydrate screen
- * history. This service is force-instantiated from
- * `IAgentLifecycleService.create` (with the other Eager agent services),
- * which runs before `sessionLifecycleService` replays records on
- * resume/fork, and before any live dispatch on fresh sessions.
- */
-
-import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-import { InstantiationType } from '#/_base/di/extensions';
-import { Disposable } from '#/_base/di/lifecycle';
-import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { IAgentWireService } from '#/wire/tokens';
-import { type IWireService } from '#/wire/wireService';
-
-import { ReplayTimelineModel, type ReplayTimeline } from './replayTimelineModel';
-import { projectReplayTimeline } from './replayProjection';
-import type { AgentReplayRecord } from './types';
-
-export interface IAgentReplayService {
-  readonly _serviceBrand: undefined;
-
-  /** The op-native folded timeline (raw form). */
-  getReplayTimeline(): ReplayTimeline;
-
-  /** v1-shaped replay DTO records for SDK/TUI resume hydration. */
-  getReplayRecords(): readonly AgentReplayRecord[];
-}
-
-export const IAgentReplayService: ServiceIdentifier<IAgentReplayService> =
-  createDecorator<IAgentReplayService>('agentReplayService');
-
-export class AgentReplayService extends Disposable implements IAgentReplayService {
-  declare readonly _serviceBrand: undefined;
-
-  constructor(@IAgentWireService private readonly wire: IWireService) {
-    super();
-    this._register(this.wire.attach(ReplayTimelineModel));
-  }
-
-  getReplayTimeline(): ReplayTimeline {
-    return this.wire.getModel(ReplayTimelineModel) as ReplayTimeline;
-  }
-
-  getReplayRecords(): readonly AgentReplayRecord[] {
-    return projectReplayTimeline(this.getReplayTimeline());
-  }
-}
-
-registerScopedService(
-  LifecycleScope.Agent,
-  IAgentReplayService,
-  AgentReplayService,
-  InstantiationType.Eager,
-  'replayBuilder',
-);
diff --git a/packages/agent-core-v2/src/agent/replayBuilder/replayProjection.ts b/packages/agent-core-v2/src/agent/replayBuilder/replayProjection.ts
deleted file mode 100644
index 88f98b934..000000000
--- a/packages/agent-core-v2/src/agent/replayBuilder/replayProjection.ts
+++ /dev/null
@@ -1,348 +0,0 @@
-/**
- * `replayBuilder` domain — read-time projection from the op-native
- * `ReplayTimeline` into the v1-shaped `AgentReplayRecord` DTO the SDK/TUI
- * hydrates resumed sessions from (`ResumedAgentState.replay`).
- *
- * The timeline stores `{ type, payload }` entries reduced from wire Ops; this
- * projection mirrors the push decisions v1's `ReplayBuilder` made at restore
- * time (packages/agent-core `agent/replay/index.ts` and its domain push sites):
- *
- * - `context.append_message`           → `message`; deferred while a tool
- *   exchange is open and flushed once it closes (v1 deferral parity)
- * - `context.append_loop_event`        → folded into `message` records the
- *   way the live context folds a turn: one assistant `message` per step
- *   (emitted when the step closes), one tool `message` per `tool.result`.
- *   A trailing exchange left open by an interrupted session — or a gap
- *   mid-history — is closed with synthetic interrupted tool results (v1
- *   `finishResume` / step-boundary parity). Fold semantics mirror
- *   `reduceContextTranscript` in `contextMemory`.
- * - `context.apply_compaction`         → `compaction` carrying the durable
- *   result (summary + token counts live on this op's payload in v2); also
- *   resets the loop-event fold bookkeeping the way live `resetFold` does —
- *   pending calls and deferred messages are forgotten, while the open step's
- *   assistant keeps buffering (the partial assistant survives in live state)
- * - `full_compaction.begin`            → `compaction` with instruction only
- *   (v1 pushes the same at restore; the TUI skips result-less records)
- * - `full_compaction.cancel`           → `compaction` with result 'cancelled'
- * - `full_compaction.complete`         → nothing (empty payload; the visible
- *   result already came from `context.apply_compaction`)
- * - `goal.create` / `goal.update`      → `goal_updated`; goal state is folded
- *   per record so each snapshot reflects that point in the timeline, and
- *   counter-only updates are skipped like v1 (`restoreUpdate` returns early
- *   when no status is present)
- * - `goal.clear`                       → nothing (v1 pushes no record)
- * - `plan_mode.enter` / cancel / exit  → `plan_updated`
- * - `config.update`                    → `config_updated`
- * - `permission.set_mode`              → `permission_updated`
- * - `permission.record_approval_result`→ `approval_result`
- *
- * Timeline entries carry no record time (the derived model reduces op
- * payloads, not persisted records), and no consumer reads
- * `AgentReplayRecord.time`, so every record stamps `0`.
- */
-
-import {
-  createToolMessage,
-  type ContentPart,
-  type ToolCall,
-} from '#/app/llmProtocol/message';
-import { contextApplyCompaction } from '#/agent/contextMemory/contextOps';
-import { TOOL_INTERRUPTED_ON_RESUME_OUTPUT } from '#/agent/contextMemory/loopEventFold';
-import type { ContextMessage } from '#/agent/contextMemory/types';
-import type { CompactionResult } from '#/agent/fullCompaction/types';
-import { type GoalState, updateGoal } from '#/agent/goal/goalOps';
-import type {
-  GoalBudgetLimits,
-  GoalBudgetReport,
-  GoalChange,
-  GoalSnapshot,
-} from '#/agent/goal/types';
-import type { PayloadOf } from '#/wire/types';
-
-import type { ReplayTimeline } from './replayTimelineModel';
-import type { AgentReplayRecord } from './types';
-
-const NO_TIME = 0;
-
-export function projectReplayTimeline(timeline: ReplayTimeline): readonly AgentReplayRecord[] {
-  const records: AgentReplayRecord[] = [];
-  let goal: GoalState | null = null;
-
-  let openAssistant: { content: ContentPart[]; toolCalls: ToolCall[] } | null = null;
-  const pendingToolCallIds = new Set<string>();
-  let deferredMessages: ContextMessage[] = [];
-
-  const pushMessage = (message: ContextMessage): void => {
-    records.push({ time: NO_TIME, type: 'message', message });
-  };
-  const flushDeferred = (): void => {
-    if (pendingToolCallIds.size > 0 || deferredMessages.length === 0) return;
-    for (const message of deferredMessages) pushMessage(message);
-    deferredMessages = [];
-  };
-  const closeOpenAssistant = (): void => {
-    if (openAssistant === null) return;
-    pushMessage({
-      role: 'assistant',
-      content: openAssistant.content,
-      toolCalls: openAssistant.toolCalls,
-    });
-    openAssistant = null;
-  };
-  const closePendingAsInterrupted = (): void => {
-    for (const toolCallId of pendingToolCallIds) {
-      pushMessage({
-        ...createToolMessage(toolCallId, TOOL_INTERRUPTED_ON_RESUME_OUTPUT),
-        isError: true,
-      });
-    }
-    pendingToolCallIds.clear();
-  };
-  const resetLoopFold = (): void => {
-    pendingToolCallIds.clear();
-    deferredMessages = [];
-  };
-
-  for (const entry of timeline) {
-    switch (entry.type) {
-      case 'context.append_message':
-        if (pendingToolCallIds.size > 0) {
-          deferredMessages.push(entry.payload.message);
-        } else {
-          pushMessage(entry.payload.message);
-        }
-        break;
-      case 'context.append_loop_event': {
-        const event = entry.payload.event;
-        switch (event.type) {
-          case 'step.begin':
-            closeOpenAssistant();
-            closePendingAsInterrupted();
-            flushDeferred();
-            openAssistant = { content: [], toolCalls: [] };
-            break;
-          case 'content.part':
-            openAssistant?.content.push(event.part);
-            break;
-          case 'tool.call': {
-            const call: ToolCall = {
-              type: 'function',
-              id: event.toolCallId,
-              name: event.name,
-              arguments: event.args === undefined ? null : JSON.stringify(event.args),
-              extras: event.extras,
-            };
-            pendingToolCallIds.add(event.toolCallId);
-            openAssistant?.toolCalls.push(call);
-            break;
-          }
-          case 'tool.result':
-            if (pendingToolCallIds.has(event.toolCallId)) {
-              pendingToolCallIds.delete(event.toolCallId);
-              const output = event.result.output;
-              pushMessage({
-                ...createToolMessage(
-                  event.toolCallId,
-                  typeof output === 'string' ? output : [...output],
-                ),
-                isError: event.result.isError,
-                note: event.result.note,
-              });
-              flushDeferred();
-            }
-            break;
-          case 'step.end':
-            closeOpenAssistant();
-            flushDeferred();
-            break;
-        }
-        break;
-      }
-      case 'context.apply_compaction': {
-        resetLoopFold();
-        const payload = entry.payload;
-        const result: CompactionResult = {
-          summary: compactionSummary(payload),
-          contextSummary: 'contextSummary' in payload ? payload.contextSummary : undefined,
-          compactedCount: payload.compactedCount ?? 0,
-          tokensBefore: payload.tokensBefore ?? 0,
-          tokensAfter: payload.tokensAfter ?? 0,
-          keptUserMessageCount: payload.keptUserMessageCount,
-          keptHeadUserMessageCount: payload.keptHeadUserMessageCount,
-          droppedCount: payload.droppedCount,
-        };
-        records.push({ time: NO_TIME, type: 'compaction', result });
-        break;
-      }
-      case 'full_compaction.begin':
-        records.push({ time: NO_TIME, type: 'compaction', instruction: entry.payload.instruction });
-        break;
-      case 'full_compaction.cancel':
-        records.push({ time: NO_TIME, type: 'compaction', result: 'cancelled' });
-        break;
-      case 'full_compaction.complete':
-        break;
-      case 'goal.create':
-        goal = {
-          goalId: entry.payload.goalId,
-          objective: entry.payload.objective,
-          completionCriterion: entry.payload.completionCriterion,
-          status: 'active',
-          turnsUsed: 0,
-          tokensUsed: 0,
-          wallClockMs: 0,
-          budgetLimits: {},
-        };
-        records.push({
-          time: NO_TIME,
-          type: 'goal_updated',
-          snapshot: goalSnapshot(goal),
-          change: { kind: 'created' },
-        });
-        break;
-      case 'goal.update': {
-        if (goal === null) break;
-        const payload = entry.payload;
-        const statusChanged = payload.status !== undefined && payload.status !== goal.status;
-        goal = applyGoalUpdate(goal, payload);
-        // v1 parity: `restoreUpdate` only pushes a replay record when the
-        // update carries a status transition; pure counter bumps are not
-        // transcript events.
-        if (!statusChanged) break;
-        const change: GoalChange =
-          payload.status === 'complete'
-            ? {
-                kind: 'completion',
-                status: payload.status,
-                reason: payload.reason,
-                stats: {
-                  turnsUsed: goal.turnsUsed,
-                  tokensUsed: goal.tokensUsed,
-                  wallClockMs: goal.wallClockMs,
-                },
-                actor: payload.actor,
-              }
-            : { kind: 'lifecycle', status: payload.status, reason: payload.reason, actor: payload.actor };
-        records.push({
-          time: NO_TIME,
-          type: 'goal_updated',
-          snapshot: goalSnapshot(goal),
-          change,
-        });
-        break;
-      }
-      case 'goal.clear':
-        goal = null;
-        break;
-      case 'plan_mode.enter':
-        records.push({ time: NO_TIME, type: 'plan_updated', enabled: true });
-        break;
-      case 'plan_mode.cancel':
-      case 'plan_mode.exit':
-        records.push({ time: NO_TIME, type: 'plan_updated', enabled: false });
-        break;
-      case 'config.update': {
-        const payload = entry.payload;
-        records.push({
-          time: NO_TIME,
-          type: 'config_updated',
-          config: {
-            cwd: payload.cwd,
-            modelAlias: payload.modelAlias,
-            profileName: payload.profileName,
-            thinkingLevel: payload.thinkingLevel ?? payload.thinkingEffort,
-            systemPrompt: payload.systemPrompt,
-          },
-        });
-        break;
-      }
-      case 'permission.set_mode':
-        records.push({ time: NO_TIME, type: 'permission_updated', mode: entry.payload.mode });
-        break;
-      case 'permission.record_approval_result':
-        records.push({ time: NO_TIME, type: 'approval_result', record: entry.payload });
-        break;
-    }
-  }
-  closeOpenAssistant();
-  closePendingAsInterrupted();
-  flushDeferred();
-  return records;
-}
-
-/** Mirror of `goalOps` `updateGoal.apply` so per-record snapshots track the timeline. */
-function applyGoalUpdate(state: GoalState, payload: PayloadOf<typeof updateGoal>): GoalState {
-  let next = state;
-  if (payload.status !== undefined && payload.status !== state.status) {
-    next = {
-      ...next,
-      status: payload.status,
-      terminalReason: payload.status === 'active' ? undefined : payload.reason,
-    };
-  }
-  if (payload.turnsUsed !== undefined && payload.turnsUsed !== next.turnsUsed) {
-    next = { ...next, turnsUsed: payload.turnsUsed };
-  }
-  if (payload.tokensUsed !== undefined && payload.tokensUsed !== next.tokensUsed) {
-    next = { ...next, tokensUsed: payload.tokensUsed };
-  }
-  if (payload.wallClockMs !== undefined && payload.wallClockMs !== next.wallClockMs) {
-    next = { ...next, wallClockMs: payload.wallClockMs };
-  }
-  if (payload.budgetLimits !== undefined && payload.budgetLimits !== next.budgetLimits) {
-    next = { ...next, budgetLimits: payload.budgetLimits };
-  }
-  return next;
-}
-
-function goalSnapshot(state: GoalState): GoalSnapshot {
-  return {
-    goalId: state.goalId,
-    objective: state.objective,
-    completionCriterion: state.completionCriterion,
-    status: state.status,
-    turnsUsed: state.turnsUsed,
-    tokensUsed: state.tokensUsed,
-    wallClockMs: state.wallClockMs,
-    budget: budgetReport(state.budgetLimits, state),
-    terminalReason: state.terminalReason,
-  };
-}
-
-function budgetReport(
-  limits: GoalBudgetLimits,
-  used: { readonly turnsUsed: number; readonly tokensUsed: number; readonly wallClockMs: number },
-): GoalBudgetReport {
-  const tokenBudget = limits.tokenBudget ?? null;
-  const turnBudget = limits.turnBudget ?? null;
-  const wallClockBudgetMs = limits.wallClockBudgetMs ?? null;
-  const tokenBudgetReached = tokenBudget !== null && used.tokensUsed >= tokenBudget;
-  const turnBudgetReached = turnBudget !== null && used.turnsUsed >= turnBudget;
-  const wallClockBudgetReached = wallClockBudgetMs !== null && used.wallClockMs >= wallClockBudgetMs;
-  return {
-    tokenBudget,
-    turnBudget,
-    wallClockBudgetMs,
-    remainingTokens: tokenBudget === null ? null : Math.max(0, tokenBudget - used.tokensUsed),
-    remainingTurns: turnBudget === null ? null : Math.max(0, turnBudget - used.turnsUsed),
-    remainingWallClockMs:
-      wallClockBudgetMs === null ? null : Math.max(0, wallClockBudgetMs - used.wallClockMs),
-    tokenBudgetReached,
-    turnBudgetReached,
-    wallClockBudgetReached,
-    overBudget: tokenBudgetReached || turnBudgetReached || wallClockBudgetReached,
-  };
-}
-
-function compactionSummary(payload: PayloadOf<typeof contextApplyCompaction>): string {
-  if (typeof payload.summary === 'string') return payload.summary;
-  if ('contextSummary' in payload && typeof payload.contextSummary === 'string') {
-    return payload.contextSummary;
-  }
-  // Legacy v1 records stored the literal summary ContextMessage the model saw.
-  const message = payload.summary as ContextMessage | undefined;
-  if (message !== undefined && Array.isArray(message.content)) {
-    return message.content.map((part) => (part?.type === 'text' ? part.text : '')).join('');
-  }
-  return '';
-}
diff --git a/packages/agent-core-v2/src/agent/replayBuilder/replayTimelineModel.ts b/packages/agent-core-v2/src/agent/replayBuilder/replayTimelineModel.ts
deleted file mode 100644
index 5a7458243..000000000
--- a/packages/agent-core-v2/src/agent/replayBuilder/replayTimelineModel.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * `replayBuilder` domain — `ReplayTimelineModel`, a derived wire model that
- * folds heterogeneous Ops from multiple domains into a single ordered timeline.
- *
- * This is the v2 replacement for v1's imperative `ReplayBuilder` class: instead
- * of each domain service pushing records into a mutable accumulator, the model
- * declares which Op types it reduces and the wire engine folds them
- * automatically — during both `replay` (silent) and `dispatch` (live).
- *
- * The timeline entries are op-native: they carry the raw op payloads, not the
- * v1 `AgentReplayRecordPayload` DTO shape. The projection to the SDK/edge DTO
- * (e.g. computing `GoalSnapshot` from `GoalState`) is a read-time concern, not
- * a reduce-time concern.
- */
-
-import {
-  contextAppendLoopEvent,
-  contextAppendMessage,
-  contextApplyCompaction,
-} from '#/agent/contextMemory/contextOps';
-import {
-  fullCompactionBegin,
-  fullCompactionCancel,
-  fullCompactionComplete,
-} from '#/agent/fullCompaction/compactionOps';
-import { clearGoal, createGoal, updateGoal } from '#/agent/goal/goalOps';
-import { planModeCancel, planModeEnter, planModeExit } from '#/agent/plan/planOps';
-import { configUpdate } from '#/agent/profile/profileOps';
-import type { PermissionMode } from '#/agent/permissionPolicy/types';
-import { setMode } from '#/agent/permissionMode/permissionModeOps';
-import type { PermissionApprovalResultRecord } from '#/agent/permissionRules/permissionRules';
-import { recordApprovalResult } from '#/agent/permissionRules/permissionRulesOps';
-import { type DerivedModelDef, defineDerivedModel } from '#/wire/model';
-import type { ModelReducers, OpPayload, OpType, PayloadOf } from '#/wire/types';
-
-type TimelineMapperMap = {
-  [K in OpType]?: (payload: OpPayload<K>) => unknown;
-};
-
-type TimelineEntry<M> = {
-  [K in keyof M]: M[K] extends (...args: never[]) => infer E ? E : never;
-}[keyof M];
-
-type ErasedTimelineMapper<E> = (payload: unknown) => E;
-
-function defineDerivedTimeline<const M extends TimelineMapperMap>(
-  name: string,
-  mappers: M & Record<Exclude<keyof M, OpType>, never>,
-): DerivedModelDef<readonly TimelineEntry<M>[]> {
-  type E = TimelineEntry<M>;
-  const entries = Object.entries(mappers) as [OpType, ErasedTimelineMapper<E>][];
-  const reducers = Object.fromEntries(
-    entries.map(
-      ([opType, mapper]) =>
-        [opType, (state: readonly E[], payload: unknown) => [...state, mapper(payload)]] as const,
-    ),
-  ) as ModelReducers<readonly E[]>;
-  return defineDerivedModel(name, () => [], reducers);
-}
-
-export const ReplayTimelineModel = defineDerivedTimeline('agent.replayTimeline', {
-  [contextAppendMessage.type]: (p: PayloadOf<typeof contextAppendMessage>) =>
-    ({ type: contextAppendMessage.type, payload: p }) as const,
-
-  [contextAppendLoopEvent.type]: (p: PayloadOf<typeof contextAppendLoopEvent>) =>
-    ({ type: contextAppendLoopEvent.type, payload: p }) as const,
-
-  [contextApplyCompaction.type]: (p: PayloadOf<typeof contextApplyCompaction>) =>
-    ({ type: contextApplyCompaction.type, payload: p }) as const,
-
-  [fullCompactionBegin.type]: (p: PayloadOf<typeof fullCompactionBegin>) =>
-    ({ type: fullCompactionBegin.type, payload: p }) as const,
-
-  [fullCompactionCancel.type]: () =>
-    ({ type: fullCompactionCancel.type }) as const,
-
-  [fullCompactionComplete.type]: (p: PayloadOf<typeof fullCompactionComplete>) =>
-    ({ type: fullCompactionComplete.type, payload: p }) as const,
-
-  [createGoal.type]: (p: PayloadOf<typeof createGoal>) =>
-    ({ type: createGoal.type, payload: p }) as const,
-
-  [updateGoal.type]: (p: PayloadOf<typeof updateGoal>) =>
-    ({ type: updateGoal.type, payload: p }) as const,
-
-  [clearGoal.type]: () =>
-    ({ type: clearGoal.type }) as const,
-
-  [planModeEnter.type]: (p: PayloadOf<typeof planModeEnter>) =>
-    ({ type: planModeEnter.type, payload: p }) as const,
-
-  [planModeCancel.type]: (p: PayloadOf<typeof planModeCancel>) =>
-    ({ type: planModeCancel.type, payload: p }) as const,
-
-  [planModeExit.type]: (p: PayloadOf<typeof planModeExit>) =>
-    ({ type: planModeExit.type, payload: p }) as const,
-
-  [configUpdate.type]: (p: PayloadOf<typeof configUpdate>) =>
-    ({ type: configUpdate.type, payload: p }) as const,
-
-  [setMode.type]: (p: { mode: PermissionMode }) =>
-    ({ type: setMode.type, payload: p }) as const,
-
-  [recordApprovalResult.type]: (p: PermissionApprovalResultRecord) =>
-    ({ type: recordApprovalResult.type, payload: p }) as const,
-});
-
-type InferTimelineEntry<D> = D extends DerivedModelDef<readonly (infer E)[]> ? E : never;
-
-export type ReplayTimelineEntry = InferTimelineEntry<typeof ReplayTimelineModel>;
-export type ReplayTimeline = readonly ReplayTimelineEntry[];
diff --git a/packages/agent-core-v2/src/agent/replayBuilder/types.ts b/packages/agent-core-v2/src/agent/replayBuilder/types.ts
index d662fa2bb..04f0bc1d0 100644
--- a/packages/agent-core-v2/src/agent/replayBuilder/types.ts
+++ b/packages/agent-core-v2/src/agent/replayBuilder/types.ts
@@ -8,7 +8,7 @@ import type { PermissionData, PermissionMode } from '#/agent/permissionPolicy/ty
 import type { PlanData } from '#/agent/plan/plan';
 import type { ToolInfo } from '#/tool/toolContract';
 import type { SessionSummary } from '#/agent/rpc/core-api';
-import type { UsageStatus } from '@moonshot-ai/protocol';
+import type { UsageStatus } from '#/agent/usage/usage';
 import type { SessionMeta } from '#/session/sessionMetadata/sessionMetadata';
 
 type AgentType = 'main' | 'sub';
diff --git a/packages/agent-core-v2/src/agent/rpc/core-api.ts b/packages/agent-core-v2/src/agent/rpc/core-api.ts
index 853843565..0285cdb8e 100644
--- a/packages/agent-core-v2/src/agent/rpc/core-api.ts
+++ b/packages/agent-core-v2/src/agent/rpc/core-api.ts
@@ -20,7 +20,8 @@ import type { ExperimentalFeatureState } from '#/app/flag/flag';
 import type { ResumeSessionResult } from '#/agent/replayBuilder/types';
 import type { SessionMeta } from '#/session/sessionMetadata/sessionMetadata';
 import type { ContentPart } from '#/app/llmProtocol/message';
-import type { SessionWarning, UsageStatus } from '@moonshot-ai/protocol';
+import type { SessionWarning } from '#/app/sessionLegacy/sessionProtocol';
+import type { UsageStatus } from '#/agent/usage/usage';
 
 import type { ExportSessionPayload, ExportSessionResult } from '#/app/sessionExport/sessionExport';
 import type { PluginCommandDef, PluginInfo, PluginSummary, ReloadSummary } from '#/app/plugin/types';
diff --git a/packages/agent-core-v2/src/agent/rpc/rpcService.ts b/packages/agent-core-v2/src/agent/rpc/rpcService.ts
index 4bba878b0..d8c9d9549 100644
--- a/packages/agent-core-v2/src/agent/rpc/rpcService.ts
+++ b/packages/agent-core-v2/src/agent/rpc/rpcService.ts
@@ -7,7 +7,6 @@ import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory'
 import { IAgentContextSizeService } from '#/agent/contextSize/contextSize';
 import { IAgentFullCompactionService } from '#/agent/fullCompaction/fullCompaction';
 import { IAgentGoalService } from '#/agent/goal/goal';
-import type { PluginCommandActivatedEvent } from '@moonshot-ai/protocol';
 import { IEventBus } from '#/app/event/eventBus';
 import { IEventService } from '#/app/event/event';
 import { ErrorCodes, Error2 } from '#/errors';
@@ -65,6 +64,15 @@ import {
   promptMetadataTextFromSkill,
 } from './prompt-metadata';
 
+export interface PluginCommandActivatedEvent {
+  readonly type: 'plugin_command.activated';
+  readonly activationId: string;
+  readonly pluginId: string;
+  readonly commandName: string;
+  readonly commandArgs?: string;
+  readonly trigger: 'user-slash';
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'plugin_command.activated': PluginCommandActivatedEvent;
@@ -137,7 +145,10 @@ export class AgentRPCService implements IAgentRPCService {
 
   cancel({ turnId }: CancelPayload): void {
     if (this.loop.status().state === 'running') {
-      this.telemetry.track2('cancel', { from: 'streaming' });
+      this.telemetry.track2('cancel', {
+        from: 'streaming',
+        trace_id: this.loop.status().activeTraceId,
+      });
     }
     this.loop.cancel(turnId);
   }
@@ -209,7 +220,10 @@ export class AgentRPCService implements IAgentRPCService {
   cancelCompaction(_payload: EmptyPayload): void {
     const active = this.fullCompaction.compacting;
     if (active !== null) {
-      this.telemetry.track2('cancel', { from: 'compacting' });
+      this.telemetry.track2('cancel', {
+        from: 'compacting',
+        trace_id: active.traceId,
+      });
     }
     active?.abortController.abort();
   }
@@ -227,6 +241,10 @@ export class AgentRPCService implements IAgentRPCService {
   }
 
   stopTask(payload: StopTaskPayload): void {
+    if (payload.reason === undefined) {
+      void this.tasks.stopByUser(payload.taskId);
+      return;
+    }
     void this.tasks.stop(payload.taskId, payload.reason);
   }
 
diff --git a/packages/agent-core-v2/src/agent/runtime/runtime.ts b/packages/agent-core-v2/src/agent/runtime/runtime.ts
deleted file mode 100644
index 7a29db0af..000000000
--- a/packages/agent-core-v2/src/agent/runtime/runtime.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * `runtime` domain (L4) — Agent-scope live phase contract.
- *
- * Defines the public contract of the agent's whole live phase: the `AgentPhase`
- * discriminated union (each variant carries its own ancillary fields) and the
- * `IAgentRuntimeService` used to read the current phase via `phase()`. The
- * phase is the agent-level, fine-grained counterpart of the session-level
- * `sessionActivity` status: it splits `running` into waiting / streaming /
- * tool_call / retrying and adds `interrupted` / `ended`. Agent-scoped — one
- * instance per agent.
- */
-
-import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-import type { TurnEndedEvent } from '@moonshot-ai/protocol';
-
-export type AgentPhase =
-  | { readonly kind: 'idle' }
-  | {
-      readonly kind: 'running';
-      readonly turnId: number;
-      readonly step: number;
-      readonly stepId: string;
-      readonly since: number;
-    }
-  | {
-      readonly kind: 'streaming';
-      readonly turnId: number;
-      readonly step: number;
-      readonly stepId: string;
-      readonly stream: 'assistant' | 'thinking' | 'tool_call';
-      readonly toolCallId?: string;
-      readonly toolName?: string;
-      readonly since: number;
-    }
-  | {
-      readonly kind: 'tool_call';
-      readonly turnId: number;
-      readonly step: number;
-      readonly toolCallId: string;
-      readonly name: string;
-      readonly since: number;
-    }
-  | {
-      readonly kind: 'retrying';
-      readonly turnId: number;
-      readonly step: number;
-      readonly stepId: string;
-      readonly failedAttempt: number;
-      readonly nextAttempt: number;
-      readonly maxAttempts: number;
-      readonly delayMs: number;
-      readonly errorName?: string;
-      readonly statusCode?: number;
-      readonly since: number;
-    }
-  | {
-      readonly kind: 'awaiting_approval';
-      readonly turnId: number;
-      readonly step?: number;
-      readonly approval: unknown;
-      readonly since: number;
-    }
-  | {
-      readonly kind: 'interrupted';
-      readonly turnId: number;
-      readonly step?: number;
-      readonly reason: 'aborted' | 'max_steps' | 'error';
-      readonly message?: string;
-      readonly at: number;
-    }
-  | {
-      readonly kind: 'ended';
-      readonly turnId: number;
-      readonly reason: TurnEndedEvent['reason'];
-      readonly durationMs?: number;
-      readonly at: number;
-    };
-
-export interface IAgentRuntimeService {
-  readonly _serviceBrand: undefined;
-
-  phase(): AgentPhase;
-}
-
-export const IAgentRuntimeService: ServiceIdentifier<IAgentRuntimeService> =
-  createDecorator<IAgentRuntimeService>('agentRuntimeService');
diff --git a/packages/agent-core-v2/src/agent/runtime/runtimeOps.ts b/packages/agent-core-v2/src/agent/runtime/runtimeOps.ts
deleted file mode 100644
index f6ec4bc19..000000000
--- a/packages/agent-core-v2/src/agent/runtime/runtimeOps.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * `runtime` domain (L4) — wire Model (`RuntimeModel`) and the `runtime.set_phase`
- * Op (`setRuntimePhase`) that holds the agent's whole live phase.
- *
- * Declares the phase as a single-field wire Model (`{ phase }`, initial
- * `{ kind: 'idle' }`) plus one Op whose `apply` is a pure, edge-triggered
- * replacement: it returns the SAME reference when the incoming phase is
- * unchanged under `phaseEqual` (which ignores `since` / `at` timestamps), so the
- * wire's reference-equality gate stays quiet and high-frequency deltas do not
- * flood subscribers. The Op is live-only because `runtime.set_phase` is not a
- * v1 record type: nothing is persisted or replayed, and resumed agents start
- * back at `idle`. The `agent.status.updated` `phase` slice is derived from
- * the Op's `toEvent` (published on `dispatch`, never on `replay`). Consumed
- * by the Agent-scope `runtimeService`.
- */
-
-import { z } from 'zod';
-
-import { defineModel } from '#/wire/model';
-
-import type { AgentPhase } from './runtime';
-
-export interface RuntimeModelState {
-  readonly phase: AgentPhase;
-}
-
-export const RuntimeModel = defineModel<RuntimeModelState>('runtime', () => ({
-  phase: { kind: 'idle' },
-}));
-
-declare module '#/wire/types' {
-  interface TransientOpMap {
-    'runtime.set_phase': typeof setRuntimePhase;
-    'activity.set_snapshot': typeof setActivitySnapshot;
-  }
-}
-
-export const setRuntimePhase = RuntimeModel.defineOp('runtime.set_phase', {
-  schema: z.object({ phase: z.custom<AgentPhase>() }),
-  persist: false,
-  apply: (s, p) => (phaseEqual(s.phase, p.phase) ? s : { phase: p.phase }),
-  toEvent: (p) => ({ type: 'agent.status.updated' as const, phase: p.phase }),
-});
-
-export function phaseEqual(a: AgentPhase, b: AgentPhase): boolean {
-  if (a.kind !== b.kind) return false;
-  switch (a.kind) {
-    case 'idle':
-      return true;
-    case 'running': {
-      const c = b as typeof a;
-      return a.turnId === c.turnId && a.step === c.step && a.stepId === c.stepId;
-    }
-    case 'streaming': {
-      const c = b as typeof a;
-      return (
-        a.turnId === c.turnId &&
-        a.step === c.step &&
-        a.stepId === c.stepId &&
-        a.stream === c.stream &&
-        a.toolCallId === c.toolCallId
-      );
-    }
-    case 'tool_call': {
-      const c = b as typeof a;
-      return a.turnId === c.turnId && a.toolCallId === c.toolCallId;
-    }
-    case 'retrying': {
-      const c = b as typeof a;
-      return (
-        a.turnId === c.turnId &&
-        a.step === c.step &&
-        a.failedAttempt === c.failedAttempt &&
-        a.nextAttempt === c.nextAttempt
-      );
-    }
-    case 'awaiting_approval': {
-      const c = b as typeof a;
-      return a.turnId === c.turnId;
-    }
-    case 'interrupted': {
-      const c = b as typeof a;
-      return a.turnId === c.turnId && a.reason === c.reason;
-    }
-    case 'ended': {
-      const c = b as typeof a;
-      return a.turnId === c.turnId && a.reason === c.reason;
-    }
-  }
-}
-
-import type { AgentActivitySnapshot } from '#/activity/activity';
-
-export const ActivityModel = defineModel<AgentActivitySnapshot>('activity', () => ({
-  lane: 'idle',
-  background: [],
-}));
-
-export const setActivitySnapshot = ActivityModel.defineOp('activity.set_snapshot', {
-  schema: z.object({ next: z.custom<AgentActivitySnapshot>() }),
-  persist: false,
-  apply: (s, p) => (snapshotEqual(s, p.next) ? s : p.next),
-  toEvent: (p) => ({ type: 'agent.activity.updated' as const, ...p.next }),
-});
-
-export function snapshotEqual(a: AgentActivitySnapshot, b: AgentActivitySnapshot): boolean {
-  if (a.lane !== b.lane) return false;
-  if (a.background.length !== b.background.length) return false;
-  if ((a.turn === undefined) !== (b.turn === undefined)) return false;
-  if (a.turn !== undefined && b.turn !== undefined) {
-    const ta = a.turn;
-    const tb = b.turn;
-    if (
-      ta.turnId !== tb.turnId ||
-      ta.phase !== tb.phase ||
-      ta.stream !== tb.stream ||
-      ta.step !== tb.step ||
-      ta.ending !== tb.ending ||
-      ta.endingReason !== tb.endingReason ||
-      ta.pendingApprovals.length !== tb.pendingApprovals.length ||
-      ta.activeToolCalls.length !== tb.activeToolCalls.length
-    ) {
-      return false;
-    }
-    if (ta.retry?.nextAttempt !== tb.retry?.nextAttempt) return false;
-  }
-  if ((a.lastTurn === undefined) !== (b.lastTurn === undefined)) return false;
-  if (a.lastTurn !== undefined && b.lastTurn !== undefined) {
-    if (a.lastTurn.turnId !== b.lastTurn.turnId || a.lastTurn.reason !== b.lastTurn.reason) {
-      return false;
-    }
-  }
-  return true;
-}
-
-declare module '#/app/event/eventBus' {
-  interface DomainEventMap {
-    'agent.activity.updated': AgentActivitySnapshot & { readonly type: 'agent.activity.updated' };
-  }
-}
diff --git a/packages/agent-core-v2/src/agent/runtime/runtimeService.ts b/packages/agent-core-v2/src/agent/runtime/runtimeService.ts
deleted file mode 100644
index b27383264..000000000
--- a/packages/agent-core-v2/src/agent/runtime/runtimeService.ts
+++ /dev/null
@@ -1,345 +0,0 @@
-/**
- * `runtime` domain (L4) — `IAgentRuntimeService` implementation and the Agent
- * activity projector.
- *
- * Folds the agent's live activity into a structured `AgentActivitySnapshot`
- * (`ActivityModel`, mutated only through the `activity.set_snapshot` Op) and a
- * legacy `AgentPhase` (`RuntimeModel`, through `runtime.set_phase`). Inputs:
- * the `activity` kernel's `LaneModel` (authoritative lane / turn / lastTurn /
- * background) plus the existing `IEventBus` facts (step / stream / retry /
- * approval / tool-call). The snapshot adds a pending-approval SET and an
- * active-tool-call SET (keyed by id), so a parallel approval resolve no longer
- * drops the still-waiting ones (矛盾 d) and parallel tool calls are all
- * visible. Subscriptions are edge-triggered: `publishSnapshot` only dispatches
- * when `snapshotEqual` says it changed. Live-only — `wire.replay` stays silent
- * and resumes into `idle`. Bound at Agent scope.
- */
-
-import { Disposable } from '#/_base/di/lifecycle';
-import { InstantiationType } from '#/_base/di/extensions';
-import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { IEventBus } from '#/app/event/eventBus';
-import type { PermissionApprovalRequestContext } from '#/agent/permissionGate/permissionGateService';
-import type { TurnEndedEvent } from '@moonshot-ai/protocol';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
-import type {
-  ActivityRetryState,
-  AgentActivitySnapshot,
-  ApprovalRef,
-  ToolCallRef,
-  TurnPhase,
-} from '#/activity/activity';
-import { LaneModel } from '#/activity/activityOps';
-
-import { type AgentPhase, IAgentRuntimeService } from './runtime';
-import {
-  phaseEqual,
-  RuntimeModel,
-  setActivitySnapshot,
-  setRuntimePhase,
-} from './runtimeOps';
-
-interface TurnCursor {
-  readonly turnId: number;
-  readonly step: number;
-  readonly stepId: string;
-}
-
-export class AgentRuntimeService extends Disposable implements IAgentRuntimeService {
-  declare readonly _serviceBrand: undefined;
-
-  private cursor: TurnCursor = { turnId: -1, step: 0, stepId: '' };
-  private current: AgentPhase = { kind: 'idle' };
-  private priorForApproval: AgentPhase | undefined;
-  private subPhase: TurnPhase = 'running';
-  private subStream: 'assistant' | 'thinking' | 'tool_call' | undefined;
-  private subRetry: ActivityRetryState | undefined;
-  private readonly pendingApprovals = new Map<string, ApprovalRef>();
-  private readonly activeToolCalls = new Map<string, ToolCallRef>();
-
-  constructor(
-    @IAgentWireService private readonly wire: IWireService,
-    @IEventBus private readonly eventBus: IEventBus,
-  ) {
-    super();
-    this._register(this.eventBus.subscribe('turn.started', (e) => this.onTurnStarted(e.turnId)));
-    this._register(
-      this.eventBus.subscribe('turn.step.started', (e) =>
-        this.onStepStarted(e.turnId, e.step, e.stepId ?? ''),
-      ),
-    );
-    this._register(
-      this.eventBus.subscribe('assistant.delta', () => this.onDelta('assistant')),
-    );
-    this._register(
-      this.eventBus.subscribe('thinking.delta', () => this.onDelta('thinking')),
-    );
-    this._register(
-      this.eventBus.subscribe('tool.call.delta', (e) =>
-        this.onToolCallDelta(e.toolCallId, e.name),
-      ),
-    );
-    this._register(
-      this.eventBus.subscribe('tool.call.started', (e) =>
-        this.onToolCallStarted(e.toolCallId, e.name),
-      ),
-    );
-    this._register(
-      this.eventBus.subscribe('tool.result', (e) => this.onToolResult(e.toolCallId)),
-    );
-    this._register(
-      this.eventBus.subscribe('turn.step.retrying', (e) => {
-        this.subPhase = 'retrying';
-        this.subStream = undefined;
-        this.subRetry = {
-          failedAttempt: e.failedAttempt,
-          nextAttempt: e.nextAttempt,
-          maxAttempts: e.maxAttempts,
-          delayMs: e.delayMs,
-          errorName: e.errorName,
-          statusCode: e.statusCode,
-        };
-        this.setPhase({
-          kind: 'retrying',
-          turnId: e.turnId,
-          step: e.step,
-          stepId: e.stepId ?? '',
-          failedAttempt: e.failedAttempt,
-          nextAttempt: e.nextAttempt,
-          maxAttempts: e.maxAttempts,
-          delayMs: e.delayMs,
-          errorName: e.errorName,
-          statusCode: e.statusCode,
-          since: Date.now(),
-        });
-        this.publishSnapshot();
-      }),
-    );
-    this._register(
-      this.eventBus.subscribe('turn.step.interrupted', (e) =>
-        this.setPhase({
-          kind: 'interrupted',
-          turnId: e.turnId,
-          step: e.step,
-          reason: e.reason as 'aborted' | 'max_steps' | 'error',
-          message: e.message,
-          at: Date.now(),
-        }),
-      ),
-    );
-    this._register(
-      this.eventBus.subscribe('turn.step.completed', () => {
-        this.subPhase = 'running';
-        this.subStream = undefined;
-        this.subRetry = undefined;
-        this.setPhase(this.running());
-        this.publishSnapshot();
-      }),
-    );
-    this._register(
-      this.eventBus.subscribe('turn.ended', (e) =>
-        this.onTurnEnded(e.turnId, e.reason, e.durationMs),
-      ),
-    );
-    this._register(
-      this.eventBus.subscribe('permission.approval.requested', (e) =>
-        this.onApprovalRequested(e),
-      ),
-    );
-    this._register(
-      this.eventBus.subscribe('permission.approval.resolved', (e) =>
-        this.onApprovalResolved(e.toolCallId),
-      ),
-    );
-    this._register(this.wire.subscribe(LaneModel, () => this.publishSnapshot()));
-  }
-
-  phase(): AgentPhase {
-    return this.wire.getModel(RuntimeModel).phase;
-  }
-
-  private onTurnStarted(turnId: number): void {
-    this.cursor = { turnId, step: 0, stepId: '' };
-    this.priorForApproval = undefined;
-    this.subPhase = 'running';
-    this.subStream = undefined;
-    this.subRetry = undefined;
-    this.pendingApprovals.clear();
-    this.activeToolCalls.clear();
-    this.setPhase(this.running());
-    this.publishSnapshot();
-  }
-
-  private onStepStarted(turnId: number, step: number, stepId: string): void {
-    this.cursor = { turnId, step, stepId };
-    this.subPhase = 'running';
-    this.subStream = undefined;
-    this.subRetry = undefined;
-    this.setPhase(this.running());
-    this.publishSnapshot();
-  }
-
-  private onDelta(stream: 'assistant' | 'thinking'): void {
-    this.subPhase = 'streaming';
-    this.subStream = stream;
-    this.subRetry = undefined;
-    this.setPhase({
-      kind: 'streaming',
-      turnId: this.cursor.turnId,
-      step: this.cursor.step,
-      stepId: this.cursor.stepId,
-      stream,
-      since: Date.now(),
-    });
-    this.publishSnapshot();
-  }
-
-  private onToolCallDelta(toolCallId: string, name: string | undefined): void {
-    this.subPhase = 'streaming';
-    this.subStream = 'tool_call';
-    this.subRetry = undefined;
-    this.setPhase({
-      kind: 'streaming',
-      turnId: this.cursor.turnId,
-      step: this.cursor.step,
-      stepId: this.cursor.stepId,
-      stream: 'tool_call',
-      toolCallId,
-      toolName: name,
-      since: Date.now(),
-    });
-    this.publishSnapshot();
-  }
-
-  private onToolCallStarted(toolCallId: string, name: string): void {
-    this.subPhase = 'tool_call';
-    this.subStream = undefined;
-    this.subRetry = undefined;
-    this.activeToolCalls.set(toolCallId, { toolCallId, name, since: Date.now() });
-    this.setPhase({
-      kind: 'tool_call',
-      turnId: this.cursor.turnId,
-      step: this.cursor.step,
-      toolCallId,
-      name,
-      since: Date.now(),
-    });
-    this.publishSnapshot();
-  }
-
-  private onToolResult(toolCallId: string): void {
-    this.activeToolCalls.delete(toolCallId);
-    this.subPhase = 'running';
-    this.subStream = undefined;
-    this.subRetry = undefined;
-    this.setPhase(this.running());
-    this.publishSnapshot();
-  }
-
-  private onTurnEnded(
-    turnId: number,
-    reason: TurnEndedEvent['reason'],
-    durationMs: number | undefined,
-  ): void {
-    this.setPhase({ kind: 'ended', turnId, reason, durationMs, at: Date.now() });
-    this.cursor = { turnId: -1, step: 0, stepId: '' };
-    this.priorForApproval = undefined;
-    this.subPhase = 'running';
-    this.subStream = undefined;
-    this.subRetry = undefined;
-    this.pendingApprovals.clear();
-    this.activeToolCalls.clear();
-    this.publishSnapshot();
-  }
-
-  private onApprovalRequested(approval: PermissionApprovalRequestContext): void {
-    this.priorForApproval = this.current;
-    this.pendingApprovals.set(approval.toolCallId, {
-      approvalId: approval.toolCallId,
-      toolCallId: approval.toolCallId,
-      since: Date.now(),
-    });
-    this.setPhase({
-      kind: 'awaiting_approval',
-      turnId: approval.turnId,
-      step: this.cursor.step || undefined,
-      approval,
-      since: Date.now(),
-    });
-    this.publishSnapshot();
-  }
-
-  private onApprovalResolved(toolCallId: string): void {
-    this.pendingApprovals.delete(toolCallId);
-    const resume = this.priorForApproval;
-    this.priorForApproval = undefined;
-    if (this.pendingApprovals.size > 0) {
-      this.setPhase({
-        kind: 'awaiting_approval',
-        turnId: this.cursor.turnId,
-        step: this.cursor.step || undefined,
-        approval: undefined,
-        since: Date.now(),
-      });
-    } else if (resume !== undefined && resume.kind !== 'idle' && resume.kind !== 'ended') {
-      this.setPhase(resume);
-    } else {
-      this.setPhase(this.running());
-    }
-    this.publishSnapshot();
-  }
-
-  private running(): AgentPhase {
-    return {
-      kind: 'running',
-      turnId: this.cursor.turnId,
-      step: this.cursor.step,
-      stepId: this.cursor.stepId,
-      since: Date.now(),
-    };
-  }
-
-  private setPhase(phase: AgentPhase): void {
-    if (phaseEqual(this.current, phase)) return;
-    this.current = phase;
-    this.wire.dispatch(setRuntimePhase({ phase }));
-  }
-
-  private publishSnapshot(): void {
-    const lane = this.wire.getModel(LaneModel);
-    const turn =
-      lane.turn === undefined
-        ? undefined
-        : {
-            turnId: lane.turn.turnId,
-            origin: lane.turn.origin,
-            phase: this.subPhase,
-            stream: this.subStream,
-            step: this.cursor.step,
-            ending: lane.turn.ending,
-            endingReason: lane.turn.endingReason,
-            retry: this.subRetry,
-            pendingApprovals: [...this.pendingApprovals.values()],
-            activeToolCalls: [...this.activeToolCalls.values()],
-            since: lane.turn.since,
-          };
-    const snapshot = {
-      lane: lane.lane,
-      turn,
-      lastTurn: lane.lastTurn,
-      background: lane.background,
-    };
-    this.wire.dispatch(
-      setActivitySnapshot({ next: snapshot as unknown as AgentActivitySnapshot }),
-    );
-  }
-}
-
-registerScopedService(
-  LifecycleScope.Agent,
-  IAgentRuntimeService,
-  AgentRuntimeService,
-  InstantiationType.Eager,
-  'runtime',
-);
diff --git a/packages/agent-core-v2/src/agent/shellCommand/shellCommandService.ts b/packages/agent-core-v2/src/agent/shellCommand/shellCommandService.ts
index fd27833ff..480cee0ca 100644
--- a/packages/agent-core-v2/src/agent/shellCommand/shellCommandService.ts
+++ b/packages/agent-core-v2/src/agent/shellCommand/shellCommandService.ts
@@ -9,8 +9,6 @@
  * scope.
  */
 
-import type { ShellOutputEvent, ShellStartedEvent } from '@moonshot-ai/protocol';
-
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { userCancellationReason } from '#/_base/utils/abort';
@@ -27,6 +25,28 @@ import {
   type RunShellCommandResult,
 } from './shellCommand';
 
+/**
+ * Live stdout/stderr chunk from a user-initiated `!` shell command. Transient
+ * (never persisted, never replayed) — the final output is still recorded once
+ * via `context.append_message` on completion. `commandId` lets the TUI route
+ * chunks to the matching live entry and drop stale events from a prior run.
+ */
+export interface ShellOutputEvent {
+  readonly type: 'shell.output';
+  readonly commandId: string;
+  readonly update: ToolUpdate;
+}
+
+/**
+ * Fired once when a `!` shell command's foreground process task is registered,
+ * carrying the task id so the client can detach (ctrl+b) it. Transient.
+ */
+export interface ShellStartedEvent {
+  readonly type: 'shell.started';
+  readonly commandId: string;
+  readonly taskId: string;
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'shell.output': ShellOutputEvent;
diff --git a/packages/agent-core-v2/src/agent/skill/skillService.ts b/packages/agent-core-v2/src/agent/skill/skillService.ts
index 3b03ac85e..3f787ffd3 100644
--- a/packages/agent-core-v2/src/agent/skill/skillService.ts
+++ b/packages/agent-core-v2/src/agent/skill/skillService.ts
@@ -26,8 +26,7 @@ import { isUserActivatableSkillType, type SkillDefinition } from '#/app/skillCat
 import { IAgentPromptService } from '#/agent/prompt/prompt';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import type { Turn } from '#/agent/loop/loop';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import { IAgentSkillService, type SkillActivationInput } from './skill';
 import { skillActivate } from './skillOps';
 import { ISessionSkillCatalog } from '#/session/sessionSkillCatalog/skillCatalog';
@@ -38,7 +37,7 @@ export class AgentSkillService extends Disposable implements IAgentSkillService
   constructor(
     @ISessionSkillCatalog private readonly skillCatalog: ISessionSkillCatalog,
     @IAgentPromptService private readonly prompt: IAgentPromptService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @ITelemetryService private readonly telemetry: ITelemetryService,
     @ISessionContext private readonly sessionContext: ISessionContext,
   ) {
diff --git a/packages/agent-core-v2/src/agent/spine/spineService.ts b/packages/agent-core-v2/src/agent/spine/spineService.ts
index 3327c0cba..e1598599e 100644
--- a/packages/agent-core-v2/src/agent/spine/spineService.ts
+++ b/packages/agent-core-v2/src/agent/spine/spineService.ts
@@ -63,8 +63,7 @@ import { IFlagService } from '#/app/flag/flag';
 import { IHostEnvironment } from '#/os/interface/hostEnvironment';
 import { IHostFileSystem } from '#/os/interface/hostFileSystem';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 
 import { SPINE_FLAG_ID } from './flag';
 import { appendSpineView, loadSpineViewOverride } from './instructions';
@@ -156,7 +155,7 @@ export class AgentSpineService extends Disposable implements IAgentSpineService
     @IFlagService private readonly flags: IFlagService,
     @ISessionContext private readonly sessionCtx: ISessionContext,
     @IAgentScopeContext private readonly agentScope: IAgentScopeContext,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
     @IAgentLoopService loop: IAgentLoopService,
     @IAgentContextProjectorService projector: IAgentContextProjectorService,
@@ -203,7 +202,7 @@ export class AgentSpineService extends Disposable implements IAgentSpineService
       }),
     );
     this._register(
-      this.wire.onRestored(() => {
+      this.wire.hooks.onDidRestore.register('spine', async (_ctx, next) => {
         // The restored history re-derives the tree on first read; the ephemeral
         // gauges and archive ledger belong to the pre-restore session. Clearing
         // the archive ledger makes the first post-restore sweep rewrite every
@@ -215,6 +214,7 @@ export class AgentSpineService extends Disposable implements IAgentSpineService
         this.finals.clear();
         this.archivedIds.clear();
         this.failedArchiveIds.clear();
+        await next();
       }),
     );
     this._register(
diff --git a/packages/agent-core-v2/src/agent/stepRetry/stepRetryService.ts b/packages/agent-core-v2/src/agent/stepRetry/stepRetryService.ts
index 47046b754..33e424d06 100644
--- a/packages/agent-core-v2/src/agent/stepRetry/stepRetryService.ts
+++ b/packages/agent-core-v2/src/agent/stepRetry/stepRetryService.ts
@@ -13,8 +13,6 @@
  * before the first turn runs (same rationale as `fullCompaction`).
  */
 
-import type { TurnStepRetryingEvent } from '@moonshot-ai/protocol';
-
 import { Disposable } from '#/_base/di/lifecycle';
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
@@ -37,6 +35,20 @@ import { LOOP_CONTROL_SECTION, type LoopControl } from '#/agent/loop/configSecti
 
 import { IAgentStepRetryService } from './stepRetry';
 
+export interface TurnStepRetryingEvent {
+  readonly type: 'turn.step.retrying';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string;
+  readonly failedAttempt: number;
+  readonly nextAttempt: number;
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly errorName: string;
+  readonly errorMessage: string;
+  readonly statusCode?: number;
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'turn.step.retrying': TurnStepRetryingEvent;
diff --git a/packages/agent-core-v2/src/agent/swarm/swarmService.ts b/packages/agent-core-v2/src/agent/swarm/swarmService.ts
index 2eb6e8dc8..4ed949ff7 100644
--- a/packages/agent-core-v2/src/agent/swarm/swarmService.ts
+++ b/packages/agent-core-v2/src/agent/swarm/swarmService.ts
@@ -21,8 +21,7 @@ import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
 import { IEventBus } from '#/app/event/eventBus';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import SWARM_MODE_ENTER_REMINDER from './enter-reminder.md?raw';
 import SWARM_MODE_EXIT_REMINDER from './exit-reminder.md?raw';
 import { IAgentSwarmService, type SwarmModeTrigger } from './swarm';
@@ -32,7 +31,7 @@ export class AgentSwarmService extends Disposable implements IAgentSwarmService
   declare readonly _serviceBrand: undefined;
 
   constructor(
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IAgentSystemReminderService private readonly reminders: IAgentSystemReminderService,
     @IAgentContextMemoryService private readonly context: IAgentContextMemoryService,
     @IEventBus private readonly eventBus: IEventBus,
diff --git a/packages/agent-core-v2/src/agent/swarm/tools/agent-swarm.ts b/packages/agent-core-v2/src/agent/swarm/tools/agent-swarm.ts
index c1475c06d..09db93c30 100644
--- a/packages/agent-core-v2/src/agent/swarm/tools/agent-swarm.ts
+++ b/packages/agent-core-v2/src/agent/swarm/tools/agent-swarm.ts
@@ -19,13 +19,14 @@ import {
 } from '#/tool/toolContract';
 import { registerTool } from '#/agent/toolRegistry/toolContribution';
 import { toInputJsonSchema } from '#/tool/input-schema';
+import { IConfigService } from '#/app/config/config';
 import { ISessionSwarmService, type SessionSwarmTask } from '#/session/swarm/sessionSwarm';
 import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import { IAgentSwarmService } from '#/agent/swarm/swarm';
+import { resolveSubagentTimeoutMs } from '#/session/subagent/configSection';
 import AGENT_SWARM_DESCRIPTION from './agent-swarm.md?raw';
 
 const DEFAULT_SUBAGENT_TYPE = 'coder';
-const DEFAULT_SUBAGENT_TIMEOUT_MS = 30 * 60 * 1000;
 const PROMPT_TEMPLATE_PLACEHOLDER = '{{item}}';
 const MAX_AGENT_SWARM_SUBAGENTS = 128;
 
@@ -107,6 +108,7 @@ export class AgentSwarmTool implements BuiltinTool<AgentSwarmToolInput> {
     @ISessionSwarmService private readonly swarmService: ISessionSwarmService,
     @IAgentScopeContext scopeContext: IAgentScopeContext,
     @IAgentSwarmService private readonly swarmMode: IAgentSwarmService,
+    @IConfigService private readonly config: IConfigService,
   ) {
     this.callerAgentId = scopeContext.agentId;
   }
@@ -150,6 +152,7 @@ export class AgentSwarmTool implements BuiltinTool<AgentSwarmToolInput> {
     toolCallId: string,
   ): Promise<string> {
     const profileName = normalizeOptionalString(args.subagent_type) ?? DEFAULT_SUBAGENT_TYPE;
+    const timeoutMs = resolveSubagentTimeoutMs(this.config);
     const specs = await createAgentSwarmSpecs(args, (agentId) =>
       this.swarmService.getSwarmItem({ callerAgentId: this.callerAgentId, agentId }),
     );
@@ -165,7 +168,7 @@ export class AgentSwarmTool implements BuiltinTool<AgentSwarmToolInput> {
         runInBackground: false,
         swarmItem: spec.item,
         signal,
-        timeout: DEFAULT_SUBAGENT_TIMEOUT_MS,
+        timeout: timeoutMs,
       };
       if (spec.kind === 'resume') {
         return {
diff --git a/packages/agent-core-v2/src/agent/task/configSection.ts b/packages/agent-core-v2/src/agent/task/configSection.ts
index c8f7d5e31..405f9c0f4 100644
--- a/packages/agent-core-v2/src/agent/task/configSection.ts
+++ b/packages/agent-core-v2/src/agent/task/configSection.ts
@@ -7,7 +7,10 @@
  * fields as the base and let `[task]` override matching fields.
  * `keepAliveOnExit` also
  * accepts the v1 env override `KIMI_CODE_BACKGROUND_KEEP_ALIVE_ON_EXIT`
- * (applied live by the config env overlay, never persisted). Self-registered
+ * (applied live by the config env overlay, never persisted). Also owns the
+ * `kimi -p` print-mode background policy (`printBackgroundMode` /
+ * `printWaitCeilingS` / `printMaxTurns`), resolved with v1 semantics by
+ * `resolvePrintBackgroundMode`. Self-registered
  * at module load via `registerConfigSection`, so the `config` domain never
  * imports this domain's types.
  */
@@ -21,12 +24,18 @@ import { registerConfigSection } from '#/app/config/configSectionContributions';
 export const TASK_SECTION = 'task';
 export const LEGACY_BACKGROUND_SECTION = 'background';
 
+export const PrintBackgroundModeSchema = z.enum(['exit', 'drain', 'steer']);
+
+export type PrintBackgroundMode = z.infer<typeof PrintBackgroundModeSchema>;
+
 export const AgentTaskConfigSchema = z.object({
   maxRunningTasks: z.number().int().min(1).optional(),
   keepAliveOnExit: z.boolean().optional(),
   bashAutoBackgroundOnTimeout: z.boolean().optional(),
   killGracePeriodMs: z.number().int().min(0).optional(),
   printWaitCeilingS: z.number().int().min(1).optional(),
+  printBackgroundMode: PrintBackgroundModeSchema.optional(),
+  printMaxTurns: z.number().int().min(1).optional(),
 });
 
 export type AgentTaskConfig = z.infer<typeof AgentTaskConfigSchema>;
@@ -39,6 +48,20 @@ export function resolveAgentTaskConfig(config: IConfigService): AgentTaskConfig
   return { ...legacy, ...current };
 }
 
+/**
+ * Resolve the effective print-mode (`kimi -p`) background-task policy, mirroring
+ * v1's `Session.resolvePrintBackgroundMode`: `printBackgroundMode` is
+ * authoritative when set; otherwise fall back to the legacy `keepAliveOnExit`
+ * mapping (`true` ⇒ `'drain'`, otherwise `'exit'`). The
+ * `KIMI_CODE_BACKGROUND_KEEP_ALIVE_ON_EXIT` env override is applied by the
+ * config env overlay (see `taskEnvBindings`), so it is covered here.
+ */
+export function resolvePrintBackgroundMode(config: IConfigService): PrintBackgroundMode {
+  const section = resolveAgentTaskConfig(config);
+  if (section?.printBackgroundMode !== undefined) return section.printBackgroundMode;
+  return section?.keepAliveOnExit === true ? 'drain' : 'exit';
+}
+
 export const KEEP_ALIVE_ON_EXIT_ENV = 'KIMI_CODE_BACKGROUND_KEEP_ALIVE_ON_EXIT';
 
 export const taskEnvBindings: EnvBindings<AgentTaskConfig> = envBindings(AgentTaskConfigSchema, {
diff --git a/packages/agent-core-v2/src/agent/task/task.ts b/packages/agent-core-v2/src/agent/task/task.ts
index 124b8c4e8..9e091502f 100644
--- a/packages/agent-core-v2/src/agent/task/task.ts
+++ b/packages/agent-core-v2/src/agent/task/task.ts
@@ -92,6 +92,7 @@ export interface IAgentTaskService {
   suppressTerminalNotification(taskId: string): Promise<void>;
   detach(taskId: string): AgentTaskInfo | undefined;
   stop(taskId: string, reason?: string): Promise<AgentTaskInfo | undefined>;
+  stopByUser(taskId: string): Promise<AgentTaskInfo | undefined>;
   stopAll(reason?: string): Promise<readonly AgentTaskInfo[]>;
   stopAllOnExit(reason: string): Promise<readonly AgentTaskInfo[]>;
   wait(
diff --git a/packages/agent-core-v2/src/agent/task/taskOps.ts b/packages/agent-core-v2/src/agent/task/taskOps.ts
index d7055a125..5a520d33f 100644
--- a/packages/agent-core-v2/src/agent/task/taskOps.ts
+++ b/packages/agent-core-v2/src/agent/task/taskOps.ts
@@ -13,7 +13,7 @@
  * carries no non-determinism. The live `ManagedTask` (the running process, its
  * `AbortController`, output ring, timers) stays OUT of the Model (live-only);
  * the Model is the restore seed for `ghosts`, applied by the service's single
- * `wire.onRestored` handler before disk load + reconcile. The Ops are
+ * `wire.hooks.onDidRestore` hook before disk load + reconcile. The Ops are
  * live-only because task records are not v1 wire types; the durable registry
  * lives in `AgentTaskPersistence` and is reconciled on resume. Consumed by the
  * Agent-scope `taskService`.
diff --git a/packages/agent-core-v2/src/agent/task/taskService.ts b/packages/agent-core-v2/src/agent/task/taskService.ts
index 632d2d510..32bb4945f 100644
--- a/packages/agent-core-v2/src/agent/task/taskService.ts
+++ b/packages/agent-core-v2/src/agent/task/taskService.ts
@@ -9,10 +9,10 @@
  * session-level task root without writing back to it, reads
  * limits through `config`, records lifecycle and broadcasts through `wire`
  * (`task.started` / `task.terminated` Ops into `TaskModel`, plus the matching
- * signals), restores ghosts through a single `wire.onRestored` handler (wire
- * replay -> disk load -> reconcile, in that order), delivers live terminal
- * notifications by enqueueing `TaskNotificationStepRequest`s onto `loop` with
- * `activeOrNewTurn` admission (mid-turn ones fold into the active turn's
+ * signals), restores ghosts through a single `wire.hooks.onDidRestore` hook
+ * (wire replay -> disk load -> reconcile, in that order), delivers live
+ * terminal notifications by enqueueing `TaskNotificationStepRequest`s onto
+ * `loop` with `activeOrNewTurn` admission (mid-turn ones fold into the active turn's
  * following step; idle ones launch a fresh turn themselves, matching v1's
  * `turn.steer`, so the model consumes the notification without waiting for
  * the user), silently appends restored notifications through `contextMemory`,
@@ -36,7 +36,10 @@ import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import type { ContentPart } from '#/app/llmProtocol/message';
 
 import { Disposable } from '#/_base/di/lifecycle';
-import { abortable } from '#/_base/utils/abort';
+import {
+  abortable,
+  userCancellationReason,
+} from '#/_base/utils/abort';
 import { escapeXml, escapeXmlAttr } from '#/_base/utils/xml-escape';
 import { IEventBus } from '#/app/event/eventBus';
 import type { ContextMessage, TaskOrigin } from '#/agent/contextMemory/types';
@@ -58,12 +61,8 @@ import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import { IAtomicDocumentStore } from '#/persistence/interface/atomicDocumentStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
-import {
-  IAgentWireRecordService,
-  type PersistedWireRecord,
-} from '#/agent/wireRecord/wireRecord';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { defineModel } from '#/wire/model';
+import { IWireService } from '#/wire/wire';
 import {
   IAgentTaskService,
   type AgentTaskNotificationContext,
@@ -108,6 +107,21 @@ interface AgentTaskNotificationBuildContext {
   readonly notification: AgentTaskNotification;
 }
 
+const TaskNotificationDeliveryModel = defineModel<readonly string[]>(
+  'task.notificationDelivery',
+  () => [],
+  {
+    reducers: {
+      'context.append_message': (state, payload: { message?: unknown }) => {
+        const origin = taskOriginFromMessage(payload.message);
+        if (origin === undefined) return state;
+        const key = notificationKey(origin);
+        return state.includes(key) ? state : [...state, key];
+      },
+    },
+  },
+);
+
 interface ManagedTask {
   readonly taskId: string;
   readonly task: AgentTask | undefined;
@@ -156,7 +170,6 @@ function outputLimitReason(): string {
 
 const SIGTERM_GRACE_MS = 5_000;
 const TASK_ID_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
-const USER_INTERRUPT_REASON = 'Interrupted by user';
 const SESSION_CLOSED_REASON = 'Session closed';
 const NOTIFICATION_FALLBACK_PREVIEW_BYTES = 3_000;
 const ACTIVE_BACKGROUND_TASK_INJECTION_VARIANT = 'background_task_status';
@@ -215,8 +228,7 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
     @ISessionContext session: ISessionContext,
     @IAgentScopeContext scopeContext: IAgentScopeContext,
     @ITaskService private readonly taskService: ITaskService,
-    @IAgentWireRecordService wireRecord: IAgentWireRecordService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus: IEventBus,
     @IAgentContextInjectorService injector: IAgentContextInjectorService,
     @IAgentLoopService private readonly loop: IAgentLoopService,
@@ -234,11 +246,12 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
       fallbackRoot,
     );
     this._register(
-      this.wire.onRestored(async () => {
-        for (const record of wireRecord.getRecords()) {
-          this.markDeliveredNotificationsFromRecord(record);
+      this.wire.hooks.onDidRestore.register('task', async (_ctx, next) => {
+        for (const key of this.wire.getModel(TaskNotificationDeliveryModel)) {
+          this.deliveredNotificationKeys.add(key);
         }
         await this.restoreAfterReplay();
+        await next();
       }),
     );
     this._register(
@@ -281,12 +294,6 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
     }
   }
 
-  private markDeliveredNotificationsFromRecord(record: PersistedWireRecord): void {
-    for (const origin of taskOriginsFromRecord(record)) {
-      this.markDeliveredNotification(origin);
-    }
-  }
-
   registerTask(task: AgentTask, options: RegisterAgentTaskOptions = {}): string {
     const detached = options.detached ?? true;
     const timeoutMs = options.timeoutMs ?? task.timeoutMs;
@@ -620,6 +627,17 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
     });
   }
 
+  async stopByUser(taskId: string): Promise<AgentTaskInfo | undefined> {
+    const entry = this.tasks.get(taskId);
+    if (entry === undefined) return undefined;
+    const reason = userCancellationReason();
+    return this.terminateWithGrace(entry, {
+      stopReason: reason.message,
+      abortReason: reason,
+      finalStatus: 'killed',
+    });
+  }
+
   private async terminateWithGrace(
     entry: ManagedTask,
     options: {
@@ -1093,8 +1111,9 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
 
     const abortFromSignal = (): void => {
       if (this.isDetached(entry)) return;
+      const userReason = userCancellationReason();
       void this.terminateWithGrace(entry, {
-        stopReason: USER_INTERRUPT_REASON,
+        stopReason: userReason.message,
         abortReason: signal.reason,
         finalStatus: 'killed',
       });
@@ -1214,30 +1233,21 @@ function notificationKey(origin: TaskNotificationOrigin): string {
   return `${origin.taskId}\0${origin.status}\0${origin.notificationId}`;
 }
 
-function taskOriginsFromRecord(record: PersistedWireRecord): readonly TaskNotificationOrigin[] {
-  const raw = record as {
-    readonly type: string;
-    readonly message?: unknown;
-  };
-  if (raw.type === 'context.append_message') {
-    return taskOriginFromMessage(raw.message);
-  }
-  return [];
-}
-
-function taskOriginFromMessage(message: unknown): readonly TaskNotificationOrigin[] {
-  if (typeof message !== 'object' || message === null) return [];
+function taskOriginFromMessage(message: unknown): TaskNotificationOrigin | undefined {
+  if (typeof message !== 'object' || message === null) return undefined;
   const origin = (message as { readonly origin?: unknown }).origin;
-  return isTaskOrigin(origin) ? [origin] : [];
+  return isTaskOrigin(origin) ? origin : undefined;
 }
 
 function buildAgentTaskNotificationBody(info: AgentTaskInfo): string {
   const baseLine =
     info.status === 'timed_out'
       ? `${info.description} timed out.`
-      : info.stopReason
-        ? `${info.description} ${info.status === 'killed' ? 'was killed' : info.status}: ${info.stopReason}.`
-        : `${info.description} ${info.status}.`;
+      : info.status === 'killed' && isSerializedUserCancellation(info.stopReason)
+        ? `${info.description} was stopped by user.`
+        : info.stopReason
+          ? `${info.description} ${info.status === 'killed' ? 'was stopped' : info.status}. Reason: ${info.stopReason}`
+          : `${info.description} ${info.status}.`;
 
   if (info.kind !== 'agent') return baseLine;
   if (info.status === 'completed') return baseLine;
@@ -1269,6 +1279,10 @@ function normalizeReason(reason: string | undefined): string | undefined {
   return trimmed === undefined || trimmed.length === 0 ? undefined : trimmed;
 }
 
+function isSerializedUserCancellation(reason: string | undefined): boolean {
+  return reason === userCancellationReason().message;
+}
+
 function createForegroundRelease(): ForegroundRelease {
   let resolve!: (reason: ForegroundTaskReleaseReason) => void;
   const promise = new Promise<ForegroundTaskReleaseReason>((done) => {
diff --git a/packages/agent-core-v2/src/agent/task/tools/task-output.ts b/packages/agent-core-v2/src/agent/task/tools/task-output.ts
index b4f8a9872..caf610bc0 100644
--- a/packages/agent-core-v2/src/agent/task/tools/task-output.ts
+++ b/packages/agent-core-v2/src/agent/task/tools/task-output.ts
@@ -157,7 +157,6 @@ export class TaskOutputTool implements BuiltinTool<TaskOutputInput> {
     return {
       output: lines.join('\n'),
       isError: false,
-      message: 'Task snapshot retrieved.',
     };
   }
 }
diff --git a/packages/agent-core-v2/src/agent/toolDedupe/toolDedupeService.ts b/packages/agent-core-v2/src/agent/toolDedupe/toolDedupeService.ts
index b5a4ff130..9c1548432 100644
--- a/packages/agent-core-v2/src/agent/toolDedupe/toolDedupeService.ts
+++ b/packages/agent-core-v2/src/agent/toolDedupe/toolDedupeService.ts
@@ -14,7 +14,9 @@ import { InstantiationType } from '#/_base/di/extensions';
 import { Disposable } from '#/_base/di/lifecycle';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { canonicalTelemetryArgs } from '#/_base/utils/canonical-args';
+import type { ToolCallDedupDetectedEvent, ToolCallRepeatEvent } from '#/app/telemetry/events';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 import { IAgentLoopService } from '#/agent/loop/loop';
 import { IAgentToolExecutorService, type ToolCallDupType } from '#/agent/toolExecutor/toolExecutor';
 import type { ContentPart } from '#/app/llmProtocol/message';
@@ -130,7 +132,7 @@ export class AgentToolDedupeService extends Disposable implements IAgentToolDedu
       await next();
     });
     toolExecutor.hooks.onBeforeExecuteTool.register('toolDedupe', async (ctx, next) => {
-      const checked = this.checkToolCall(ctx.toolCall.id, ctx.toolCall.name, ctx.args);
+      const checked = this.checkToolCall(ctx.toolCall.id, ctx.toolCall.name, ctx.args, ctx.trace);
       if (checked.syntheticResult !== null) {
         ctx.decision = { syntheticResult: checked.syntheticResult };
         return;
@@ -143,6 +145,7 @@ export class AgentToolDedupeService extends Disposable implements IAgentToolDedu
         ctx.toolCall.name,
         ctx.args,
         ctx.result,
+        ctx.trace,
       );
       if (ctx.result.stopTurn === true) {
         ctx.stopTurn = true;
@@ -185,7 +188,12 @@ export class AgentToolDedupeService extends Disposable implements IAgentToolDedu
     }
   }
 
-  private checkToolCall(toolCallId: string, toolName: string, args: unknown): CheckedToolCall {
+  private checkToolCall(
+    toolCallId: string,
+    toolName: string,
+    args: unknown,
+    trace: LLMRequestTrace | undefined,
+  ): CheckedToolCall {
     const key = makeKey(toolName, args);
     const index = this.stepCalls.length;
     this.stepCalls.push(key);
@@ -194,13 +202,13 @@ export class AgentToolDedupeService extends Disposable implements IAgentToolDedu
     const existing = this.stepDeferreds.get(key);
     if (existing !== undefined) {
       this.syntheticCallIds.add(toolCallId);
-      this.recordDupType(toolCallId, toolName, args, 'same_step');
+      this.recordDupType(toolCallId, toolName, args, 'same_step', trace);
       return { syntheticResult: DEDUPE_PLACEHOLDER_RESULT };
     }
     this.stepDeferreds.set(key, makeDeferred<ToolDedupeResult>());
     this.originalCallIndex.set(toolCallId, index);
     if (this.consecutiveKey === key && this.consecutiveCount > 0) {
-      this.recordDupType(toolCallId, toolName, args, 'cross_step');
+      this.recordDupType(toolCallId, toolName, args, 'cross_step', trace);
       return { syntheticResult: null };
     }
     return { syntheticResult: null };
@@ -211,16 +219,19 @@ export class AgentToolDedupeService extends Disposable implements IAgentToolDedu
     toolName: string,
     args: unknown,
     dupType: ToolCallDupType,
+    trace: LLMRequestTrace | undefined,
   ): void {
     this.toolExecutor.recordDupType(toolCallId, dupType);
-    this.telemetry.track2('tool_call_dedup_detected', {
+    const properties: ToolCallDedupDetectedEvent = {
       turn_id: this.activeTurnId ?? 0,
       step_no: this.activeStep,
       tool_call_id: toolCallId,
       tool_name: toolName,
       dup_type: dupType,
       args_hash: argsHash(args),
-    });
+      trace_id: trace?.traceId,
+    };
+    this.telemetry.track2('tool_call_dedup_detected', properties);
   }
 
   private async finalizeResult(
@@ -228,6 +239,7 @@ export class AgentToolDedupeService extends Disposable implements IAgentToolDedu
     toolName: string,
     args: unknown,
     result: ToolDedupeResult,
+    trace: LLMRequestTrace | undefined,
   ): Promise<ToolDedupeResult> {
     const key = this.callKeyByCallId.get(toolCallId);
     if (key === undefined) return result;
@@ -271,11 +283,13 @@ export class AgentToolDedupeService extends Disposable implements IAgentToolDedu
     }
 
     if (streak >= 2) {
-      this.telemetry.track2('tool_call_repeat', {
+      const properties: ToolCallRepeatEvent = {
         tool_name: toolName,
         repeat_count: streak,
         action,
-      });
+        trace_id: trace?.traceId,
+      };
+      this.telemetry.track2('tool_call_repeat', properties);
     }
 
     this.stepDeferreds.get(key)?.resolve(finalResult);
diff --git a/packages/agent-core-v2/src/agent/toolExecutor/toolExecutor.ts b/packages/agent-core-v2/src/agent/toolExecutor/toolExecutor.ts
index cba1c4557..d8ca83fb6 100644
--- a/packages/agent-core-v2/src/agent/toolExecutor/toolExecutor.ts
+++ b/packages/agent-core-v2/src/agent/toolExecutor/toolExecutor.ts
@@ -12,6 +12,7 @@ import type { ToolResult } from '#/tool/toolContract';
 import type { ToolDidExecuteContext, ToolBeforeExecuteContext } from '#/agent/toolExecutor/toolHooks';
 import type { ToolCall } from '#/app/llmProtocol/message';
 import type { OrderedHookSlot } from '#/hooks';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 
 export interface ToolCallStartedPayload {
   readonly toolCallId: string;
@@ -22,6 +23,7 @@ export interface ToolCallStartedPayload {
 export interface ToolExecutorExecuteOptions {
   readonly signal: AbortSignal;
   readonly turnId: number;
+  readonly trace?: LLMRequestTrace;
   readonly onToolCall?: (payload: ToolCallStartedPayload) => void;
 }
 
diff --git a/packages/agent-core-v2/src/agent/toolExecutor/toolExecutorEvents.ts b/packages/agent-core-v2/src/agent/toolExecutor/toolExecutorEvents.ts
new file mode 100644
index 000000000..e0c858c31
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/toolExecutor/toolExecutorEvents.ts
@@ -0,0 +1,41 @@
+/**
+ * `toolExecutor` domain — the `tool.call.*` / `tool.progress` / `tool.result`
+ * event payloads published through `IEventBus` as tool calls execute.
+ */
+
+import type { ToolUpdate } from '#/tool/toolContract';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
+
+export interface ToolCallStartedEvent {
+  readonly type: 'tool.call.started';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly name: string;
+  readonly args: unknown;
+  readonly description?: string;
+  readonly display?: ToolInputDisplay;
+}
+
+export interface ToolProgressEvent {
+  readonly type: 'tool.progress';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly update: ToolUpdate;
+}
+
+export interface ToolResultEvent {
+  readonly type: 'tool.result';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly output: unknown;
+  readonly isError?: boolean;
+  readonly synthetic?: boolean;
+}
+
+declare module '#/app/event/eventBus' {
+  interface DomainEventMap {
+    'tool.call.started': ToolCallStartedEvent;
+    'tool.result': ToolResultEvent;
+    'tool.progress': ToolProgressEvent;
+  }
+}
diff --git a/packages/agent-core-v2/src/agent/toolExecutor/toolExecutorService.ts b/packages/agent-core-v2/src/agent/toolExecutor/toolExecutorService.ts
index 7f7acffcb..c7e2f0272 100644
--- a/packages/agent-core-v2/src/agent/toolExecutor/toolExecutorService.ts
+++ b/packages/agent-core-v2/src/agent/toolExecutor/toolExecutorService.ts
@@ -10,13 +10,8 @@
 import { InstantiationType } from '#/_base/di/extensions';
 import { toDisposable } from '#/_base/di/lifecycle';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import type { ContentPart } from '#/app/llmProtocol/message';
-import type {
-  ToolCallStartedEvent,
-  ToolInputDisplay,
-  ToolProgressEvent,
-  ToolResultEvent,
-} from '@moonshot-ai/protocol';
+import type { ContentPart, ToolCall } from '#/app/llmProtocol/message';
+import type { ToolInputDisplay } from '@moonshot-ai/protocol';
 
 import {
   compileToolArgsValidator,
@@ -25,8 +20,7 @@ import {
   type ToolArgsValidator,
 } from '#/tool/args-validator';
 import { PathSecurityError } from '#/tool/path-access';
-import { isUserCancellation } from "#/_base/utils/abort";
-import { isAbortError } from '#/_base/utils/abort';
+import { isAbortError, isUserCancellation } from '#/_base/utils/abort';
 import { IEventBus } from '#/app/event/eventBus';
 import {
   ToolAccesses,
@@ -39,7 +33,6 @@ import {
 } from '#/tool/toolContract';
 import type { ToolDidExecuteContext, ToolBeforeExecuteContext } from '#/agent/toolExecutor/toolHooks';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
-import type { ToolCall } from '#/app/llmProtocol/message';
 import { ILogService } from '#/_base/log/log';
 import type { ToolCallEvent } from '#/app/telemetry/events';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
@@ -54,14 +47,10 @@ import {
   type UnavailableToolDescriber,
 } from './toolExecutor';
 import { ToolScheduler } from './toolScheduler';
-
-declare module '#/app/event/eventBus' {
-  interface DomainEventMap {
-    'tool.call.started': ToolCallStartedEvent;
-    'tool.result': ToolResultEvent;
-    'tool.progress': ToolProgressEvent;
-  }
-}
+// Loads the `DomainEventMap` augmentation for the `tool.call.*` / `tool.result`
+// events this service publishes (the augmentation lives with the event
+// definitions; without an import it would not enter every consumer's program).
+import './toolExecutorEvents';
 
 const ABORT_GRACE_MS = 2_000;
 const TOOL_OUTPUT_EMPTY = 'Tool output is empty.';
@@ -254,7 +243,7 @@ export class AgentToolExecutorService implements IAgentToolExecutorService {
     const finalized = await this.finalizeToolResult(call, rawResult, options);
 
     this.dispatchToolResult(call, finalized, options);
-    this.trackToolCall(call, finalized, timedResult.durationMs, options.turnId);
+    this.trackToolCall(call, finalized, timedResult.durationMs, options);
 
     return {
       toolCallId: call.toolCall.id,
@@ -267,19 +256,20 @@ export class AgentToolExecutorService implements IAgentToolExecutorService {
     call: PreflightedToolCall,
     result: ToolResult,
     durationMs: number,
-    turnId: number,
+    options: ToolExecutorExecuteOptions,
   ): void {
     const outcome = toolTelemetryOutcome(result);
     const toolCallId = call.toolCall.id;
     const dupType = this.toolCallDupTypes.get(toolCallId) ?? 'normal';
     this.toolCallDupTypes.delete(toolCallId);
     const properties: ToolCallEvent = {
-      turn_id: turnId,
+      turn_id: options.turnId,
       tool_call_id: toolCallId,
       tool_name: call.toolName,
       outcome,
       duration_ms: durationMs,
       dup_type: dupType,
+      trace_id: options.trace?.traceId,
     };
     if (result.isError === true) properties['error_type'] = toolTelemetryErrorType(outcome);
     this.telemetry.track2('tool_call', properties);
@@ -463,6 +453,7 @@ export class AgentToolExecutorService implements IAgentToolExecutorService {
       const executePromise = execution.execute({
         turnId: options.turnId,
         toolCallId: call.toolCall.id,
+        trace: options.trace,
         metadata,
         signal,
         onUpdate: (update) => {
@@ -560,6 +551,7 @@ export class AgentToolExecutorService implements IAgentToolExecutorService {
     const didCtx: ToolDidExecuteContext = {
       turnId: options.turnId,
       signal: options.signal,
+      trace: options.trace,
       toolCall: call.toolCall,
       toolCalls: [call.toolCall],
       tool: call.tool,
@@ -587,7 +579,6 @@ export class AgentToolExecutorService implements IAgentToolExecutorService {
     const effectiveResult = normalizeToolResult(coercedResult);
     const finalResult: ToolResult = {
       ...effectiveResult,
-      message: coercedResult.message ?? result.message,
       description: result.description,
       display: result.display,
       approvalRule: result.approvalRule,
@@ -643,6 +634,7 @@ function buildWillExecuteContext(
   return {
     turnId: options.turnId,
     signal: options.signal,
+    trace: options.trace,
     toolCall: call.toolCall,
     toolCalls: allCalls,
     tool: call.tool,
diff --git a/packages/agent-core-v2/src/agent/toolExecutor/toolHooks.ts b/packages/agent-core-v2/src/agent/toolExecutor/toolHooks.ts
index 9bbf671c2..015ed3dd6 100644
--- a/packages/agent-core-v2/src/agent/toolExecutor/toolHooks.ts
+++ b/packages/agent-core-v2/src/agent/toolExecutor/toolHooks.ts
@@ -10,12 +10,14 @@
  */
 
 import type { ToolCall } from '#/app/llmProtocol/message';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 
 import type { ExecutableTool, ExecutableToolResult, RunnableToolExecution } from '#/tool/toolContract';
 
 export interface ToolExecutionHookContext {
   readonly turnId: number;
   readonly signal: AbortSignal;
+  readonly trace?: LLMRequestTrace;
   readonly toolCall: ToolCall;
   readonly toolCalls: readonly ToolCall[];
   readonly tool?: ExecutableTool | undefined;
diff --git a/packages/agent-core-v2/src/agent/toolSelect/flag.ts b/packages/agent-core-v2/src/agent/toolSelect/flag.ts
index 4015a2b49..c77331403 100644
--- a/packages/agent-core-v2/src/agent/toolSelect/flag.ts
+++ b/packages/agent-core-v2/src/agent/toolSelect/flag.ts
@@ -20,7 +20,7 @@ export const toolSelectFlag: FlagDefinitionInput = {
   id: TOOL_SELECT_FLAG_ID,
   title: 'Tool select (progressive tool disclosure)',
   description:
-    'Keep MCP tool schemas out of the immutable top-level tools[]; the model loads them on demand via the select_tools tool. Only takes effect on models whose capability catalog declares select_tools.',
+    'Keep MCP tool schemas out of the immutable top-level tools[]; the model loads them on demand via the select_tools tool. Only takes effect on models whose capability catalog declares dynamically loaded tools.',
   env: TOOL_SELECT_FLAG_ENV,
   default: false,
   surface: 'core',
diff --git a/packages/agent-core-v2/src/agent/toolSelect/toolSelectService.ts b/packages/agent-core-v2/src/agent/toolSelect/toolSelectService.ts
index 3e5e19c53..94410d53a 100644
--- a/packages/agent-core-v2/src/agent/toolSelect/toolSelectService.ts
+++ b/packages/agent-core-v2/src/agent/toolSelect/toolSelectService.ts
@@ -88,7 +88,7 @@ export class AgentToolSelectService extends Disposable implements IAgentToolSele
   enabled(): boolean {
     const capabilities = this.profile.getModelCapabilities();
     return (
-      capabilities.select_tools === true &&
+      capabilities.dynamically_loaded_tools === true &&
       capabilities.tool_use &&
       this.flags.enabled(TOOL_SELECT_FLAG_ID)
     );
diff --git a/packages/agent-core-v2/src/agent/usage/usage.ts b/packages/agent-core-v2/src/agent/usage/usage.ts
index 833e5bd4e..692c61968 100644
--- a/packages/agent-core-v2/src/agent/usage/usage.ts
+++ b/packages/agent-core-v2/src/agent/usage/usage.ts
@@ -11,7 +11,7 @@ import type { TokenUsage } from '#/app/llmProtocol/usage';
 
 import { createDecorator } from '#/_base/di/instantiation';
 import type { Event } from '#/_base/event';
-import type { ErrorCode } from '#/_base/errors/codes';
+import type { ErrorCode } from '#/errors';
 import { Error2 } from '#/_base/errors/errors';
 
 import { UsageErrors } from './errors';
diff --git a/packages/agent-core-v2/src/agent/usage/usageOps.ts b/packages/agent-core-v2/src/agent/usage/usageOps.ts
index 48297109b..6b3eeb24c 100644
--- a/packages/agent-core-v2/src/agent/usage/usageOps.ts
+++ b/packages/agent-core-v2/src/agent/usage/usageOps.ts
@@ -17,7 +17,6 @@
 import { z } from 'zod';
 
 import { addUsage, type TokenUsage } from '#/app/llmProtocol/usage';
-import type { AgentPhase } from '#/agent/runtime/runtime';
 import { defineModel } from '#/wire/model';
 
 import type { UsageStatus } from './usage';
@@ -35,7 +34,6 @@ declare module '#/app/event/eventBus' {
       maxContextTokens?: number;
       contextTokens?: number;
       rawContextTokens?: number;
-      phase?: AgentPhase;
     };
   }
 }
diff --git a/packages/agent-core-v2/src/agent/usage/usageService.ts b/packages/agent-core-v2/src/agent/usage/usageService.ts
index 8ff62eb22..cc78a3f4f 100644
--- a/packages/agent-core-v2/src/agent/usage/usageService.ts
+++ b/packages/agent-core-v2/src/agent/usage/usageService.ts
@@ -19,8 +19,7 @@ import { Emitter, type Event } from '#/_base/event';
 
 import type { LLMRequestSource } from '#/agent/llmRequester/llmRequester';
 import { IEventBus } from '#/app/event/eventBus';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import type { UsageRecordedContext, UsageStatus } from './usage';
 import { IAgentUsageService } from './usage';
 import {
@@ -41,7 +40,7 @@ export class AgentUsageService extends Disposable implements IAgentUsageService
   private currentTurn: TokenUsage | undefined;
 
   constructor(
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
     @IEventBus private readonly eventBus?: IEventBus,
   ) {
     super();
diff --git a/packages/agent-core-v2/src/agent/userTool/userToolOps.ts b/packages/agent-core-v2/src/agent/userTool/userToolOps.ts
index 9b54e8963..e4036097c 100644
--- a/packages/agent-core-v2/src/agent/userTool/userToolOps.ts
+++ b/packages/agent-core-v2/src/agent/userTool/userToolOps.ts
@@ -13,8 +13,9 @@
  * reference-equality gate stays quiet. The side effects — `registry.register`
  * and `profile.addActiveTool` (and the matching dispose / `removeActiveTool`) —
  * are NOT part of `apply`: they run after `wire.dispatch` on the live path and
- * are re-derived from the rebuilt Model by `wire.onRestored` after replay, so a
- * resumed agent re-registers exactly the tools the persisted ops describe.
+ * are re-derived from the rebuilt Model by `wire.hooks.onDidRestore` after
+ * restore, so a resumed agent re-registers exactly the tools the persisted ops
+ * describe.
  * Consumed by the Agent-scope `userToolService`.
  */
 
diff --git a/packages/agent-core-v2/src/agent/userTool/userToolService.ts b/packages/agent-core-v2/src/agent/userTool/userToolService.ts
index 530d30edc..201c52119 100644
--- a/packages/agent-core-v2/src/agent/userTool/userToolService.ts
+++ b/packages/agent-core-v2/src/agent/userTool/userToolService.ts
@@ -7,8 +7,9 @@
  * (`wire.dispatch(...)`). The live side effects — `registry.register` +
  * `profile.addActiveTool` (and the matching dispose / `removeActiveTool`) — run
  * after the dispatch, and are re-derived from the rebuilt Model by
- * `wire.onRestored` after `wire.replay`, so a resumed agent re-registers exactly
- * the tools the persisted ops describe without re-firing any live notification.
+ * `wire.hooks.onDidRestore` after `wire.restore`, so a resumed agent re-registers
+ * exactly the tools the persisted ops describe without re-firing any live
+ * notification.
  * The restore re-registers into the tool registry only: the active-tool set is
  * owned by the persisted `ActiveToolsModel`, so the ephemeral `addActiveTool`
  * overlay is not rebuilt (it is live-only by design). The per-tool
@@ -28,8 +29,7 @@ import type {
 } from '#/tool/toolContract';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { ISessionInteractionService } from '#/session/interaction/interaction';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 
 import { IAgentUserToolService, type UserToolRegistration } from './userTool';
 import { registerUserTool, unregisterUserTool, UserToolModel } from './userToolOps';
@@ -50,10 +50,15 @@ export class AgentUserToolService extends Disposable implements IAgentUserToolSe
     @IAgentToolRegistryService private readonly registry: IAgentToolRegistryService,
     @IAgentProfileService private readonly profile: IAgentProfileService,
     @ISessionInteractionService private readonly interaction: ISessionInteractionService,
-    @IAgentWireService private readonly wire: IWireService,
+    @IWireService private readonly wire: IWireService,
   ) {
     super();
-    this._register(this.wire.onRestored(() => this.restoreRegisteredTools()));
+    this._register(
+      this.wire.hooks.onDidRestore.register('user-tool', async (_ctx, next) => {
+        this.restoreRegisteredTools();
+        await next();
+      }),
+    );
   }
 
   list(): readonly UserToolRegistration[] {
diff --git a/packages/agent-core-v2/src/agent/wireRecord/agentWireService.ts b/packages/agent-core-v2/src/agent/wireRecord/agentWireService.ts
deleted file mode 100644
index 7ccdc2ead..000000000
--- a/packages/agent-core-v2/src/agent/wireRecord/agentWireService.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * `wireRecord` domain (L2), Agent scope — the `IAgentWireService` binding.
- *
- * Thin Agent-scope adapter over the scope-agnostic `WireService`: derives the
- * persistence addressing (`logScope` / `logKey`) from `IAgentScopeContext`
- * instead of receiving it as constructor options, so no per-agent scope seed
- * is required. `WireService` itself stays scope-agnostic; a future
- * Session-scope wire binds the same way.
- */
-
-import { InstantiationType } from '#/_base/di/extensions';
-import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { IAgentBlobService } from '#/agent/blob/agentBlobService';
-import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
-import { IEventBus } from '#/app/event/eventBus';
-import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
-import { IAgentWireService } from '#/wire/tokens';
-import { WireService } from '#/wire/wireServiceImpl';
-
-import { WIRE_RECORD_FILENAME } from './wireRecordService';
-
-export class AgentWireService extends WireService {
-  constructor(
-    @IAgentScopeContext scopeContext: IAgentScopeContext,
-    @IAppendLogStore log?: IAppendLogStore,
-    @IAgentBlobService blobService?: IAgentBlobService,
-    @IEventBus eventBus?: IEventBus,
-  ) {
-    super(
-      { logScope: scopeContext.scope(), logKey: WIRE_RECORD_FILENAME },
-      log,
-      blobService,
-      eventBus,
-    );
-  }
-}
-
-registerScopedService(
-  LifecycleScope.Agent,
-  IAgentWireService,
-  AgentWireService,
-  InstantiationType.Eager,
-  'wireRecord',
-);
diff --git a/packages/agent-core-v2/src/agent/wireRecord/errors.ts b/packages/agent-core-v2/src/agent/wireRecord/errors.ts
deleted file mode 100644
index a5b6f3156..000000000
--- a/packages/agent-core-v2/src/agent/wireRecord/errors.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-/**
- * `wireRecord` domain error codes — record persistence failures.
- */
-
-import { registerErrorDomain, type ErrorDomain } from '#/_base/errors/codes';
-
-export const WireRecordErrors = {
-  codes: {
-    RECORDS_WRITE_FAILED: 'records.write_failed',
-  },
-} as const satisfies ErrorDomain;
-
-registerErrorDomain(WireRecordErrors);
diff --git a/packages/agent-core-v2/src/agent/wireRecord/metadataOps.ts b/packages/agent-core-v2/src/agent/wireRecord/metadataOps.ts
deleted file mode 100644
index 59429a4e3..000000000
--- a/packages/agent-core-v2/src/agent/wireRecord/metadataOps.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * `wireRecord` domain (L6) — wire-log metadata envelope op.
- *
- * Declares a marker-only wire Model and the `metadata` Op whose flattened
- * record carries the wire-protocol envelope (`protocol_version`, `created_at`)
- * as the first record of each agent `wire.jsonl`. It is the only persisted
- * record that opts out of the `time` stamp, matching v1. Defined through the
- * low-level `wire` registry so `WireService` can persist the envelope through
- * the same append path as every other Op. `metadataRecord()` is the single
- * shared factory for the envelope — restore-time healing and fork-time log
- * copies both use it instead of hand-rolling the shape. Scope-agnostic.
- */
-
-import { z } from 'zod';
-
-import { defineModel } from '#/wire/model';
-import {
-  AGENT_WIRE_PROTOCOL_VERSION,
-} from '#/agent/wireRecord/migration/migration';
-import type { WireRecordMetadata } from './wireRecord';
-
-const MetadataModel = defineModel<null>('wire.metadata', () => null);
-
-declare module '#/wire/types' {
-  interface PersistedOpMap {
-    metadata: typeof wireMetadata;
-  }
-}
-
-export const wireMetadata = MetadataModel.defineOp('metadata', {
-  schema: z.object({ protocol_version: z.string(), created_at: z.number() }),
-  stamp: false,
-  apply: (s) => s,
-});
-
-/** A fresh metadata envelope stamped at the current protocol version. */
-export function metadataRecord(): WireRecordMetadata {
-  return {
-    type: 'metadata',
-    protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
-    created_at: Date.now(),
-  };
-}
diff --git a/packages/agent-core-v2/src/agent/wireRecord/wireRecord.ts b/packages/agent-core-v2/src/agent/wireRecord/wireRecord.ts
deleted file mode 100644
index d10522584..000000000
--- a/packages/agent-core-v2/src/agent/wireRecord/wireRecord.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { createDecorator } from '#/_base/di/instantiation';
-
-import type { WireMigrationRecord } from '#/agent/wireRecord/migration/migration';
-
-export * from '#/agent/wireRecord/migration/migration';
-
-export interface WireRecordMetadata {
-  readonly type: 'metadata';
-  readonly protocol_version: string;
-  readonly created_at: number;
-  readonly time?: number;
-}
-
-export type PersistedWireRecord = WireRecordMetadata | WireMigrationRecord;
-
-export interface WireRecordRestoreOptions {
-  readonly rewriteMigratedRecords?: boolean;
-}
-
-export interface WireRecordRestoreResult {
-  readonly warning?: string;
-}
-
-export interface IAgentWireRecordService {
-  readonly _serviceBrand: undefined;
-
-  getRecords(): readonly PersistedWireRecord[];
-  restore(
-    records?: readonly PersistedWireRecord[],
-    options?: WireRecordRestoreOptions,
-  ): Promise<WireRecordRestoreResult>;
-  flush(): Promise<void>;
-  close(): Promise<void>;
-}
-
-export const IAgentWireRecordService = createDecorator<IAgentWireRecordService>('agentWireRecordService');
diff --git a/packages/agent-core-v2/src/agent/wireRecord/wireRecordService.ts b/packages/agent-core-v2/src/agent/wireRecord/wireRecordService.ts
deleted file mode 100644
index 7eb92eb52..000000000
--- a/packages/agent-core-v2/src/agent/wireRecord/wireRecordService.ts
+++ /dev/null
@@ -1,172 +0,0 @@
-/**
- * `wireRecord` domain (L2) — `IAgentWireRecordService` implementation.
- *
- * Restores and retains the owning agent's wire journal, applies protocol
- * migrations, rejects non-empty unversioned logs, and awaits durable atomic
- * rewrites before restore completes. Tracks live records through `wire`, uses
- * `agent/scopeContext` for storage addressing, and persists through the
- * `appendLog` access-pattern store. Bound at Agent scope.
- */
-
-import { relative } from 'pathe';
-
-import { InstantiationType } from '#/_base/di/extensions';
-import { Disposable } from '#/_base/di/lifecycle';
-import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
-import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
-import {
-  AGENT_WIRE_PROTOCOL_VERSION,
-  applyWireMigrations,
-  isNewerWireVersion,
-  resolveWireMigrations,
-  type WireMigration,
-  type WireMigrationRecord,
-} from '#/agent/wireRecord/migration/migration';
-import { metadataRecord } from './metadataOps';
-import {
-  IAgentWireRecordService,
-  type PersistedWireRecord,
-  type WireRecordMetadata,
-  type WireRecordRestoreOptions,
-  type WireRecordRestoreResult,
-} from './wireRecord';
-
-export class AgentWireRecordService extends Disposable implements IAgentWireRecordService {
-  declare readonly _serviceBrand: undefined;
-  private readonly records: PersistedWireRecord[] = [];
-  private readonly wireScope: string;
-
-  constructor(
-    @IAgentScopeContext scopeContext: IAgentScopeContext,
-    @IAppendLogStore private readonly log?: IAppendLogStore,
-    @IAgentWireService private readonly wire?: IWireService,
-  ) {
-    super();
-    this.wireScope = scopeContext.scope();
-    if (this.log !== undefined) {
-      this._register(this.log.acquire(this.wireScope, WIRE_RECORD_FILENAME));
-    }
-    if (wire !== undefined) {
-      this._register(
-        wire.onEmission((emission) => {
-          if (emission.type === 'record' && emission.record.type !== 'metadata') {
-            this.records.push(emission.record as PersistedWireRecord);
-          }
-        }),
-      );
-    }
-  }
-
-  getRecords(): readonly PersistedWireRecord[] {
-    return [...this.records];
-  }
-
-  async restore(
-    records?: readonly PersistedWireRecord[],
-    options: WireRecordRestoreOptions = {},
-  ): Promise<WireRecordRestoreResult> {
-    const fromPersistence = records === undefined;
-    const source =
-      records ??
-      (this.log !== undefined
-        ? this.log.read<PersistedWireRecord>(this.wireScope, WIRE_RECORD_FILENAME)
-        : undefined);
-    if (source === undefined) {
-      return {};
-    }
-
-    const rewriteMigratedRecords =
-      fromPersistence && (options.rewriteMigratedRecords ?? true);
-    const restoredRecords: PersistedWireRecord[] | undefined =
-      rewriteMigratedRecords ? [] : undefined;
-    let migrations: readonly WireMigration[] = [];
-    let shouldRewrite = false;
-    let warning: string | undefined;
-
-    const collected: PersistedWireRecord[] = [];
-    for await (const record of source) {
-      collected.push(record);
-    }
-
-    let sourceRecords = collected;
-    const firstRecord = sourceRecords[0];
-    if (firstRecord !== undefined) {
-      if (firstRecord.type !== 'metadata') {
-        // Envelope-less log: a fresh agent (creation no longer seals the log)
-        // or a pre-envelope legacy log. Heal it in place: synthesize the
-        // envelope at the current protocol version — records written by
-        // current builds need no migration — and rewrite so the invariant
-        // holds from now on.
-        sourceRecords = [metadataRecord(), ...sourceRecords];
-        shouldRewrite = fromPersistence;
-      } else {
-        if (!isWireRecordMetadata(firstRecord)) {
-          throw new Error('WireRecord restore expected metadata protocol_version');
-        }
-        const readVersion = firstRecord.protocol_version;
-        if (isNewerWireVersion(readVersion)) {
-          warning = `Session wire protocol version ${readVersion} is newer than the current version ${AGENT_WIRE_PROTOCOL_VERSION}. Records will be restored without migration.`;
-          shouldRewrite = false;
-        } else {
-          migrations = resolveWireMigrations(readVersion);
-          shouldRewrite = readVersion !== AGENT_WIRE_PROTOCOL_VERSION;
-        }
-      }
-    }
-
-    const migratedRecords = applyWireMigrations(
-      sourceRecords as WireMigrationRecord[],
-      migrations,
-    ) as PersistedWireRecord[];
-    for (let migratedRecord of migratedRecords) {
-      if (migratedRecord.type === 'metadata') {
-        migratedRecord = {
-          ...migratedRecord,
-          protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
-        };
-      }
-      restoredRecords?.push(migratedRecord);
-      if (migratedRecord.type === 'metadata') continue;
-      this.records.push(migratedRecord);
-    }
-
-    if (shouldRewrite && restoredRecords !== undefined && this.log !== undefined) {
-      await this.log.rewrite(this.wireScope, WIRE_RECORD_FILENAME, restoredRecords);
-    }
-    return warning === undefined ? {} : { warning };
-  }
-
-  async flush(): Promise<void> {
-    await this.wire?.flush();
-    await this.log?.flush();
-  }
-
-  async close(): Promise<void> {
-    await this.log?.close();
-  }
-}
-
-registerScopedService(
-  LifecycleScope.Agent,
-  IAgentWireRecordService,
-  AgentWireRecordService,
-  InstantiationType.Eager,
-  'wireRecord',
-);
-
-function isWireRecordMetadata(record: PersistedWireRecord): record is WireRecordMetadata {
-  return record.type === 'metadata' && typeof record['protocol_version'] === 'string';
-}
-
-export const WIRE_RECORD_FILENAME = 'wire.jsonl';
-
-export function missingWireMetadataError(): Error {
-  return new Error('WireRecord restore expected metadata as the first record');
-}
-
-export function wireRecordScope(homedir: string, homeDir: string): string {
-  return relative(homeDir, homedir);
-}
diff --git a/packages/agent-core-v2/src/app/auth/auth.ts b/packages/agent-core-v2/src/app/auth/auth.ts
index ebbc4da67..a9f97c6ef 100644
--- a/packages/agent-core-v2/src/app/auth/auth.ts
+++ b/packages/agent-core-v2/src/app/auth/auth.ts
@@ -17,20 +17,19 @@ import type {
   KimiOAuthLogoutResult,
   KimiOAuthTokenRef,
 } from '@moonshot-ai/kimi-code-oauth';
-import type {
-  OAuthFlowSnapshot,
-  OAuthFlowStart,
-  OAuthLoginCancelResponse,
-  OAuthLogoutResponse,
-  RefreshOAuthProviderModelsResponse,
-} from '@moonshot-ai/protocol';
-
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 import { Error2 } from '#/_base/errors/errors';
 
 import type { OAuthRef } from '#/app/provider/provider';
 
 import { AuthErrors } from './errors';
+import type {
+  OAuthFlowSnapshot,
+  OAuthFlowStart,
+  OAuthLoginCancelResponse,
+  OAuthLogoutResponse,
+  RefreshOAuthProviderModelsResponse,
+} from './oauthProtocol';
 
 export interface AuthStatus {
   readonly loggedIn: boolean;
diff --git a/packages/agent-core-v2/src/app/auth/authService.ts b/packages/agent-core-v2/src/app/auth/authService.ts
index 7dbf538a0..00e402f97 100644
--- a/packages/agent-core-v2/src/app/auth/authService.ts
+++ b/packages/agent-core-v2/src/app/auth/authService.ts
@@ -39,7 +39,7 @@ import type {
   OAuthLoginCancelResponse,
   OAuthLogoutResponse,
   RefreshOAuthProviderModelsResponse,
-} from '@moonshot-ai/protocol';
+} from './oauthProtocol';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { Disposable } from '#/_base/di/lifecycle';
diff --git a/packages/agent-core-v2/src/app/auth/oauthProtocol.ts b/packages/agent-core-v2/src/app/auth/oauthProtocol.ts
new file mode 100644
index 000000000..8d6cb90db
--- /dev/null
+++ b/packages/agent-core-v2/src/app/auth/oauthProtocol.ts
@@ -0,0 +1,109 @@
+/**
+ * `auth` domain — the v1 OAuth wire DTO schemas.
+ *
+ * Request/response shapes of the v1 `/oauth/*` endpoints plus the managed
+ * OAuth provider model-refresh response, defined as zod schemas so the
+ * transports validate against the same contract the `IOAuthService` returns.
+ */
+
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '#/_base/utils/isoDateTime';
+
+export const oauthFlowStatusEnum = z.enum([
+  'pending',
+  'authenticated',
+  'denied',
+  'expired',
+  'cancelled',
+]);
+export type OAuthFlowStatus = z.infer<typeof oauthFlowStatusEnum>;
+
+/**
+ * Result of `POST /v1/oauth/login`.
+ *
+ * Two shapes, discriminated by `status`:
+ *   - `pending`: a real device-code flow was started; the `verification_*`,
+ *     `user_code`, `expires_*`, and `interval` fields are populated so the
+ *     client can render the device-code step and start polling.
+ *   - `authenticated`: the toolkit already had a usable token and short-
+ *     circuited via its `ensureFresh` fast path, so no device code was
+ *     issued. The client can skip the device-code step and treat the login
+ *     as already complete.
+ */
+export const oauthFlowStartPendingSchema = z.object({
+  flow_id: z.string().min(1),
+  provider: z.string().min(1),
+  status: z.literal('pending'),
+  verification_uri: z.string().url(),
+  verification_uri_complete: z.string().url(),
+  user_code: z.string().min(1),
+  expires_in: z.number().int().positive(),
+  interval: z.number().int().positive(),
+  expires_at: isoDateTimeSchema,
+});
+export type OAuthFlowStartPending = z.infer<typeof oauthFlowStartPendingSchema>;
+
+export const oauthFlowStartAuthenticatedSchema = z.object({
+  flow_id: z.string().min(1),
+  provider: z.string().min(1),
+  status: z.literal('authenticated'),
+});
+export type OAuthFlowStartAuthenticated = z.infer<typeof oauthFlowStartAuthenticatedSchema>;
+
+export const oauthFlowStartSchema = z.discriminatedUnion('status', [
+  oauthFlowStartPendingSchema,
+  oauthFlowStartAuthenticatedSchema,
+]);
+export type OAuthFlowStart = z.infer<typeof oauthFlowStartSchema>;
+
+export const oauthFlowSnapshotSchema = z.object({
+  flow_id: z.string().min(1),
+  provider: z.string().min(1),
+  status: oauthFlowStatusEnum,
+  verification_uri: z.string().url(),
+  verification_uri_complete: z.string().url(),
+  user_code: z.string().min(1),
+  expires_in: z.number().int().positive(),
+  expires_at: isoDateTimeSchema,
+  interval: z.number().int().positive(),
+  resolved_at: isoDateTimeSchema.optional(),
+  error_message: z.string().optional(),
+});
+export type OAuthFlowSnapshot = z.infer<typeof oauthFlowSnapshotSchema>;
+
+export const oauthLoginCancelResponseSchema = z.object({
+  cancelled: z.boolean(),
+  status: oauthFlowStatusEnum,
+});
+export type OAuthLoginCancelResponse = z.infer<typeof oauthLoginCancelResponseSchema>;
+
+export const oauthLogoutResponseSchema = z.object({
+  logged_out: z.literal(true),
+  provider: z.string().min(1),
+});
+export type OAuthLogoutResponse = z.infer<typeof oauthLogoutResponseSchema>;
+
+const providerRefreshChangeSchema = z.object({
+  provider_id: z.string().min(1),
+  provider_name: z.string().min(1),
+  added: z.number().int().min(0),
+  removed: z.number().int().min(0),
+});
+
+const providerRefreshFailureSchema = z.object({
+  provider: z.string().min(1),
+  reason: z.string().min(1),
+});
+
+// Same response shape as the modelCatalog refresh endpoint; defined
+// self-contained here because the two domains sit at different layers and the
+// `auth` domain owns the OAuth-provider refresh operation.
+export const refreshOAuthProviderModelsResponseSchema = z.object({
+  changed: z.array(providerRefreshChangeSchema),
+  unchanged: z.array(z.string().min(1)),
+  failed: z.array(providerRefreshFailureSchema),
+});
+export type RefreshOAuthProviderModelsResponse = z.infer<
+  typeof refreshOAuthProviderModelsResponseSchema
+>;
diff --git a/packages/agent-core-v2/src/app/authLegacy/authLegacy.ts b/packages/agent-core-v2/src/app/authLegacy/authLegacy.ts
index ac9c959f5..88d004e49 100644
--- a/packages/agent-core-v2/src/app/authLegacy/authLegacy.ts
+++ b/packages/agent-core-v2/src/app/authLegacy/authLegacy.ts
@@ -9,10 +9,32 @@
  * stateless projector over the global provider / model / credential state.
  */
 
-import type { AuthSummary } from '@moonshot-ai/protocol';
+import { z } from 'zod';
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 
+export const managedProviderStatusSchema = z.enum([
+  'authenticated',
+  'expired',
+  'revoked',
+  'unauthenticated',
+]);
+export type ManagedProviderStatus = z.infer<typeof managedProviderStatusSchema>;
+
+export const managedProviderSummarySchema = z.object({
+  name: z.string().min(1),
+  status: managedProviderStatusSchema,
+});
+export type ManagedProviderSummary = z.infer<typeof managedProviderSummarySchema>;
+
+export const authSummarySchema = z.object({
+  ready: z.boolean(),
+  providers_count: z.number().int().nonnegative(),
+  default_model: z.string().nullable(),
+  managed_provider: managedProviderSummarySchema.nullable(),
+});
+export type AuthSummary = z.infer<typeof authSummarySchema>;
+
 export interface IAuthLegacyService {
   readonly _serviceBrand: undefined;
 
diff --git a/packages/agent-core-v2/src/app/authLegacy/authLegacyService.ts b/packages/agent-core-v2/src/app/authLegacy/authLegacyService.ts
index d50fe7ddf..083c29e02 100644
--- a/packages/agent-core-v2/src/app/authLegacy/authLegacyService.ts
+++ b/packages/agent-core-v2/src/app/authLegacy/authLegacyService.ts
@@ -11,7 +11,7 @@
  */
 
 import { KIMI_CODE_PROVIDER_NAME } from '@moonshot-ai/kimi-code-oauth';
-import type { AuthSummary } from '@moonshot-ai/protocol';
+import type { AuthSummary } from './authLegacy';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
diff --git a/packages/agent-core-v2/src/app/cron/format.ts b/packages/agent-core-v2/src/app/cron/format.ts
index 86d990f26..49fb6a42a 100644
--- a/packages/agent-core-v2/src/app/cron/format.ts
+++ b/packages/agent-core-v2/src/app/cron/format.ts
@@ -7,7 +7,7 @@
  * them without pulling in the rest of the cron stack.
  */
 
-import type { CronJobOrigin } from '@moonshot-ai/protocol';
+import type { CronJobOrigin } from '#/agent/contextMemory/types';
 
 export function formatLocalIsoWithOffset(ms: number): string {
   const date = new Date(ms);
diff --git a/packages/agent-core-v2/src/app/event/eventBus.ts b/packages/agent-core-v2/src/app/event/eventBus.ts
index eaf090d45..8f3177752 100644
--- a/packages/agent-core-v2/src/app/event/eventBus.ts
+++ b/packages/agent-core-v2/src/app/event/eventBus.ts
@@ -7,8 +7,7 @@
  * `publish(event)` and consumers `subscribe(handler)` (all events) or
  * `subscribe(type, handler)` (one type). It is bound at Agent scope — one
  * instance per agent — so a subscription sees only that agent's events (the
- * server fans out per agent and tags `agentId` / `sessionId`, exactly like the
- * former `IAgentWireService.onEmission`). Process-global events (model catalog,
+ * server fans out per agent and tags `agentId` / `sessionId`). Process-global events (model catalog,
  * session lifecycle, auth) stay on the legacy `IEventService` (`./event`),
  * which is retained as the global channel; its payload type is re-exported from
  * the barrel as `GlobalEvent`. Domains declare their agent-event shapes by
diff --git a/packages/agent-core-v2/src/app/file/fileService.ts b/packages/agent-core-v2/src/app/file/fileService.ts
index ed0b98dee..476b615e6 100644
--- a/packages/agent-core-v2/src/app/file/fileService.ts
+++ b/packages/agent-core-v2/src/app/file/fileService.ts
@@ -8,11 +8,22 @@
 
 import type { Readable } from 'node:stream';
 
-import type { FileMeta } from '@moonshot-ai/protocol';
+import { z } from 'zod';
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 import { registerErrorDomain, type ErrorDomain } from '#/_base/errors/codes';
 import { Error2 } from '#/_base/errors/errors';
+import { isoDateTimeSchema } from '#/_base/utils/isoDateTime';
+
+export const fileMetaSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  media_type: z.string().min(1),
+  size: z.number().int().nonnegative(),
+  created_at: isoDateTimeSchema,
+  expires_at: isoDateTimeSchema.optional(),
+});
+export type FileMeta = z.infer<typeof fileMetaSchema>;
 
 export const DEFAULT_MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
 
diff --git a/packages/agent-core-v2/src/app/file/fileServiceImpl.ts b/packages/agent-core-v2/src/app/file/fileServiceImpl.ts
index bf15732ec..1b3f17dcb 100644
--- a/packages/agent-core-v2/src/app/file/fileServiceImpl.ts
+++ b/packages/agent-core-v2/src/app/file/fileServiceImpl.ts
@@ -11,7 +11,7 @@
 import { randomUUID } from 'node:crypto';
 import { Readable } from 'node:stream';
 
-import type { FileMeta } from '@moonshot-ai/protocol';
+import type { FileMeta } from './fileService';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
diff --git a/packages/agent-core-v2/src/app/git/git.ts b/packages/agent-core-v2/src/app/git/git.ts
index 86565f25e..1063cef0f 100644
--- a/packages/agent-core-v2/src/app/git/git.ts
+++ b/packages/agent-core-v2/src/app/git/git.ts
@@ -9,8 +9,62 @@
  * already-resolved absolute `cwd` and repo-relative paths.
  */
 
+import { z } from 'zod';
+
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-import type { FsDiffResponse, FsGitStatusResponse } from '@moonshot-ai/protocol';
+
+export const fsGitStatusSchema = z.enum([
+  'clean',
+  'modified',
+  'added',
+  'deleted',
+  'renamed',
+  'untracked',
+  'ignored',
+  'conflicted',
+]);
+export type FsGitStatus = z.infer<typeof fsGitStatusSchema>;
+
+export const fsPullRequestSchema = z.object({
+  number: z.number().int().positive(),
+  state: z.enum(['open', 'merged', 'closed', 'draft']),
+  url: z.string().url(),
+});
+export type FsPullRequest = z.infer<typeof fsPullRequestSchema>;
+
+export const fsGitStatusRequestSchema = z.object({
+  paths: z.array(z.string().min(1)).optional(),
+});
+export type FsGitStatusRequest = z.infer<typeof fsGitStatusRequestSchema>;
+
+export const fsGitStatusResponseSchema = z.object({
+  branch: z.string(),
+  ahead: z.number().int().nonnegative(),
+  behind: z.number().int().nonnegative(),
+  entries: z.record(z.string(), fsGitStatusSchema),
+  // Aggregate working-tree diff against HEAD (`git diff --numstat HEAD`):
+  // summed added/deleted lines across all changed files. Binary files (numstat
+  // `-`) contribute 0. Both 0 for a clean tree or a repo with no commits yet.
+  additions: z.number().int().nonnegative(),
+  deletions: z.number().int().nonnegative(),
+  // GitHub pull request for the current branch, looked up via `gh pr view`.
+  // Null when not a GitHub repo, `gh` is unavailable/unauthenticated, the
+  // branch has no PR, or the lookup failed/timed out. Never fails the request.
+  pullRequest: fsPullRequestSchema.nullable(),
+});
+export type FsGitStatusResponse = z.infer<typeof fsGitStatusResponseSchema>;
+
+export const fsDiffRequestSchema = z.object({
+  path: z.string().min(1),
+});
+export type FsDiffRequest = z.infer<typeof fsDiffRequestSchema>;
+
+export const fsDiffResponseSchema = z.object({
+  path: z.string(),
+  diff: z.string(),
+  truncated: z.boolean(),
+});
+export type FsDiffResponse = z.infer<typeof fsDiffResponseSchema>;
 
 export interface IGitService {
   readonly _serviceBrand: undefined;
diff --git a/packages/agent-core-v2/src/app/git/gitParsers.ts b/packages/agent-core-v2/src/app/git/gitParsers.ts
index b223bd569..613ed7b8a 100644
--- a/packages/agent-core-v2/src/app/git/gitParsers.ts
+++ b/packages/agent-core-v2/src/app/git/gitParsers.ts
@@ -8,7 +8,7 @@
  * `services/fs/fsGit.ts`).
  */
 
-import type { FsGitStatus, FsGitStatusResponse, FsPullRequest } from '@moonshot-ai/protocol';
+import type { FsGitStatus, FsGitStatusResponse, FsPullRequest } from './git';
 
 export function parsePorcelain(
   stdout: string,
diff --git a/packages/agent-core-v2/src/app/git/gitService.ts b/packages/agent-core-v2/src/app/git/gitService.ts
index a93a9f65b..73b7e4bc3 100644
--- a/packages/agent-core-v2/src/app/git/gitService.ts
+++ b/packages/agent-core-v2/src/app/git/gitService.ts
@@ -10,7 +10,7 @@
  * paths.
  */
 
-import type { FsDiffResponse, FsGitStatusResponse, FsPullRequest } from '@moonshot-ai/protocol';
+import type { FsDiffResponse, FsGitStatusResponse, FsPullRequest } from './git';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
diff --git a/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowser.ts b/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowser.ts
index 35d2026e1..82bfd2263 100644
--- a/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowser.ts
+++ b/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowser.ts
@@ -6,17 +6,40 @@
  * folder. Distinct from the Session-side `sessionFs`, which is sandboxed and may
  * be remote. App-scoped.
  *
- * The wire shapes (`FsBrowseResponse` / `FsHomeResponse`) are sourced from
- * `@moonshot-ai/protocol` so the `/api/v1` and `/api/v2` transports share one
- * contract. Domain errors (`HostFolder*Error`) carry the failing path and are
- * translated to protocol error codes at the transport boundary.
+ * The wire shapes (`FsBrowseResponse` / `FsHomeResponse`) are defined here as
+ * zod schemas so the `/api/v1` and `/api/v2` transports share one contract.
+ * Domain errors (`HostFolder*Error`) carry the failing path and are
+ * translated to wire error codes at the transport boundary.
  */
 
+import { z } from 'zod';
+
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 
-import type { FsBrowseResponse, FsHomeResponse } from '@moonshot-ai/protocol';
+export const fsBrowseQuerySchema = z.object({
+  path: z.string().min(1).optional(),
+});
+export type FsBrowseQuery = z.infer<typeof fsBrowseQuerySchema>;
 
-export type { FsBrowseResponse, FsHomeResponse };
+export const fsBrowseEntrySchema = z.object({
+  name: z.string().min(1),
+  path: z.string().min(1),
+  is_dir: z.literal(true),
+});
+export type FsBrowseEntry = z.infer<typeof fsBrowseEntrySchema>;
+
+export const fsBrowseResponseSchema = z.object({
+  path: z.string().min(1),
+  parent: z.string().min(1).nullable(),
+  entries: z.array(fsBrowseEntrySchema),
+});
+export type FsBrowseResponse = z.infer<typeof fsBrowseResponseSchema>;
+
+export const fsHomeResponseSchema = z.object({
+  home: z.string().min(1),
+  recent_roots: z.array(z.string().min(1)),
+});
+export type FsHomeResponse = z.infer<typeof fsHomeResponseSchema>;
 
 export class HostFolderNotAbsoluteError extends Error {
   readonly path: string;
diff --git a/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowserService.ts b/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowserService.ts
index fc4f2846e..3264c9a17 100644
--- a/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowserService.ts
+++ b/packages/agent-core-v2/src/app/hostFolderBrowser/hostFolderBrowserService.ts
@@ -5,14 +5,14 @@
  * `recent_roots` from the process-wide `IWorkspaceRegistry`. Bound at App
  * scope. Mirrors the v1 `WorkspaceFsService` behaviour so the `/api/v1`
  * transport stays wire-compatible: realpath resolution, directory-only
- * entries, git metadata, dot-last sorting, and `parent` resolution.
+ * entries, dot-last sorting, and `parent` resolution.
  */
 
-import { lstat, readFile, readdir, realpath } from 'node:fs/promises';
+import { readdir, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join } from 'node:path';
 
-import type { FsBrowseEntry, FsBrowseResponse, FsHomeResponse } from '@moonshot-ai/protocol';
+import type { FsBrowseEntry, FsBrowseResponse, FsHomeResponse } from './hostFolderBrowser';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
@@ -51,20 +51,13 @@ export class HostFolderBrowser implements IHostFolderBrowser {
       throw mapFsError(err, realTarget);
     }
 
-    const dirOnly = dirents.filter((d) => d.isDirectory());
-    const entries: FsBrowseEntry[] = await Promise.all(
-      dirOnly.map(async (d) => {
-        const childAbs = join(realTarget, d.name);
-        const git = await detectGit(childAbs);
-        return {
-          name: d.name,
-          path: childAbs,
-          is_dir: true as const,
-          is_git_repo: git.is_git_repo,
-          branch: git.branch ?? undefined,
-        };
-      }),
-    );
+    const entries: FsBrowseEntry[] = dirents
+      .filter((d) => d.isDirectory())
+      .map((d) => ({
+        name: d.name,
+        path: join(realTarget, d.name),
+        is_dir: true as const,
+      }));
 
     entries.sort(compareBrowseEntries);
 
@@ -102,51 +95,6 @@ function compareBrowseEntries(a: FsBrowseEntry, b: FsBrowseEntry): number {
   return a.name.localeCompare(b.name);
 }
 
-interface GitInfo {
-  readonly is_git_repo: boolean;
-  readonly branch: string | null;
-}
-
-async function detectGit(root: string): Promise<GitInfo> {
-  let dotGit;
-  try {
-    dotGit = await lstat(join(root, '.git'));
-  } catch {
-    return { is_git_repo: false, branch: null };
-  }
-
-  let gitDir: string;
-  if (dotGit.isDirectory()) {
-    gitDir = join(root, '.git');
-  } else if (dotGit.isFile()) {
-    let text: string;
-    try {
-      text = await readFile(join(root, '.git'), 'utf8');
-    } catch {
-      return { is_git_repo: false, branch: null };
-    }
-    const m = /^gitdir:\s*(.+)$/m.exec(text);
-    if (m === null) return { is_git_repo: false, branch: null };
-    const ref = m[1] ?? '';
-    if (ref === '') return { is_git_repo: false, branch: null };
-    gitDir = ref.trim();
-    if (!gitDir.startsWith('/')) {
-      gitDir = join(root, gitDir);
-    }
-  } else {
-    return { is_git_repo: false, branch: null };
-  }
-
-  let head: string;
-  try {
-    head = (await readFile(join(gitDir, 'HEAD'), 'utf8')).trim();
-  } catch {
-    return { is_git_repo: true, branch: null };
-  }
-  const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
-  return { is_git_repo: true, branch: ref ? (ref[1] ?? null) : null };
-}
-
 registerScopedService(
   LifecycleScope.App,
   IHostFolderBrowser,
diff --git a/packages/agent-core-v2/src/app/llmProtocol/capability.ts b/packages/agent-core-v2/src/app/llmProtocol/capability.ts
index 52a395012..de54d89be 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/capability.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/capability.ts
@@ -15,7 +15,7 @@ export interface ModelCapability {
   readonly thinking: boolean;
   readonly tool_use: boolean;
   readonly max_context_tokens: number;
-  readonly select_tools?: boolean;
+  readonly dynamically_loaded_tools?: boolean;
 }
 
 const UNKNOWN_CAPABILITY_MARKER = Symbol.for('moonshot-ai.kosong.UNKNOWN_CAPABILITY');
@@ -29,7 +29,7 @@ export const UNKNOWN_CAPABILITY: ModelCapability = Object.freeze(
       thinking: false,
       tool_use: false,
       max_context_tokens: 0,
-      select_tools: false,
+      dynamically_loaded_tools: false,
     },
     UNKNOWN_CAPABILITY_MARKER,
     { value: true },
@@ -47,7 +47,7 @@ export function isUnknownCapability(capability: ModelCapability): boolean {
     !capability.audio_in &&
     !capability.thinking &&
     !capability.tool_use &&
-    capability.select_tools !== true &&
+    capability.dynamically_loaded_tools !== true &&
     capability.max_context_tokens === 0
   );
 }
diff --git a/packages/agent-core-v2/src/app/llmProtocol/catalog.ts b/packages/agent-core-v2/src/app/llmProtocol/catalog.ts
index 744de6229..4fee00397 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/catalog.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/catalog.ts
@@ -8,7 +8,7 @@ export interface CatalogModelEntry {
   readonly limit?: { readonly context?: number; readonly output?: number };
   readonly tool_call?: boolean;
   readonly reasoning?: boolean;
-  readonly select_tools?: boolean;
+  readonly dynamically_loaded_tools?: boolean;
   readonly interleaved?: boolean | { readonly field?: string };
   readonly modalities?: {
     readonly input?: readonly string[];
@@ -109,7 +109,7 @@ export function catalogModelToCapability(model: CatalogModelEntry): CatalogModel
       thinking: Boolean(model.reasoning),
       tool_use: model.tool_call ?? true,
       max_context_tokens: context,
-      select_tools: model.select_tools === true,
+      dynamically_loaded_tools: model.dynamically_loaded_tools === true,
     },
   };
 }
diff --git a/packages/agent-core-v2/src/app/llmProtocol/errors.ts b/packages/agent-core-v2/src/app/llmProtocol/errors.ts
index d1f815228..7a4d5d70c 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/errors.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/errors.ts
@@ -25,18 +25,22 @@ export class APIStatusError extends ChatProviderError {
   readonly statusCode: number;
   readonly requestId: string | null;
   readonly retryAfterMs: number | null;
+  /** Trace id from the `x-trace-id` response header (Kimi only; `null` otherwise). */
+  readonly traceId: string | null;
 
   constructor(
     statusCode: number,
     message: string,
     requestId?: string | null,
     retryAfterMs?: number | null,
+    traceId?: string | null,
   ) {
     super(message);
     this.name = 'APIStatusError';
     this.statusCode = statusCode;
     this.requestId = requestId ?? null;
     this.retryAfterMs = retryAfterMs ?? null;
+    this.traceId = traceId ?? null;
   }
 }
 
@@ -46,8 +50,9 @@ export class APIContextOverflowError extends APIStatusError {
     message: string,
     requestId?: string | null,
     retryAfterMs?: number | null,
+    traceId?: string | null,
   ) {
-    super(statusCode, message, requestId, retryAfterMs);
+    super(statusCode, message, requestId, retryAfterMs, traceId);
     this.name = 'APIContextOverflowError';
   }
 }
@@ -58,15 +63,21 @@ export class APIRequestTooLargeError extends APIStatusError {
     message: string,
     requestId?: string | null,
     retryAfterMs?: number | null,
+    traceId?: string | null,
   ) {
-    super(statusCode, message, requestId, retryAfterMs);
+    super(statusCode, message, requestId, retryAfterMs, traceId);
     this.name = 'APIRequestTooLargeError';
   }
 }
 
 export class APIProviderRateLimitError extends APIStatusError {
-  constructor(message: string, requestId?: string | null, retryAfterMs?: number | null) {
-    super(429, message, requestId, retryAfterMs);
+  constructor(
+    message: string,
+    requestId?: string | null,
+    retryAfterMs?: number | null,
+    traceId?: string | null,
+  ) {
+    super(429, message, requestId, retryAfterMs, traceId);
     this.name = 'APIProviderRateLimitError';
   }
 }
@@ -77,8 +88,9 @@ export class APIProviderOverloadedError extends APIStatusError {
     message: string,
     requestId?: string | null,
     retryAfterMs?: number | null,
+    traceId?: string | null,
   ) {
-    super(statusCode, message, requestId, retryAfterMs);
+    super(statusCode, message, requestId, retryAfterMs, traceId);
     this.name = 'APIProviderOverloadedError';
   }
 }
@@ -229,24 +241,26 @@ export function normalizeAPIStatusError(
   message: string,
   requestId?: string | null,
   retryAfterMs?: number | null,
+  traceId?: string | null,
 ): APIStatusError {
   if (statusCode === 429) {
-    return new APIProviderRateLimitError(message, requestId, retryAfterMs);
+    return new APIProviderRateLimitError(message, requestId, retryAfterMs, traceId);
   }
   if (isContextOverflowStatusError(statusCode, message)) {
-    return new APIContextOverflowError(statusCode, message, requestId, retryAfterMs);
+    return new APIContextOverflowError(statusCode, message, requestId, retryAfterMs, traceId);
   }
   if (isRequestTooLargeStatusError(statusCode, message)) {
-    return new APIRequestTooLargeError(statusCode, message, requestId, retryAfterMs);
+    return new APIRequestTooLargeError(statusCode, message, requestId, retryAfterMs, traceId);
   }
   if (isProviderOverloadStatusError(statusCode, message)) {
-    return new APIProviderOverloadedError(statusCode, message, requestId, retryAfterMs);
+    return new APIProviderOverloadedError(statusCode, message, requestId, retryAfterMs, traceId);
   }
   return new APIStatusError(
     statusCode,
     appendThinkingEffortConfigHint(statusCode, message),
     requestId,
     retryAfterMs,
+    traceId,
   );
 }
 
@@ -263,6 +277,17 @@ export function parseRetryAfterMs(headers: unknown): number | null {
   return seconds * 1000;
 }
 
+export function parseTraceId(headers: unknown): string | null {
+  const raw =
+    headers !== null &&
+    typeof headers === 'object' &&
+    typeof (headers as { get?: unknown }).get === 'function'
+      ? (headers as { get(name: string): string | null }).get('x-trace-id')
+      : null;
+  if (raw === null || raw === undefined || raw.length === 0) return null;
+  return raw;
+}
+
 export function isContextOverflowStatusError(statusCode: number, message: string): boolean {
   if (statusCode !== 400 && statusCode !== 413 && statusCode !== 422) return false;
   const lowerMessage = message.toLowerCase();
diff --git a/packages/agent-core-v2/src/app/llmProtocol/generate.ts b/packages/agent-core-v2/src/app/llmProtocol/generate.ts
index bc33baa7b..cbe70260e 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/generate.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/generate.ts
@@ -20,6 +20,7 @@ export interface GenerateResult {
   readonly usage: TokenUsage | null;
   readonly finishReason: FinishReason | null;
   readonly rawFinishReason: string | null;
+  readonly traceId?: string | null;
 }
 
 export interface GenerateCallbacks {
@@ -50,6 +51,9 @@ export async function generate(
 
   options?.onRequestStart?.();
   const stream = await provider.generate(systemPrompt, wireTools, history, options);
+  if (stream.traceId !== undefined) {
+    options?.onTraceId?.(stream.traceId);
+  }
 
   await throwIfAborted(options?.signal, stream);
 
@@ -153,13 +157,17 @@ export async function generate(
     }
   }
 
-  return {
+  const result: GenerateResult = {
     id: stream.id,
     message,
     usage: stream.usage,
     finishReason: stream.finishReason,
     rawFinishReason: stream.rawFinishReason,
   };
+  if (stream.traceId !== undefined) {
+    return { ...result, traceId: stream.traceId };
+  }
+  return result;
 }
 
 type CancelableStream = StreamedMessage & {
diff --git a/packages/agent-core-v2/src/app/llmProtocol/provider.ts b/packages/agent-core-v2/src/app/llmProtocol/provider.ts
index 04547944f..591c5cc23 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/provider.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/provider.ts
@@ -48,6 +48,11 @@ export interface StreamedMessage {
   readonly usage: TokenUsage | null;
   readonly finishReason: FinishReason | null;
   readonly rawFinishReason: string | null;
+  /**
+   * Trace id from the provider's `x-trace-id` response header (Kimi only;
+   * `null` for every other protocol and for headerless responses).
+   */
+  readonly traceId?: string | null;
 }
 
 export interface ProviderRequestAuth {
@@ -62,6 +67,11 @@ export interface GenerateOptions {
   onRequestStart?: () => void;
   onRequestSent?: () => void;
   onStreamEnd?: (stats?: StreamDecodeStats) => void;
+  /**
+   * Called as soon as the response headers arrive (before the stream body),
+   * with the provider's trace id — `null` when the protocol has none.
+   */
+  onTraceId?: (traceId: string | null) => void;
 }
 
 export interface StreamDecodeStats {
diff --git a/packages/agent-core-v2/src/app/llmProtocol/providers/anthropic-profile.ts b/packages/agent-core-v2/src/app/llmProtocol/providers/anthropic-profile.ts
new file mode 100644
index 000000000..8ac962373
--- /dev/null
+++ b/packages/agent-core-v2/src/app/llmProtocol/providers/anthropic-profile.ts
@@ -0,0 +1,153 @@
+/**
+ * `llmProtocol` domain (L0) — Anthropic model capability profiles and name matching.
+ * Matrix source: https://platform.claude.com/docs/en/build-with-claude/effort
+ * and https://platform.claude.com/docs/en/build-with-claude/extended-thinking.
+ */
+
+export type AnthropicThinkingMode = 'budget' | 'adaptive';
+
+export interface AnthropicModelProfile {
+  readonly mode: AnthropicThinkingMode;
+  readonly efforts: readonly string[];
+  readonly supportsEffortParam: boolean;
+  readonly canDisableThinking: boolean;
+}
+
+export type AnthropicModelFamily = 'opus' | 'sonnet' | 'haiku' | 'fable' | 'mythos';
+
+export interface AnthropicModelVersion {
+  readonly family: AnthropicModelFamily;
+  readonly major: number;
+  readonly minor: number | null;
+}
+
+export const BUDGET_THINKING_EFFORTS = ['low', 'medium', 'high'] as const;
+const ADAPTIVE_MAX_EFFORTS = ['low', 'medium', 'high', 'max'] as const;
+export const LATEST_OPUS_THINKING_EFFORTS = [
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+] as const;
+
+const BUDGET_PROFILE: AnthropicModelProfile = {
+  mode: 'budget',
+  efforts: BUDGET_THINKING_EFFORTS,
+  supportsEffortParam: false,
+  canDisableThinking: true,
+};
+
+const OPUS_45_PROFILE: AnthropicModelProfile = {
+  ...BUDGET_PROFILE,
+  supportsEffortParam: true,
+};
+
+const ADAPTIVE_MAX_PROFILE: AnthropicModelProfile = {
+  mode: 'adaptive',
+  efforts: ADAPTIVE_MAX_EFFORTS,
+  supportsEffortParam: true,
+  canDisableThinking: true,
+};
+
+export const LATEST_OPUS_PROFILE: AnthropicModelProfile = {
+  mode: 'adaptive',
+  efforts: LATEST_OPUS_THINKING_EFFORTS,
+  supportsEffortParam: true,
+  canDisableThinking: true,
+};
+
+const ALWAYS_ADAPTIVE_PROFILE: AnthropicModelProfile = {
+  ...LATEST_OPUS_PROFILE,
+  canDisableThinking: false,
+};
+
+const ALWAYS_ADAPTIVE_MAX_PROFILE: AnthropicModelProfile = {
+  ...ADAPTIVE_MAX_PROFILE,
+  canDisableThinking: false,
+};
+
+const FAMILY_FIRST_RE =
+  /(opus|sonnet|haiku|fable|mythos)[-._](\d{1,2})(?!\d)(?:[-._](\d{1,2})(?!\d))?/;
+const VERSION_FIRST_RE = /(\d{1,2})[-._](\d{1,2})[-._](opus|sonnet|haiku)/;
+const BARE_FAMILY_RE = /(\d{1,2})[-._](opus|sonnet|haiku)/;
+
+export function parseAnthropicModelVersion(
+  model: string,
+  requireClaudeMarker = false,
+): AnthropicModelVersion | null {
+  const normalized = model.toLowerCase();
+  if (requireClaudeMarker && !normalized.includes('claude')) return null;
+
+  const familyFirst = FAMILY_FIRST_RE.exec(normalized);
+  if (familyFirst !== null) {
+    return {
+      family: familyFirst[1] as AnthropicModelFamily,
+      major: Number.parseInt(familyFirst[2]!, 10),
+      minor: familyFirst[3] !== undefined ? Number.parseInt(familyFirst[3], 10) : null,
+    };
+  }
+
+  const versionFirst = VERSION_FIRST_RE.exec(normalized);
+  if (versionFirst !== null) {
+    return {
+      major: Number.parseInt(versionFirst[1]!, 10),
+      minor: Number.parseInt(versionFirst[2]!, 10),
+      family: versionFirst[3] as AnthropicModelFamily,
+    };
+  }
+
+  const bare = BARE_FAMILY_RE.exec(normalized);
+  if (bare !== null) {
+    return {
+      major: Number.parseInt(bare[1]!, 10),
+      minor: null,
+      family: bare[2] as AnthropicModelFamily,
+    };
+  }
+
+  return null;
+}
+
+export function matchKnownAnthropicModelProfile(
+  model: string,
+): AnthropicModelProfile | undefined {
+  const normalized = model.toLowerCase();
+  if (/mythos[-._]preview/.test(normalized)) return ALWAYS_ADAPTIVE_MAX_PROFILE;
+
+  const version = parseAnthropicModelVersion(model);
+  if (version === null) return undefined;
+
+  switch (version.family) {
+    case 'opus':
+      if (version.major === 4 && (version.minor === 7 || version.minor === 8)) {
+        return LATEST_OPUS_PROFILE;
+      }
+      if (version.major === 4 && version.minor === 6) return ADAPTIVE_MAX_PROFILE;
+      if (version.major === 4 && version.minor === 5) return OPUS_45_PROFILE;
+      if (version.major < 4 || (version.major === 4 && (version.minor ?? 0) < 5)) {
+        return BUDGET_PROFILE;
+      }
+      return undefined;
+    case 'sonnet':
+      if (version.major === 5) return LATEST_OPUS_PROFILE;
+      if (version.major === 4 && version.minor === 6) return ADAPTIVE_MAX_PROFILE;
+      if (version.major < 4 || (version.major === 4 && (version.minor ?? 0) <= 5)) {
+        return BUDGET_PROFILE;
+      }
+      return undefined;
+    case 'haiku':
+      if (version.major < 4 || (version.major === 4 && (version.minor ?? 0) <= 5)) {
+        return BUDGET_PROFILE;
+      }
+      return undefined;
+    case 'fable':
+      return version.major === 5 ? ALWAYS_ADAPTIVE_PROFILE : undefined;
+    case 'mythos':
+      return version.major === 5 ? ALWAYS_ADAPTIVE_PROFILE : undefined;
+  }
+}
+
+export function inferAnthropicModelProfile(model: string): AnthropicModelProfile {
+  return matchKnownAnthropicModelProfile(model) ?? LATEST_OPUS_PROFILE;
+}
diff --git a/packages/agent-core-v2/src/app/llmProtocol/providers/anthropic.ts b/packages/agent-core-v2/src/app/llmProtocol/providers/anthropic.ts
index c9a6f297c..011fb34ea 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/providers/anthropic.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/providers/anthropic.ts
@@ -1,3 +1,7 @@
+/**
+ * `llmProtocol` domain (L0) — Anthropic-compatible chat request and response adapter.
+ */
+
 import {
   APIConnectionError,
   APITimeoutError,
@@ -41,6 +45,14 @@ import type {
   ToolUseBlockParam,
 } from '@anthropic-ai/sdk/resources/messages/messages.js';
 
+import {
+  BUDGET_THINKING_EFFORTS,
+  inferAnthropicModelProfile,
+  matchKnownAnthropicModelProfile,
+  parseAnthropicModelVersion,
+  type AnthropicModelProfile,
+  type AnthropicModelVersion,
+} from './anthropic-profile';
 import { mergeConsecutiveUserMessages } from './merge-user-messages';
 import { mergeRequestHeaders, resolveAuthBackedClient } from './request-auth';
 import {
@@ -82,6 +94,7 @@ export interface AnthropicOptions {
   metadata?: Record<string, string> | undefined;
   stream?: boolean | undefined;
   adaptiveThinking?: boolean | undefined;
+  supportEfforts?: readonly string[] | undefined;
   kimiThinking?: boolean | undefined;
   betaApi?: boolean | undefined;
   clientFactory?: (auth: ProviderRequestAuth) => Anthropic;
@@ -102,13 +115,9 @@ interface AnthropicContextManagement {
   edits: Array<{ type: string; keep?: unknown }>;
 }
 
-type AnthropicEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
-
 const INTERLEAVED_THINKING_BETA = 'interleaved-thinking-2025-05-14';
 const CONTEXT_MANAGEMENT_BETA = 'context-management-2025-06-27';
 const CLEAR_THINKING_EDIT = 'clear_thinking_20251015';
-const OPUS_VERSION_RE = /opus[.-](\d+)[.-](\d{1,2})(?!\d)/;
-const ADAPTIVE_MIN_VERSION = { major: 4, minor: 6 } as const;
 const ANTHROPIC_TOOL_CALL_ID_POLICY: ToolCallIdPolicy = {
   normalize: (id) => sanitizeToolCallId(id, 64),
   maxLength: 64,
@@ -137,6 +146,7 @@ function applyResponseFormat(
 
 const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
   'fable-5': 128000,
+  'mythos-5': 128000,
   'opus-4-8': 128000,
   'opus-4-7': 128000,
   'opus-4-6': 128000,
@@ -144,7 +154,8 @@ const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
   'opus-4-1': 32000,
   'opus-4-0': 32000,
   'opus-4': 32000,
-  'sonnet-4-6': 64000,
+  'sonnet-5': 128000,
+  'sonnet-4-6': 128000,
   'sonnet-4-5': 64000,
   'sonnet-4-0': 64000,
   'sonnet-4': 64000,
@@ -159,61 +170,9 @@ const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
   'haiku-3': 4096,
 };
 
-const FALLBACK_MAX_TOKENS = 32000;
+const FALLBACK_MAX_TOKENS = 128000;
 
-type ClaudeFamily = 'opus' | 'sonnet' | 'haiku' | 'fable';
-
-interface ClaudeVersion {
-  family: ClaudeFamily;
-  major: number;
-  minor: number | null;
-}
-
-const FAMILY_FIRST_RE =
-  /(opus|sonnet|haiku|fable)[-._](\d{1,2})(?!\d)(?:[-._](\d{1,2})(?!\d))?/;
-const VERSION_FIRST_RE = /(\d{1,2})[-._](\d{1,2})[-._](opus|sonnet|haiku)/;
-const BARE_FAMILY_RE = /(\d{1,2})[-._](opus|sonnet|haiku)/;
-
-function parseClaudeVersion(model: string): ClaudeVersion | null {
-  return parseClaudeFamilyVersion(model, true);
-}
-
-function parseClaudeAliasVersion(model: string): ClaudeVersion | null {
-  return parseClaudeFamilyVersion(model, false);
-}
-
-function parseClaudeFamilyVersion(model: string, requireClaudeMarker: boolean): ClaudeVersion | null {
-  const normalized = model.toLowerCase();
-  if (requireClaudeMarker && !normalized.includes('claude')) return null;
-
-  const familyFirst = FAMILY_FIRST_RE.exec(normalized);
-  if (familyFirst !== null) {
-    return {
-      family: familyFirst[1] as ClaudeFamily,
-      major: Number.parseInt(familyFirst[2]!, 10),
-      minor: familyFirst[3] !== undefined ? Number.parseInt(familyFirst[3], 10) : null,
-    };
-  }
-  const versionFirst = VERSION_FIRST_RE.exec(normalized);
-  if (versionFirst !== null) {
-    return {
-      major: Number.parseInt(versionFirst[1]!, 10),
-      minor: Number.parseInt(versionFirst[2]!, 10),
-      family: versionFirst[3] as ClaudeFamily,
-    };
-  }
-  const bare = BARE_FAMILY_RE.exec(normalized);
-  if (bare !== null) {
-    return {
-      major: Number.parseInt(bare[1]!, 10),
-      minor: null,
-      family: bare[2] as ClaudeFamily,
-    };
-  }
-  return null;
-}
-
-function lookupClaudeCeiling(version: ClaudeVersion): number | undefined {
+function lookupClaudeCeiling(version: AnthropicModelVersion): number | undefined {
   const { family, major, minor } = version;
   if (minor !== null) {
     for (let candidate = minor; candidate >= 0; candidate--) {
@@ -225,7 +184,7 @@ function lookupClaudeCeiling(version: ClaudeVersion): number | undefined {
 }
 
 export function resolveDefaultMaxTokens(model: string, override?: number): number {
-  const parsed = parseClaudeVersion(model);
+  const parsed = parseAnthropicModelVersion(model, true);
   const ceiling = parsed === null ? undefined : lookupClaudeCeiling(parsed);
   if (ceiling === undefined) {
     return override ?? FALLBACK_MAX_TOKENS;
@@ -233,93 +192,53 @@ export function resolveDefaultMaxTokens(model: string, override?: number): numbe
   return override === undefined ? ceiling : Math.min(override, ceiling);
 }
 
-function parseVersion(match: RegExpExecArray): { major: number; minor: number } {
-  const majorRaw = match[1];
-  const minorRaw = match[2];
-  if (majorRaw === undefined || minorRaw === undefined) {
-    throw new Error('Model version regex did not capture major and minor versions.');
-  }
-  return { major: Number.parseInt(majorRaw, 10), minor: Number.parseInt(minorRaw, 10) };
-}
-
-function versionAtLeast(
-  version: { major: number; minor: number },
-  minimum: { major: number; minor: number },
-): boolean {
-  return (
-    version.major > minimum.major ||
-    (version.major === minimum.major && version.minor >= minimum.minor)
+function requiresAdaptiveThinking(efforts: readonly string[]): boolean {
+  return efforts.some(
+    (effort) => effort !== 'low' && effort !== 'medium' && effort !== 'high',
   );
 }
 
-function supportsAdaptiveThinking(model: string): boolean {
-  const version = parseClaudeAliasVersion(model);
-  if (version === null) {
-    return false;
+function resolveThinkingProfile(
+  model: string,
+  supportEfforts: readonly string[] | undefined,
+  adaptiveThinking: boolean | undefined,
+): AnthropicModelProfile {
+  const inferred = inferAnthropicModelProfile(model);
+  if (adaptiveThinking === false) {
+    return {
+      ...inferred,
+      mode: 'budget',
+      efforts: supportEfforts ?? BUDGET_THINKING_EFFORTS,
+      supportsEffortParam: false,
+    };
   }
-  return versionAtLeast(
-    { major: version.major, minor: version.minor ?? 0 },
-    ADAPTIVE_MIN_VERSION,
-  );
+
+  if (adaptiveThinking === true) {
+    return {
+      ...inferred,
+      mode: 'adaptive',
+      efforts: supportEfforts ?? inferred.efforts,
+      supportsEffortParam: true,
+    };
+  }
+
+  if (supportEfforts === undefined) {
+    return inferred;
+  }
+  return {
+    ...inferred,
+    mode: requiresAdaptiveThinking(supportEfforts) ? 'adaptive' : inferred.mode,
+    efforts: supportEfforts,
+    supportsEffortParam:
+      requiresAdaptiveThinking(supportEfforts) || inferred.supportsEffortParam,
+  };
 }
 
-function isOpus47(model: string): boolean {
-  const match = OPUS_VERSION_RE.exec(model.toLowerCase());
-  if (match === null) {
-    return false;
-  }
-  const version = parseVersion(match);
-  return version.major === 4 && version.minor === 7;
-}
-
-function isFableModel(model: string): boolean {
-  return parseClaudeAliasVersion(model)?.family === 'fable';
-}
-
-function supportsEffortParam(model: string, adaptive: boolean): boolean {
-  if (adaptive) {
-    return true;
-  }
-  const normalized = model.toLowerCase();
-  return normalized.includes('opus-4-5') || normalized.includes('opus-4.5');
-}
-
-function clampEffort(effort: ThinkingEffort, model: string, adaptive: boolean): ThinkingEffort {
-  if (effort === 'off') {
-    return effort;
-  }
-  if (effort === 'xhigh' && !isOpus47(model) && !isFableModel(model)) {
-    return 'high';
-  }
-  if (effort === 'max' && !adaptive) {
-    return 'high';
-  }
-  if (
-    effort !== 'low' &&
-    effort !== 'medium' &&
-    effort !== 'high' &&
-    effort !== 'xhigh' &&
-    effort !== 'max'
-  ) {
-    return 'high';
-  }
-  return effort;
-}
-
-function budgetTokensForEffort(effort: ThinkingEffort): number {
-  switch (effort) {
-    case 'low':
-      return 1024;
-    case 'medium':
-      return 4096;
-    case 'high':
-      return 32_000;
-    case 'off':
-    case 'xhigh':
-    case 'max':
-      throw new Error(`Unsupported budget-based thinking effort: ${effort}`);
-  }
-  throw new Error(`Unknown thinking effort: ${String(effort)}`);
+function budgetTokensForEffort(effort: ThinkingEffort): number | undefined {
+  if (effort === 'low') return 1024;
+  if (effort === 'medium') return 4096;
+  if (effort === 'on' || effort === 'high') return 32_000;
+  return undefined;
 }
 
 const CACHE_CONTROL = { type: 'ephemeral' as const };
@@ -327,7 +246,10 @@ const CACHE_CONTROL = { type: 'ephemeral' as const };
 type CacheableBlock = ContentBlockParam & { cache_control?: { type: 'ephemeral' } };
 
 function shouldPreserveUnsignedThinking(model: string): boolean {
-  return parseClaudeAliasVersion(model) === null;
+  return (
+    parseAnthropicModelVersion(model) === null &&
+    matchKnownAnthropicModelProfile(model) === undefined
+  );
 }
 
 const CACHEABLE_TYPES = new Set([
@@ -551,6 +473,11 @@ function convertMessage(message: Message, model: string): MessageParam {
 
   return { role: role, content: blocks };
 }
+
+function shouldKeepConvertedMessage(message: MessageParam): boolean {
+  return message.role !== 'assistant' || message.content.length > 0;
+}
+
 export function convertAnthropicError(error: unknown): ChatProviderError {
   if (error instanceof AnthropicTimeoutError) {
     return new APITimeoutError(error.message);
@@ -740,7 +667,7 @@ class AnthropicStreamedMessage implements StreamedMessage {
               yield { type: 'text', text: block.text };
               break;
             case 'thinking':
-              yield { type: 'think', think: block.thinking };
+              yield { type: 'think', think: block.thinking ?? '' };
               break;
             case 'redacted_thinking':
               yield {
@@ -770,7 +697,7 @@ class AnthropicStreamedMessage implements StreamedMessage {
               yield { type: 'text', text: delta.text };
               break;
             case 'thinking_delta':
-              yield { type: 'think', think: delta.thinking };
+              yield { type: 'think', think: delta.thinking ?? '' };
               break;
             case 'input_json_delta':
               yield {
@@ -830,6 +757,7 @@ export class AnthropicChatProvider implements ChatProvider {
   private _defaultHeaders: Record<string, string | null> | undefined;
   private _clientFactory: ((auth: ProviderRequestAuth) => Anthropic) | undefined;
   private _adaptiveThinking: boolean | undefined;
+  private readonly _supportEfforts: readonly string[] | undefined;
   private readonly _kimiThinking: boolean;
   private _betaApi: boolean;
   private _explicitMaxTokens: boolean;
@@ -839,6 +767,7 @@ export class AnthropicChatProvider implements ChatProvider {
     this._stream = options.stream ?? true;
     this._metadata = options.metadata;
     this._adaptiveThinking = options.adaptiveThinking;
+    this._supportEfforts = options.supportEfforts;
     this._kimiThinking = options.kimiThinking ?? false;
     this._betaApi = options.betaApi ?? false;
     this._apiKey =
@@ -917,9 +846,9 @@ export class AnthropicChatProvider implements ChatProvider {
       normalizeToolCallIdsForProvider(
         history.filter((msg) => !isToolDeclarationOnlyMessage(msg)),
         ANTHROPIC_TOOL_CALL_ID_POLICY,
-      ).map((msg) =>
-        convertMessage(msg, this._model),
-      ),
+      )
+        .map((msg) => convertMessage(msg, this._model))
+        .filter(shouldKeepConvertedMessage),
       {
         isUser: (message) => message.role === 'user',
         isToolResultOnly,
@@ -949,7 +878,7 @@ export class AnthropicChatProvider implements ChatProvider {
       kwargs['top_p'] = this._generationKwargs.top_p;
     }
     const thinking = this._generationKwargs.thinking;
-    if (thinking !== undefined && !(thinking.type === 'disabled' && isFableModel(this._model))) {
+    if (thinking !== undefined) {
       kwargs['thinking'] = thinking;
     }
     if (this._generationKwargs.output_config !== undefined) {
@@ -1096,11 +1025,15 @@ export class AnthropicChatProvider implements ChatProvider {
   }
 
   withThinking(effort: ThinkingEffort): AnthropicChatProvider {
-    const adaptive = this._adaptiveThinking ?? supportsAdaptiveThinking(this._model);
+    const profile = resolveThinkingProfile(
+      this._model,
+      this._supportEfforts,
+      this._kimiThinking ? true : this._adaptiveThinking,
+    );
 
     if (effort === 'off') {
       let newBetas = [...(this._generationKwargs.betaFeatures ?? [])];
-      if (adaptive) {
+      if (profile.mode === 'adaptive') {
         newBetas = newBetas.filter((b) => b !== INTERLEAVED_THINKING_BETA);
       }
       const clone = this._withGenerationKwargs({
@@ -1112,7 +1045,7 @@ export class AnthropicChatProvider implements ChatProvider {
     }
 
     let newBetas = [...(this._generationKwargs.betaFeatures ?? [])];
-    if (adaptive) {
+    if (profile.mode === 'adaptive') {
       newBetas = newBetas.filter((b) => b !== INTERLEAVED_THINKING_BETA);
     }
     if (this._kimiThinking) {
@@ -1130,31 +1063,32 @@ export class AnthropicChatProvider implements ChatProvider {
       return clone;
     }
 
-    const clamped = clampEffort(effort, this._model, adaptive);
-    if (clamped === 'off') {
-      throw new Error('Non-off thinking effort unexpectedly clamped to off.');
-    }
-    const effectiveEffort = clamped as AnthropicEffort;
-
-    if (adaptive) {
+    if (profile.mode === 'adaptive') {
       return this._withGenerationKwargs({
         thinking: { type: 'adaptive', display: 'summarized' },
-        output_config: { effort: effectiveEffort },
+        output_config:
+          effort === 'on'
+            ? undefined
+            : ({ effort } as MessageCreateParams['output_config']),
         betaFeatures: newBetas,
       });
     }
 
+    const budgetTokens = budgetTokensForEffort(effort);
     const kwargs: Partial<AnthropicGenerationKwargs> = {
-      thinking: { type: 'enabled', budget_tokens: budgetTokensForEffort(effectiveEffort) },
+      thinking:
+        budgetTokens === undefined
+          ? ({ type: 'enabled' } as MessageCreateParams['thinking'])
+          : { type: 'enabled', budget_tokens: budgetTokens },
       betaFeatures: newBetas,
     };
-    if (supportsEffortParam(this._model, adaptive)) {
-      kwargs.output_config = { effort: effectiveEffort };
+    if ((profile.supportsEffortParam || budgetTokens === undefined) && effort !== 'on') {
+      kwargs.output_config = { effort } as MessageCreateParams['output_config'];
     } else {
       kwargs.output_config = undefined;
     }
     const clone = this._withGenerationKwargs(kwargs);
-    if (!supportsEffortParam(this._model, adaptive)) {
+    if (!profile.supportsEffortParam && budgetTokens !== undefined) {
       delete clone._generationKwargs.output_config;
     }
     return clone;
diff --git a/packages/agent-core-v2/src/app/llmProtocol/providers/google-genai.ts b/packages/agent-core-v2/src/app/llmProtocol/providers/google-genai.ts
index 893bf9d93..c7b998aed 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/providers/google-genai.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/providers/google-genai.ts
@@ -141,8 +141,9 @@ interface GooglePart {
 function toolCallIdToName(toolCallId: string, toolNameById: Map<string, string>): string {
   const name = toolNameById.get(toolCallId);
   if (name !== undefined) return name;
-  const match = /^(.+)_[^_]+$/.exec(toolCallId);
-  return match?.[1] ?? toolCallId;
+  const withoutEntropy = toolCallId.replace(/_[0-9a-f]{8}$/, '');
+  const match = /^(.+)_[^_]+$/.exec(withoutEntropy);
+  return match?.[1] ?? withoutEntropy;
 }
 
 function convertMediaUrl(
@@ -510,7 +511,7 @@ export class GoogleGenAIStreamedMessage implements StreamedMessage {
           const name = fc['name'] as string;
           if (!name) continue;
           const id_ = (fc['id'] as string) ?? crypto.randomUUID();
-          const toolCallId = `${name}_${id_}`;
+          const toolCallId = `${name}_${id_}_${crypto.randomUUID().replaceAll('-', '').slice(0, 8)}`;
           const thoughtSigB64 = p['thoughtSignature'] ?? p['thought_signature'];
           const toolCall: ToolCall = {
             type: 'function',
diff --git a/packages/agent-core-v2/src/app/llmProtocol/providers/kimi.ts b/packages/agent-core-v2/src/app/llmProtocol/providers/kimi.ts
index c77e6fc10..e02bb343f 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/providers/kimi.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/providers/kimi.ts
@@ -30,6 +30,7 @@ import {
   type OpenAIToolParam,
   toolToOpenAI,
 } from './openai-common';
+import { parseTraceId } from '../errors';
 import {
   mergeRequestHeaders,
   requireProviderApiKey,
@@ -232,6 +233,7 @@ class KimiStreamedMessage implements StreamedMessage {
   constructor(
     response: OpenAI.Chat.ChatCompletion | AsyncIterable<OpenAI.Chat.ChatCompletionChunk>,
     isStream: boolean,
+    private readonly _traceId: string | null,
   ) {
     if (isStream) {
       this._iter = this._convertStreamResponse(
@@ -258,6 +260,10 @@ class KimiStreamedMessage implements StreamedMessage {
     return this._rawFinishReason;
   }
 
+  get traceId(): string | null {
+    return this._traceId;
+  }
+
   async *[Symbol.asyncIterator](): AsyncIterator<StreamedMessagePart> {
     yield* this._iter;
   }
@@ -483,11 +489,21 @@ export class KimiChatProvider implements ChatProvider {
     try {
       const client = this._createClient(options?.auth);
       options?.onRequestSent?.();
-      const response = (await client.chat.completions.create(
-        createParams as unknown as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming,
-        options?.signal ? { signal: options.signal } : undefined,
-      )) as unknown as OpenAI.Chat.ChatCompletion | AsyncIterable<OpenAI.Chat.ChatCompletionChunk>;
-      return new KimiStreamedMessage(response, this._stream);
+      // `withResponse()` resolves as soon as the response headers arrive
+      // (before the stream body), so the trace id is available mid-stream.
+      const { data, response } = await client.chat.completions
+        .create(
+          createParams as unknown as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming,
+          options?.signal ? { signal: options.signal } : undefined,
+        )
+        .withResponse();
+      return new KimiStreamedMessage(
+        data as unknown as
+          | OpenAI.Chat.ChatCompletion
+          | AsyncIterable<OpenAI.Chat.ChatCompletionChunk>,
+        this._stream,
+        parseTraceId(response.headers),
+      );
     } catch (error: unknown) {
       throw convertOpenAIError(error);
     }
diff --git a/packages/agent-core-v2/src/app/llmProtocol/providers/openai-common.ts b/packages/agent-core-v2/src/app/llmProtocol/providers/openai-common.ts
index 6538845b9..9322a02a4 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/providers/openai-common.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/providers/openai-common.ts
@@ -5,6 +5,7 @@ import {
   classifyBaseApiError,
   normalizeAPIStatusError,
   parseRetryAfterMs,
+  parseTraceId,
 } from '../errors';
 import { extractText } from '../message';
 import type { ContentPart, Message } from '../message';
@@ -96,6 +97,7 @@ export function convertOpenAIError(error: unknown): ChatProviderError {
       error.message,
       reqId,
       parseRetryAfterMs(error.headers),
+      parseTraceId(error.headers),
     );
   }
   if (
diff --git a/packages/agent-core-v2/src/app/llmProtocol/providers/openai-legacy.ts b/packages/agent-core-v2/src/app/llmProtocol/providers/openai-legacy.ts
index 421cc2f31..8f6b4b034 100644
--- a/packages/agent-core-v2/src/app/llmProtocol/providers/openai-legacy.ts
+++ b/packages/agent-core-v2/src/app/llmProtocol/providers/openai-legacy.ts
@@ -433,7 +433,7 @@ export class OpenAILegacyChatProvider implements ChatProvider {
   private _baseUrl: string | undefined;
   private _defaultHeaders: Record<string, string> | undefined;
   private _reasoningKey: string | undefined;
-  private _reasoningEffort: string | undefined;
+  private _thinkingEffort: ThinkingEffort | undefined;
   private _generationKwargs: OpenAILegacyGenerationKwargs;
   private _toolMessageConversion: ToolMessageConversion;
   private _client: OpenAI | undefined;
@@ -452,7 +452,7 @@ export class OpenAILegacyChatProvider implements ChatProvider {
       normalizedReasoningKey !== undefined && normalizedReasoningKey.length > 0
         ? normalizedReasoningKey
         : undefined;
-    this._reasoningEffort = undefined;
+    this._thinkingEffort = undefined;
     this._generationKwargs =
       options.maxTokens !== undefined ? completionTokenKwargs(this._model, options.maxTokens) : {};
     this._toolMessageConversion = options.toolMessageConversion ?? null;
@@ -467,8 +467,7 @@ export class OpenAILegacyChatProvider implements ChatProvider {
   }
 
   get thinkingEffort(): ThinkingEffort | null {
-    if (this._reasoningEffort === undefined) return null;
-    return this._reasoningEffort === 'none' ? 'off' : this._reasoningEffort;
+    return this._thinkingEffort ?? null;
   }
 
   get maxCompletionTokens(): number | undefined {
@@ -506,9 +505,19 @@ export class OpenAILegacyChatProvider implements ChatProvider {
       this._generationKwargs,
     );
 
-    let reasoningEffort: string | undefined = this._reasoningEffort;
+    // 'off' and 'on' have no wire encoding; only a concrete effort is passed
+    // through. An explicit 'off' must also suppress the history-based
+    // auto-enable below (issue #1616), so it stays distinguishable from
+    // "never configured".
+    const effort = this._thinkingEffort;
+    let reasoningEffort: string | undefined =
+      effort === undefined || effort === 'off' || effort === 'on' ? undefined : effort;
 
-    if (reasoningEffort === undefined && kwargs['reasoning_effort'] === undefined) {
+    if (
+      reasoningEffort === undefined &&
+      effort !== 'off' &&
+      kwargs['reasoning_effort'] === undefined
+    ) {
       const hasThinkPart = history.some((message) =>
         message.content.some((part) => part.type === 'think'),
       );
@@ -560,9 +569,8 @@ export class OpenAILegacyChatProvider implements ChatProvider {
   }
 
   withThinking(effort: ThinkingEffort): OpenAILegacyChatProvider {
-    const reasoningEffort = effort === 'off' || effort === 'on' ? undefined : effort;
     const clone = this._clone();
-    clone._reasoningEffort = reasoningEffort;
+    clone._thinkingEffort = effort;
     return clone;
   }
 
diff --git a/packages/agent-core-v2/src/app/llmProtocol/requestTrace.ts b/packages/agent-core-v2/src/app/llmProtocol/requestTrace.ts
new file mode 100644
index 000000000..573348e84
--- /dev/null
+++ b/packages/agent-core-v2/src/app/llmProtocol/requestTrace.ts
@@ -0,0 +1,10 @@
+/**
+ * `llmProtocol` domain (L1) — live request provenance contract.
+ *
+ * Exposes the provider trace identifier of one logical LLM request while its
+ * result is still pending. Pure contract (types only); no scoped service.
+ */
+
+export interface LLMRequestTrace {
+  readonly traceId: string | undefined;
+}
diff --git a/packages/agent-core-v2/src/app/messageLegacy/messageLegacy.ts b/packages/agent-core-v2/src/app/messageLegacy/messageLegacy.ts
index e36ca0834..778337452 100644
--- a/packages/agent-core-v2/src/app/messageLegacy/messageLegacy.ts
+++ b/packages/agent-core-v2/src/app/messageLegacy/messageLegacy.ts
@@ -7,29 +7,34 @@
  * The native `IAgentContextMemoryService` (Agent scope, serving `/api/v2`
  * `messages:*`) holds the model's CURRENT, folded context and is NOT the full
  * transcript: after a compaction it collapses into `[...keptUserMessages,
- * compaction_summary]`. The full transcript is reduced from the main agent's
- * in-memory record journal (`IAgentWireRecordService.getRecords()`), which
- * `ISessionLifecycleService.resume` seeds from `wire.jsonl` and live dispatch
- * then keeps current — so neither a live nor a cold session is read back from
- * disk here. The `ContextMessage → Message` projection is shared with the
- * `snapshot` and `:undo` edges via `contextMemory/messageProjection`. Bound at
- * App scope — a stateless dispatcher that resolves the target session/agent per
- * call.
+ * compaction_summary]`. The full transcript is reduced on demand by streaming
+ * the main agent's `wire.jsonl`; the service does not make every live Agent
+ * retain its raw journal in memory. The `ContextMessage → Message` projection
+ * is shared with the `snapshot` and `:undo` edges via
+ * `contextMemory/messageProjection`. Bound at App scope — a stateless
+ * dispatcher that resolves the target session/agent per call.
  *
  * Error contract (mapped at the route layer):
  *   - `session.not_found`  → 40401
  *   - `message.not_found`  → 40403
  */
 
-import type {
-  CursorQuery,
-  Message,
-  MessageRole,
-  PageResponse,
-} from '@moonshot-ai/protocol';
+import type { Message, MessageRole } from '#/agent/contextMemory/protocolMessage';
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 
+/** Cursor pagination query shared by the v1 history/list endpoints. */
+export interface CursorQuery {
+  before_id?: string | undefined;
+  after_id?: string | undefined;
+  page_size?: number | undefined;
+}
+
+export interface PageResponse<T> {
+  items: T[];
+  has_more: boolean;
+}
+
 export interface MessageListQuery extends CursorQuery {
   readonly role?: MessageRole;
 }
diff --git a/packages/agent-core-v2/src/app/messageLegacy/messageLegacyService.ts b/packages/agent-core-v2/src/app/messageLegacy/messageLegacyService.ts
index be1606f58..8d025f8ac 100644
--- a/packages/agent-core-v2/src/app/messageLegacy/messageLegacyService.ts
+++ b/packages/agent-core-v2/src/app/messageLegacy/messageLegacyService.ts
@@ -5,13 +5,10 @@
  * its main agent), sources the transcript, and projects it into the v1 wire
  * shape.
  *
- * History source is the main agent's in-memory record journal
- * (`IAgentWireRecordService.getRecords()`), seeded from `wire.jsonl` by
- * `ISessionLifecycleService.resume` and then kept current as live dispatch
- * appends each record — so a transcript read never re-reads the file. The
- * journal is reduced by `reduceContextTranscript` (the same reducer v1's
- * `MessageService` uses), which keeps the full history across compactions
- * (inserting a summary marker instead of folding) — unlike the live
+ * History is streamed from the main agent's append log after its pending wire
+ * writes are flushed. The journal is folded incrementally by the same
+ * transcript reducer v1's `MessageService` uses, keeping full history across
+ * compactions (inserting a summary marker instead of folding) — unlike the live
  * `IAgentContextMemoryService.get()`, whose folded context collapses into
  * `[...keptUserMessages, compaction_summary]` and would lose the prefix.
  * `foldedLength` is what the live history length WOULD be from the journal's
@@ -21,24 +18,28 @@
  * (`packages/agent-core/src/services/message/messageService.ts`).
  */
 
-import type { Message, PageResponse } from '@moonshot-ai/protocol';
+import type { Message } from '#/agent/contextMemory/protocolMessage';
+
+import type { PageResponse } from './messageLegacy';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { type IAgentScopeHandle, LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { IAgentBlobService } from '#/agent/blob/agentBlobService';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import {
-  reduceContextTranscript,
+  createContextTranscriptReducer,
   type ContextTranscript,
 } from '#/agent/contextMemory/contextTranscript';
 import { toProtocolMessage } from '#/agent/contextMemory/messageProjection';
 import type { ContextMessage } from '#/agent/contextMemory/types';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
+import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
 import { ISessionIndex } from '#/app/sessionIndex/sessionIndex';
 import { ISessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycle';
 import { ErrorCodes, Error2 } from '#/errors';
 import { ensureMainAgent } from '#/session/agentLifecycle/mainAgent';
-import type { PersistedRecord } from '#/wire/wireService';
 
 import { IMessageLegacyService, type MessageListQuery } from './messageLegacy';
 
@@ -51,6 +52,7 @@ export class MessageLegacyService implements IMessageLegacyService {
   constructor(
     @ISessionLifecycleService private readonly lifecycle: ISessionLifecycleService,
     @ISessionIndex private readonly index: ISessionIndex,
+    @IAppendLogStore private readonly appendLog: IAppendLogStore,
   ) {}
 
   async list(sessionId: string, query: MessageListQuery): Promise<PageResponse<Message>> {
@@ -105,7 +107,7 @@ export class MessageLegacyService implements IMessageLegacyService {
     if (session === undefined) return [];
     const agent = await ensureMainAgent(session);
 
-    const transcript = this.readTranscript(agent);
+    const transcript = await this.readTranscript(agent);
     const contextMessages = agent.accessor.get(IAgentContextMemoryService).get();
     const merged = mergeLiveTail(transcript, contextMessages);
     const entries = await this.rehydrate(agent, merged.messages);
@@ -143,11 +145,14 @@ export class MessageLegacyService implements IMessageLegacyService {
     return changed ? out : messages;
   }
 
-  private readTranscript(agent: IAgentScopeHandle): ContextTranscript {
-    const records = agent
-      .accessor.get(IAgentWireRecordService)
-      .getRecords() as readonly PersistedRecord[];
-    return reduceContextTranscript(records);
+  private async readTranscript(agent: IAgentScopeHandle): Promise<ContextTranscript> {
+    await agent.accessor.get(IWireService).flush();
+    const scope = agent.accessor.get(IAgentScopeContext).scope();
+    const reducer = createContextTranscriptReducer();
+    for await (const record of this.appendLog.read<WireRecord>(scope, AGENT_WIRE_RECORD_KEY)) {
+      reducer.add(record);
+    }
+    return reducer.result();
   }
 }
 
diff --git a/packages/agent-core-v2/src/app/model/modelAuth.ts b/packages/agent-core-v2/src/app/model/modelAuth.ts
index fad5e2587..852b864a4 100644
--- a/packages/agent-core-v2/src/app/model/modelAuth.ts
+++ b/packages/agent-core-v2/src/app/model/modelAuth.ts
@@ -4,11 +4,20 @@
  * Resolves Model / Provider / Platform credential precedence for runtime
  * model resolution and auth-readiness probes. Pure computation; callers
  * supply the Platform lookup so this file stays outside the service graph.
+ * The inferred Anthropic effort profile is reserved for non-Kimi
+ * Anthropic-compatible providers; Kimi providers — including managed models
+ * routed through protocol = "anthropic" — keep only catalog-declared effort
+ * metadata.
  */
 
 import { ErrorCodes, Error2 } from '#/errors';
+import {
+  BUDGET_THINKING_EFFORTS,
+  inferAnthropicModelProfile,
+  matchKnownAnthropicModelProfile,
+} from '#/app/llmProtocol/providers/anthropic-profile';
 import { type PlatformConfig, UNKNOWN_PLATFORM_KEY } from '#/app/platform/platform';
-import type { OAuthRef, ProviderConfig } from '#/app/provider/provider';
+import type { OAuthRef, ProviderConfig, ProviderType } from '#/app/provider/provider';
 import type { Protocol } from '#/app/protocol/protocol';
 
 import type { ModelConfig } from './model';
@@ -70,19 +79,48 @@ export function resolveModelAuthMaterial(args: {
   return {};
 }
 
-export function effectiveModelConfig(model: ModelConfig): ModelConfig {
+export function effectiveModelConfig(
+  model: ModelConfig,
+  providerType?: ProviderType,
+): ModelConfig {
   const { overrides, ...base } = model;
-  if (overrides === undefined) return model;
-  const effective: ModelConfig = { ...base, ...overrides };
+  const effective: ModelConfig = overrides === undefined ? model : { ...base, ...overrides };
   if (
-    overrides.supportEfforts !== undefined &&
+    overrides?.supportEfforts !== undefined &&
     overrides.defaultEffort === undefined &&
     effective.defaultEffort !== undefined &&
     !overrides.supportEfforts.includes(effective.defaultEffort)
   ) {
     delete effective.defaultEffort;
   }
-  return effective;
+  return withAnthropicProfile(effective, providerType);
+}
+
+function withAnthropicProfile(model: ModelConfig, providerType?: ProviderType): ModelConfig {
+  const wireName = model.name ?? model.model;
+  const protocol = model.protocol ?? providerType;
+  const profile =
+    wireName === undefined
+      ? undefined
+      : providerType !== undefined && providerType !== 'kimi' && protocol === 'anthropic'
+        ? inferAnthropicModelProfile(wireName)
+        : matchKnownAnthropicModelProfile(wireName);
+  if (profile === undefined) return model;
+  const capability = profile.canDisableThinking ? 'thinking' : 'always_thinking';
+  const capabilities = model.capabilities ?? [];
+  const hasCapability = capabilities.some(
+    (candidate) => candidate.trim().toLowerCase() === capability,
+  );
+  const supportEfforts =
+    model.supportEfforts ??
+    (model.adaptiveThinking === false ? [...BUDGET_THINKING_EFFORTS] : [...profile.efforts]);
+  return {
+    ...model,
+    capabilities: hasCapability ? capabilities : [...capabilities, capability],
+    supportEfforts,
+    defaultEffort:
+      model.defaultEffort ?? (supportEfforts.includes('high') ? 'high' : undefined),
+  };
 }
 
 export function deriveProviderId(baseUrl: string): string {
diff --git a/packages/agent-core-v2/src/app/model/modelImpl.ts b/packages/agent-core-v2/src/app/model/modelImpl.ts
index b0b1608d1..f576a2237 100644
--- a/packages/agent-core-v2/src/app/model/modelImpl.ts
+++ b/packages/agent-core-v2/src/app/model/modelImpl.ts
@@ -37,7 +37,7 @@ import { sanitizeStatusErrorMessage, translateProviderError } from '#/app/protoc
 import { type ProtocolAdapterRegistry } from '#/app/protocol/protocolAdapterRegistry';
 import { ErrorCodes, Error2 } from '#/errors';
 
-import type { AuthProvider, LLMEvent, LLMRequestInput, Model } from './modelInstance';
+import type { AuthProvider, LLMEvent, LLMRequestInput, Model, ModelRequestOptions } from './modelInstance';
 
 export interface ModelImplInit {
   readonly id: string;
@@ -198,9 +198,13 @@ export class ModelImpl implements Model {
     return provider;
   }
 
-  request(input: LLMRequestInput, signal?: AbortSignal): AsyncIterable<LLMEvent> {
+  request(
+    input: LLMRequestInput,
+    signal?: AbortSignal,
+    options?: ModelRequestOptions,
+  ): AsyncIterable<LLMEvent> {
     const queue = new AsyncEventQueue<LLMEvent>();
-    void this.runRequest(input, signal, queue).then(
+    void this.runRequest(input, signal, queue, options).then(
       () => queue.end(),
       (error) => queue.fail(error),
     );
@@ -227,6 +231,7 @@ export class ModelImpl implements Model {
     input: LLMRequestInput,
     signal: AbortSignal | undefined,
     queue: AsyncEventQueue<LLMEvent>,
+    options?: ModelRequestOptions,
   ): Promise<void> {
     signal?.throwIfAborted();
     const provider = this.resolveChatProvider();
@@ -269,6 +274,7 @@ export class ModelImpl implements Model {
               streamEndedAt = Date.now();
               decodeStats = stats;
             },
+            onTraceId: options?.onTraceId,
             responseFormat: input.responseFormat,
           },
         );
@@ -298,6 +304,7 @@ export class ModelImpl implements Model {
       providerFinishReason: result.finishReason ?? undefined,
       rawFinishReason: result.rawFinishReason ?? undefined,
       id: result.id ?? undefined,
+      traceId: result.traceId ?? undefined,
     });
     if (firstChunkAt !== undefined) {
       queue.push({
diff --git a/packages/agent-core-v2/src/app/model/modelInstance.ts b/packages/agent-core-v2/src/app/model/modelInstance.ts
index 7f4fb6d47..19951f41d 100644
--- a/packages/agent-core-v2/src/app/model/modelInstance.ts
+++ b/packages/agent-core-v2/src/app/model/modelInstance.ts
@@ -50,6 +50,7 @@ export type LLMEvent =
       readonly providerFinishReason?: FinishReason;
       readonly rawFinishReason?: string;
       readonly id?: string;
+      readonly traceId?: string;
     }
   | {
       readonly type: 'timing';
@@ -61,6 +62,14 @@ export type LLMEvent =
       readonly clientConsumeMs?: number;
     };
 
+export interface ModelRequestOptions {
+  /**
+   * Called as soon as the response headers arrive (before the stream body),
+   * with the provider's trace id — `null` when the protocol has none.
+   */
+  readonly onTraceId?: (traceId: string | null) => void;
+}
+
 export interface Model {
   readonly id: string;
   readonly name: string;
@@ -94,7 +103,11 @@ export interface Model {
 
   withThinkingKeep(keep: string): Model;
 
-  request(input: LLMRequestInput, signal?: AbortSignal): AsyncIterable<LLMEvent>;
+  request(
+    input: LLMRequestInput,
+    signal?: AbortSignal,
+    options?: ModelRequestOptions,
+  ): AsyncIterable<LLMEvent>;
 
   uploadVideo?(
     input: string | VideoUploadInput,
diff --git a/packages/agent-core-v2/src/app/model/modelResolverService.ts b/packages/agent-core-v2/src/app/model/modelResolverService.ts
index 8eb737e57..a7d7b1e9a 100644
--- a/packages/agent-core-v2/src/app/model/modelResolverService.ts
+++ b/packages/agent-core-v2/src/app/model/modelResolverService.ts
@@ -84,9 +84,14 @@ export class ModelResolverService extends Disposable implements IModelResolver {
         `Model "${id}" is not configured in config.toml.`,
       );
     }
-    const model = effectiveModelConfig(configuredModel);
-
-    const { providerConfig, providerName, resolvedBaseUrl: rawBaseUrl } = this.resolveProviderContext(id, model);
+    const routingModel = effectiveModelConfig(configuredModel);
+    const { providerConfig, providerName, resolvedBaseUrl: rawBaseUrl } =
+      this.resolveProviderContext(id, routingModel);
+    const protocol = this.resolveProtocol(id, routingModel, providerConfig);
+    const model = effectiveModelConfig(
+      configuredModel,
+      providerConfig?.type ?? configuredModel.protocol,
+    );
     const auth = resolveModelAuthMaterial({
       modelId: id,
       model,
@@ -96,7 +101,6 @@ export class ModelResolverService extends Disposable implements IModelResolver {
     });
     const authProvider = this.buildAuthProvider(providerName, auth);
 
-    const protocol = this.resolveProtocol(id, model, providerConfig);
     const providerType = providerConfig?.type ?? protocol;
     const resolvedBaseUrl =
       model.protocol === 'anthropic' && rawBaseUrl !== undefined
@@ -160,14 +164,16 @@ export class ModelResolverService extends Disposable implements IModelResolver {
     const effort = this.resolveDefaultThinking(
       model,
       alwaysThinking,
+      protocol === 'kimi',
       providerType === 'kimi',
     );
-    return effort === 'off' ? impl : impl.withThinking(effort);
+    return effort === 'off' && protocol !== 'anthropic' ? impl : impl.withThinking(effort);
   }
 
   private resolveDefaultThinking(
     model: ModelConfig,
     alwaysThinking: boolean,
+    kimiProtocol: boolean,
     kimiProvider: boolean,
   ): ThinkingEffort {
     const thinking = this.config.get<ThinkingSection | undefined>('thinking');
@@ -178,7 +184,7 @@ export class ModelResolverService extends Disposable implements IModelResolver {
         effort: thinking?.effort,
       },
       { ...model, alwaysThinking },
-      kimiProvider,
+      kimiProtocol,
     );
     return (
       resolveKimiThinkingEffortOverride(thinking?.forcedEffort, effort, kimiProvider) ?? effort
@@ -315,7 +321,9 @@ function resolveModelCapabilities(
     thinking: declared.has('thinking') || declared.has('always_thinking') || detected.thinking,
     tool_use: declared.has('tool_use') || detected.tool_use,
     max_context_tokens: maxContextSize,
-    select_tools: declared.has('select_tools') || detected.select_tools === true,
+    dynamically_loaded_tools:
+      declared.has('dynamically_loaded_tools') ||
+      detected.dynamically_loaded_tools === true,
   };
 }
 
@@ -334,6 +342,7 @@ function buildProtocolProviderOptions(
   switch (protocol) {
     case 'anthropic':
       if (model.maxOutputSize !== undefined) options.defaultMaxTokens = model.maxOutputSize;
+      if (model.supportEfforts !== undefined) options.supportEfforts = model.supportEfforts;
       if (model.adaptiveThinking !== undefined) options.adaptiveThinking = model.adaptiveThinking;
       if (provider?.type === 'kimi') options.kimiThinking = true;
       if (model.betaApi !== undefined) options.betaApi = model.betaApi;
diff --git a/packages/agent-core-v2/src/app/model/thinking.ts b/packages/agent-core-v2/src/app/model/thinking.ts
index b9fac6f3a..a46054b21 100644
--- a/packages/agent-core-v2/src/app/model/thinking.ts
+++ b/packages/agent-core-v2/src/app/model/thinking.ts
@@ -102,9 +102,9 @@ export function defaultThinkingEffortForModel(
 export function modelSupportsThinkingEffort(
   effort: ThinkingEffort,
   model: ModelThinkingMetadata | undefined,
-  kimiProvider: boolean,
+  kimiProtocol: boolean,
 ): boolean {
-  if (!kimiProvider || effort === 'off') return true;
+  if (!kimiProtocol || effort === 'off') return true;
   if (!modelSupportsThinking(model)) return false;
   const efforts = effortsFor(model);
   return efforts.length === 0 || effort === 'on' || efforts.includes(effort);
@@ -113,11 +113,11 @@ export function modelSupportsThinkingEffort(
 function normalizeThinkingEffortForModel(
   effort: ThinkingEffort,
   model: ModelThinkingMetadata | undefined,
-  kimiProvider: boolean,
+  kimiProtocol: boolean,
 ): ThinkingEffort {
   if (effort === 'off' && model?.alwaysThinking !== true) return 'off';
   const efforts = effortsFor(model);
-  if (!kimiProvider) {
+  if (!kimiProtocol) {
     return effort === 'on' && efforts.length > 0
       ? defaultThinkingEffortForModel(model)
       : effort;
@@ -134,7 +134,7 @@ export function resolveThinkingEffortForModel(
   requested: string | undefined,
   defaults: ThinkingDefaults | undefined,
   model: ModelThinkingMetadata | undefined,
-  kimiProvider = false,
+  kimiProtocol = false,
 ): ThinkingEffort {
   const configured = nonEmpty(defaults?.effort) as ThinkingEffort | undefined;
   const normalized = normalizeRequestedThinkingEffort(requested);
@@ -147,8 +147,8 @@ export function resolveThinkingEffortForModel(
     effort = configured ?? defaultThinkingEffortForModel(model);
   }
 
-  if (effort === 'off' && model?.alwaysThinking === true) {
+  if (kimiProtocol && effort === 'off' && model?.alwaysThinking === true) {
     effort = configured ?? defaultThinkingEffortForModel(model);
   }
-  return normalizeThinkingEffortForModel(effort, model, kimiProvider);
+  return normalizeThinkingEffortForModel(effort, model, kimiProtocol);
 }
diff --git a/packages/agent-core-v2/src/app/modelCatalog/modelCatalog.ts b/packages/agent-core-v2/src/app/modelCatalog/modelCatalog.ts
index 66fc872f4..ffc6583a9 100644
--- a/packages/agent-core-v2/src/app/modelCatalog/modelCatalog.ts
+++ b/packages/agent-core-v2/src/app/modelCatalog/modelCatalog.ts
@@ -3,26 +3,79 @@
  * model aliases, plus the global default-model selection.
  *
  * Projects the `provider` / `model` configuration registries into the
- * protocol `ProviderCatalogItem` / `ModelCatalogItem` wire shapes that the
- * edge (`server-v2` `/api/v1` routes) serves. App-scoped — provider and
+ * `ProviderCatalogItem` / `ModelCatalogItem` wire shapes (defined below as zod
+ * schemas) that the edge (`server-v2` `/api/v1` routes) serves. App-scoped — provider and
  * model configuration is global and shared across sessions. This domain is a
  * thin facade over `provider`, `model`, `config`, and `auth`; it owns no
  * persistence of its own. The OAuth-provider model refresh lives in
  * The OAuth-provider model refresh lives in `auth` (`IOAuthService`), not here.
  */
 
-import type {
-  ModelCatalogItem,
-  ProviderCatalogItem,
-  RefreshProviderModelsResponse,
-  SetDefaultModelResponse,
-} from '@moonshot-ai/protocol';
+import { z } from 'zod';
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 
 import type { ModelAlias } from '#/app/model/model';
 import { effectiveModelConfig } from '#/app/model/modelAuth';
-import type { ProviderConfig } from '#/app/provider/provider';
+import type { ProviderConfig, ProviderType } from '#/app/provider/provider';
+
+export const modelCatalogItemSchema = z.object({
+  provider: z.string().min(1),
+  model: z.string().min(1),
+  display_name: z.string().min(1).optional(),
+  max_context_size: z.number().int().min(1),
+  capabilities: z.array(z.string()).optional(),
+  support_efforts: z.array(z.string()).optional(),
+  default_effort: z.string().optional(),
+});
+export type ModelCatalogItem = z.infer<typeof modelCatalogItemSchema>;
+
+export const providerCatalogStatusSchema = z.enum([
+  'connected',
+  'error',
+  'unconfigured',
+]);
+export type ProviderCatalogStatus = z.infer<typeof providerCatalogStatusSchema>;
+
+export const providerCatalogItemSchema = z.object({
+  id: z.string().min(1),
+  type: z.string().min(1),
+  base_url: z.string().min(1).optional(),
+  default_model: z.string().min(1).optional(),
+  has_api_key: z.boolean(),
+  status: providerCatalogStatusSchema,
+  models: z.array(z.string().min(1)).optional(),
+});
+export type ProviderCatalogItem = z.infer<typeof providerCatalogItemSchema>;
+
+export const providerRefreshChangeSchema = z.object({
+  provider_id: z.string().min(1),
+  provider_name: z.string().min(1),
+  added: z.number().int().min(0),
+  removed: z.number().int().min(0),
+});
+export type ProviderRefreshChange = z.infer<typeof providerRefreshChangeSchema>;
+
+export const providerRefreshFailureSchema = z.object({
+  provider: z.string().min(1),
+  reason: z.string().min(1),
+});
+export type ProviderRefreshFailure = z.infer<typeof providerRefreshFailureSchema>;
+
+export const setDefaultModelResponseSchema = z.object({
+  default_model: z.string().min(1),
+  model: modelCatalogItemSchema,
+});
+export type SetDefaultModelResponse = z.infer<typeof setDefaultModelResponseSchema>;
+
+export const refreshProviderModelsResponseSchema = z.object({
+  changed: z.array(providerRefreshChangeSchema),
+  unchanged: z.array(z.string().min(1)),
+  failed: z.array(providerRefreshFailureSchema),
+});
+export type RefreshProviderModelsResponse = z.infer<
+  typeof refreshProviderModelsResponseSchema
+>;
 
 export type RefreshProviderModelsScope = 'all' | 'oauth';
 
@@ -51,8 +104,12 @@ export interface ProviderCredentialState {
   readonly hasOAuthToken: boolean;
 }
 
-export function toProtocolModel(modelId: string, alias: ModelAlias): ModelCatalogItem {
-  const effective = effectiveModelConfig(alias);
+export function toProtocolModel(
+  modelId: string,
+  alias: ModelAlias,
+  providerType?: ProviderType,
+): ModelCatalogItem {
+  const effective = effectiveModelConfig(alias, providerType);
   return {
     provider: effective.provider ?? '',
     model: modelId,
diff --git a/packages/agent-core-v2/src/app/modelCatalog/modelCatalogService.ts b/packages/agent-core-v2/src/app/modelCatalog/modelCatalogService.ts
index e5d1b33ae..37a8062ed 100644
--- a/packages/agent-core-v2/src/app/modelCatalog/modelCatalogService.ts
+++ b/packages/agent-core-v2/src/app/modelCatalog/modelCatalogService.ts
@@ -23,7 +23,7 @@ import type {
   ProviderCatalogItem,
   RefreshProviderModelsResponse,
   SetDefaultModelResponse,
-} from '@moonshot-ai/protocol';
+} from './modelCatalog';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
@@ -37,6 +37,7 @@ import {
   IProviderService,
   type OAuthRef,
   type ProviderConfig,
+  type ProviderType,
   PROVIDERS_SECTION,
 } from '#/app/provider/provider';
 
@@ -67,7 +68,9 @@ export class ModelCatalogService implements IModelCatalogService {
 
   async listModels(): Promise<readonly ModelCatalogItem[]> {
     const models = this.modelService.list();
-    return Object.entries(models).map(([modelId, alias]) => toProtocolModel(modelId, alias));
+    return Object.entries(models).map(([modelId, alias]) =>
+      toProtocolModel(modelId, alias, this.providerTypeOf(alias)),
+    );
   }
 
   async listProviders(): Promise<readonly ProviderCatalogItem[]> {
@@ -100,10 +103,16 @@ export class ModelCatalogService implements IModelCatalogService {
     const updatedAlias = this.modelService.get(modelId) ?? alias;
     return {
       default_model: modelId,
-      model: toProtocolModel(modelId, updatedAlias),
+      model: toProtocolModel(modelId, updatedAlias, this.providerTypeOf(updatedAlias)),
     };
   }
 
+  private providerTypeOf(alias: ModelAlias): ProviderType | undefined {
+    const providerId =
+      alias.providerId ?? alias.provider ?? this.config.get<string>('defaultProvider');
+    return this.providerService.get(providerId ?? '')?.type ?? alias.protocol;
+  }
+
   refreshProviderModels(
     options: RefreshProviderModelsOptions = {},
   ): Promise<RefreshProviderModelsResponse> {
diff --git a/packages/agent-core-v2/src/app/plugin/manager.ts b/packages/agent-core-v2/src/app/plugin/manager.ts
index 200be9ee5..b3d5000ee 100644
--- a/packages/agent-core-v2/src/app/plugin/manager.ts
+++ b/packages/agent-core-v2/src/app/plugin/manager.ts
@@ -651,6 +651,19 @@ function withPluginMcpRuntime(
     KIMI_PLUGIN_ROOT: pluginRoot,
   };
 
+  if (config.command === 'node' && isElectron()) {
+    // Electron host: run the entry with the bundled Node (`ELECTRON_RUN_AS_NODE`)
+    // instead of the CLI's `__plugin_run_node` subcommand, which only the CLI
+    // binary implements (Electron would try to open it as an app and fail).
+    return {
+      ...config,
+      command: process.execPath,
+      args: config.args ?? [],
+      cwd: config.cwd ?? pluginRoot,
+      env: { ...env, ELECTRON_RUN_AS_NODE: '1' },
+    };
+  }
+
   if (config.command === 'node' && isKimiNativeBinary()) {
     return {
       ...config,
@@ -664,6 +677,10 @@ function withPluginMcpRuntime(
   return { ...config, cwd: config.cwd ?? pluginRoot, env };
 }
 
+function isElectron(): boolean {
+  return typeof process.versions['electron'] === 'string';
+}
+
 function isKimiNativeBinary(): boolean {
   return !path.basename(process.execPath).toLowerCase().startsWith('node');
 }
diff --git a/packages/agent-core-v2/src/app/protocol/errors.ts b/packages/agent-core-v2/src/app/protocol/errors.ts
index 220777be9..86a418678 100644
--- a/packages/agent-core-v2/src/app/protocol/errors.ts
+++ b/packages/agent-core-v2/src/app/protocol/errors.ts
@@ -92,7 +92,11 @@ export function translateProviderError(error: unknown): Error2 {
     return new Error2(code, sanitizeStatusErrorMessage(error.message), {
       name: error.name,
       cause: error,
-      details: { statusCode: error.statusCode, requestId: error.requestId },
+      details: {
+        statusCode: error.statusCode,
+        requestId: error.requestId,
+        traceId: error.traceId,
+      },
     });
   }
   if (error instanceof APIConnectionError || error instanceof APITimeoutError) {
diff --git a/packages/agent-core-v2/src/app/protocol/protocol.ts b/packages/agent-core-v2/src/app/protocol/protocol.ts
index 67575c69e..13d7f9a40 100644
--- a/packages/agent-core-v2/src/app/protocol/protocol.ts
+++ b/packages/agent-core-v2/src/app/protocol/protocol.ts
@@ -33,6 +33,7 @@ export type Protocol = z.infer<typeof ProtocolSchema>;
 export interface ProtocolProviderOptions {
   readonly reasoningKey?: string;
   readonly defaultMaxTokens?: number;
+  readonly supportEfforts?: readonly string[];
   readonly adaptiveThinking?: boolean;
   readonly kimiThinking?: boolean;
   readonly betaApi?: boolean;
diff --git a/packages/agent-core-v2/src/app/sessionExport/manifest.ts b/packages/agent-core-v2/src/app/sessionExport/manifest.ts
index 3a27dd407..49b418987 100644
--- a/packages/agent-core-v2/src/app/sessionExport/manifest.ts
+++ b/packages/agent-core-v2/src/app/sessionExport/manifest.ts
@@ -6,7 +6,7 @@
  * version facts, and wire-log activity timestamps discovered during export.
  */
 
-import { AGENT_WIRE_PROTOCOL_VERSION } from '#/agent/wireRecord/wireRecord';
+import { WIRE_PROTOCOL_VERSION } from '#/wire/migration/migration';
 
 import type {
   ExportSessionManifest,
@@ -14,8 +14,6 @@ import type {
 } from './sessionExport';
 import type { SessionWireScan } from './wire-scan';
 
-export const WIRE_PROTOCOL_VERSION = AGENT_WIRE_PROTOCOL_VERSION;
-
 export interface ExportSessionManifestSummary {
   readonly id: string;
   readonly title?: string | undefined;
diff --git a/packages/agent-core-v2/src/app/sessionExport/sessionExportService.ts b/packages/agent-core-v2/src/app/sessionExport/sessionExportService.ts
index e48aef704..134dd8ea0 100644
--- a/packages/agent-core-v2/src/app/sessionExport/sessionExportService.ts
+++ b/packages/agent-core-v2/src/app/sessionExport/sessionExportService.ts
@@ -12,7 +12,7 @@ import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
 import { ILogService } from '#/_base/log/log';
 import { resolveGlobalLogPath } from '#/_base/log/logConfig';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { IWireService } from '#/wire/wire';
 import { IBootstrapService } from '#/app/bootstrap/bootstrap';
 import { ISessionIndex, type SessionSummary } from '#/app/sessionIndex/sessionIndex';
 import { ISessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycle';
@@ -126,7 +126,7 @@ export class SessionExportService implements ISessionExportService {
     const agents = handle.accessor.get(IAgentLifecycleService);
     for (const agent of agents.list()) {
       await this.warnIfFails('export agent wire flush failed', () =>
-        agent.accessor.get(IAgentWireRecordService).flush(),
+        agent.accessor.get(IWireService).flush(),
       );
     }
 
@@ -197,9 +197,10 @@ export async function exportSessionDirectory(input: {
       );
     }
     const bundledWebLog = input.webLog !== undefined;
+    const now = new Date();
     const baseManifest = buildExportManifest({
       summary: input.summary,
-      now: new Date(),
+      now,
       version: input.request.version,
       sessionScan,
       sessionLogPath: stableSessionLog === undefined ? undefined : SESSION_LOG_REL,
@@ -210,7 +211,7 @@ export async function exportSessionDirectory(input: {
     const outputPath =
       input.request.outputPath !== undefined
         ? resolve(input.request.outputPath)
-        : resolve(`${input.summary.id}.zip`);
+        : resolve(defaultExportZipName(input.summary.id, now));
     const extras: ExtraZipEntry[] = [];
     if (input.webLog !== undefined) {
       extras.push({ data: Buffer.from(input.webLog, 'utf8'), target: WEB_LOG_REL });
@@ -252,6 +253,12 @@ export async function exportSessionDirectory(input: {
   }
 }
 
+function defaultExportZipName(sessionId: string, now: Date): string {
+  const shortId = sessionId.slice(0, 8);
+  const timestamp = now.toISOString().replaceAll(/[-:]/g, '').replace(/T/, '-').slice(0, 15);
+  return `kimi-debug-${shortId}-${timestamp}.zip`;
+}
+
 function sessionZipEntryPath(entry: SessionZipEntry): string {
   return typeof entry === 'string' ? entry : entry.path;
 }
diff --git a/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacy.ts b/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacy.ts
index d765aef05..3886beff1 100644
--- a/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacy.ts
+++ b/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacy.ts
@@ -22,14 +22,12 @@
  * it is a stateless dispatcher that resolves the target session/agent per call.
  */
 
-import type {
-  GoalSnapshot,
-  SessionStatusResponse,
-  UpdateSessionProfileRequest,
-} from '@moonshot-ai/protocol';
+import type { GoalSnapshot } from '#/agent/goal/types';
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 
+import type { SessionStatusResponse, UpdateSessionProfileRequest } from './sessionProtocol';
+
 export interface SessionWireFields {
   readonly id: string;
   readonly workspaceId: string;
diff --git a/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacyService.ts b/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacyService.ts
index 44c648e5f..79dd3e96f 100644
--- a/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacyService.ts
+++ b/packages/agent-core-v2/src/app/sessionLegacy/sessionLegacyService.ts
@@ -13,11 +13,9 @@
  * the real work stays in the native services.
  */
 
-import type {
-  GoalSnapshot,
-  SessionStatusResponse,
-  UpdateSessionProfileRequest,
-} from '@moonshot-ai/protocol';
+import type { GoalSnapshot } from '#/agent/goal/types';
+
+import type { SessionStatusResponse, UpdateSessionProfileRequest } from './sessionProtocol';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { type IAgentScopeHandle, LifecycleScope, registerScopedService } from '#/_base/di/scope';
@@ -33,7 +31,8 @@ import { IModelResolver } from '#/app/model/modelResolver';
 import { ISessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycle';
 import { ErrorCodes, Error2 } from '#/errors';
 import { ensureMainAgent } from '#/session/agentLifecycle/mainAgent';
-import { ISessionActivity } from '#/session/sessionActivity/sessionActivity';
+import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
+import { IAgentActivityView } from '#/agent/activityView/activityView';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import { ISessionMetadata } from '#/session/sessionMetadata/sessionMetadata';
 
@@ -128,7 +127,7 @@ export class SessionLegacyService implements ISessionLegacyService {
           await goal.pauseGoal({});
           break;
         case 'resume':
-          await goal.resumeGoal({ continueIfBlocked: true });
+          await goal.resumeGoal({ continueIfPaused: true, continueIfBlocked: true });
           break;
         case 'cancel':
           await goal.cancelGoal({});
@@ -154,7 +153,6 @@ export class SessionLegacyService implements ISessionLegacyService {
     sessionId: string,
     agent: IAgentScopeHandle,
   ): Promise<SessionStatusResponse> {
-    const session = this.lifecycle.get(sessionId);
     const profile = agent.accessor.get(IAgentProfileService);
     const contextSize = agent.accessor.get(IAgentContextSizeService);
     const permission = agent.accessor.get(IAgentPermissionModeService);
@@ -169,7 +167,7 @@ export class SessionLegacyService implements ISessionLegacyService {
     const planData = await plan.status();
 
     return {
-      status: session?.accessor.get(ISessionActivity).status() ?? 'idle',
+      busy: this.readBusy(sessionId),
       model: model === '' ? undefined : model,
       thinking_level: profile.getEffectiveThinkingLevel(),
       permission: permission.mode,
@@ -182,6 +180,21 @@ export class SessionLegacyService implements ISessionLegacyService {
     };
   }
 
+  /**
+   * The session's busy fact, derived on demand from the agents' activity
+   * views (any active turn or background task). Nothing is booked at session
+   * level — a cold session is simply not busy.
+   */
+  private readBusy(sessionId: string): boolean {
+    const handle = this.lifecycle.get(sessionId);
+    if (handle === undefined) return false;
+    for (const agent of handle.accessor.get(IAgentLifecycleService).list()) {
+      const state = agent.accessor.get(IAgentActivityView).state();
+      if (state.turn !== undefined || state.background.length > 0) return true;
+    }
+    return false;
+  }
+
   async goal(sessionId: string): Promise<GoalSnapshot | null> {
     const agent = await this.resolveMainAgent(sessionId);
     return agent.accessor.get(IAgentGoalService).getGoal().goal;
diff --git a/packages/agent-core-v2/src/app/sessionLegacy/sessionProtocol.ts b/packages/agent-core-v2/src/app/sessionLegacy/sessionProtocol.ts
new file mode 100644
index 000000000..9d16e008c
--- /dev/null
+++ b/packages/agent-core-v2/src/app/sessionLegacy/sessionProtocol.ts
@@ -0,0 +1,94 @@
+/**
+ * `sessionLegacy` domain — the v1 session wire DTO schemas.
+ *
+ * These zod schemas define the request/response shapes of the v1 session
+ * endpoints this adapter backs (`POST /sessions/{id}/profile`,
+ * `GET /sessions/{id}/status`, session warnings); the transports validate
+ * against them and the adapter's contract consumes the inferred types.
+ * Field-level changes here are wire breaks — see the schema-fidelity rule in
+ * `server-align.md`.
+ */
+
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '#/_base/utils/isoDateTime';
+
+export const sessionWarningSchema = z.object({
+  code: z.string(),
+  message: z.string(),
+  severity: z.enum(['info', 'warning', 'error']),
+});
+export type SessionWarning = z.infer<typeof sessionWarningSchema>;
+
+export const sessionWarningsResponseSchema = z.object({
+  warnings: z.array(sessionWarningSchema),
+});
+export type SessionWarningsResponse = z.infer<typeof sessionWarningsResponseSchema>;
+
+export const promptThinkingSchema = z.string().min(1);
+export type PromptThinking = z.infer<typeof promptThinkingSchema>;
+
+export const promptPermissionModeSchema = z.enum(['manual', 'yolo', 'auto']);
+export type PromptPermissionMode = z.infer<typeof promptPermissionModeSchema>;
+
+export const sessionMetadataSchema = z
+  .object({
+    cwd: z.string().min(1),
+  })
+  .catchall(z.unknown());
+export type SessionMetadata = z.infer<typeof sessionMetadataSchema>;
+
+export const sessionAgentConfigSchema = z.object({
+  model: z.string(),
+  system_prompt: z.string().optional(),
+  tools: z.array(z.string()).optional(),
+  mcp_servers: z.array(z.string()).optional(),
+  thinking: promptThinkingSchema.optional(),
+  permission_mode: promptPermissionModeSchema.optional(),
+  plan_mode: z.boolean().optional(),
+  swarm_mode: z.boolean().optional(),
+  goal_objective: z.string().optional(),
+  goal_control: z.enum(['pause', 'resume', 'cancel']).optional(),
+});
+export type SessionAgentConfig = z.infer<typeof sessionAgentConfigSchema>;
+
+export const sessionAgentConfigPartialSchema = sessionAgentConfigSchema.partial();
+export type SessionAgentConfigPartial = z.infer<typeof sessionAgentConfigPartialSchema>;
+
+export const permissionRuleMatcherSchema = z.object({
+  kind: z.enum(['command_prefix', 'path_glob', 'exact_input', 'always']),
+  value: z.string().optional(),
+});
+export type PermissionRuleMatcher = z.infer<typeof permissionRuleMatcherSchema>;
+
+export const permissionRuleSchema = z.object({
+  id: z.string().min(1),
+  tool_name: z.string().min(1),
+  matcher: permissionRuleMatcherSchema.optional(),
+  decision: z.literal('approved'),
+  created_at: isoDateTimeSchema,
+  created_by: z.enum(['user', 'agent']),
+});
+export type PermissionRule = z.infer<typeof permissionRuleSchema>;
+
+export const updateSessionProfileRequestSchema = z.object({
+  title: z.string().min(1).optional(),
+  metadata: sessionMetadataSchema.partial().optional(),
+  agent_config: sessionAgentConfigPartialSchema.optional(),
+  permission_rules: z.array(permissionRuleSchema).optional(),
+});
+export type UpdateSessionProfileRequest = z.infer<typeof updateSessionProfileRequestSchema>;
+
+export const sessionStatusResponseSchema = z.object({
+  busy: z.boolean(),
+  model: z.string().optional(),
+  thinking_level: z.string(),
+  permission: z.string(),
+  plan_mode: z.boolean(),
+  swarm_mode: z.boolean(),
+  context_tokens: z.number().int().nonnegative(),
+  raw_context_tokens: z.number().int().nonnegative().optional(),
+  max_context_tokens: z.number().int().nonnegative(),
+  context_usage: z.number().min(0).max(1),
+});
+export type SessionStatusResponse = z.infer<typeof sessionStatusResponseSchema>;
diff --git a/packages/agent-core-v2/src/app/sessionLifecycle/sessionLifecycleService.ts b/packages/agent-core-v2/src/app/sessionLifecycle/sessionLifecycleService.ts
index 3805d8105..5eb7d3c57 100644
--- a/packages/agent-core-v2/src/app/sessionLifecycle/sessionLifecycleService.ts
+++ b/packages/agent-core-v2/src/app/sessionLifecycle/sessionLifecycleService.ts
@@ -7,14 +7,18 @@
  * close/archive — archiving flags the session's `sessionMetadata`, removes
  * its `agentLifecycle` agents, restoring clears the archived flag, and
  * broadcasts through `event`; session start and resume failures are reported
- * through `telemetry`. Materializes the session's initial metadata on
+ * through `telemetry`. Because hosts bind their telemetry context only after
+ * create()/resume() returns, the created-session announcement binds the
+ * session id into telemetry context before emitting `session_started`, and the
+ * resume-failure path does the same before `session_load_failed`.
+ * Materializes the session's initial metadata on
  * creation by resolving `sessionMetadata`. Bound at App scope. Persisted
  * sessions are discovered through the `sessionIndex` read model, and workspace
  * roots are remembered through `workspaceRegistry`. On create / fork the
  * session is also appended to the shared `session_index.jsonl` so v1 clients
  * (TUI, export) can discover sessions created by the v2 engine. Fork flushes
- * live agent logs and rejects non-empty logs without a protocol metadata
- * envelope instead of stamping legacy data as current.
+ * live Agent wire journals, normalizes a missing protocol envelope, and
+ * appends the fork boundary before restoring the target Agent.
  */
 
 import { randomUUID } from 'node:crypto';
@@ -34,16 +38,8 @@ import {
 import { unwrapErrorCause } from '#/_base/errors/errors';
 import { Emitter, type Event } from '#/_base/event';
 import { encodeWorkDirKey } from '#/_base/utils/workdir-slug';
-import { ISessionActivityKernel } from '#/activity/activity';
-import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import { DEFAULT_PLAN_MODE_SECTION } from '#/agent/plan/configSection';
 import { IAgentPlanService } from '#/agent/plan/plan';
-import {
-  IAgentWireRecordService,
-  type PersistedWireRecord,
-} from '#/agent/wireRecord/wireRecord';
-import { metadataRecord } from '#/agent/wireRecord/metadataOps';
-import { WIRE_RECORD_FILENAME, wireRecordScope } from '#/agent/wireRecord/wireRecordService';
 import { IBootstrapService } from '#/app/bootstrap/bootstrap';
 import { CRON_SESSION_TAG, type CronTask } from '#/app/cron/cronTask';
 import { ICronTaskPersistence } from '#/app/cron/cronTaskPersistence';
@@ -74,8 +70,12 @@ import { ISessionCronService } from '#/session/cron/sessionCronService';
 import { ISessionMetadata, type SessionMeta } from '#/session/sessionMetadata/sessionMetadata';
 import { ISessionSkillCatalog } from '#/session/sessionSkillCatalog/skillCatalog';
 import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceContext';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
+import {
+  AGENT_WIRE_RECORD_KEY,
+  createWireMetadataRecord,
+  type WireRecord,
+} from '#/wire/record';
 
 import {
   type CreateChildSessionOptions,
@@ -174,7 +174,6 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
         extra: [...sessionContextSeed(ctx)],
       },
     ) as ISessionScopeHandle;
-    handle.accessor.get(ISessionActivityKernel);
     if (additionalDirs.length > 0) {
       handle.accessor.get(ISessionWorkspaceContext).setAdditionalDirs(additionalDirs);
     }
@@ -203,8 +202,8 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
   private async announceCreated(event: SessionCreatedEvent): Promise<void> {
     await this.hooks.onDidCreateSession.run(event);
     this._onDidCreateSession.fire(event);
+    this.telemetry.setContext({ sessionId: event.sessionId });
     this.telemetry.track2('session_started', { resumed: event.source === 'resume' });
-    event.handle.accessor.get(ISessionActivityKernel).markActive();
   }
 
   get(sessionId: string): ISessionScopeHandle | undefined {
@@ -219,6 +218,7 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
     if (live !== undefined) return Promise.resolve(live);
     const promise = this.doResume(sessionId)
       .catch((error: unknown) => {
+        this.telemetry.setContext({ sessionId });
         this.telemetry.track2('session_load_failed', {
           reason: isError2(error) ? error.code : error instanceof Error ? error.name : 'unknown',
         });
@@ -247,15 +247,7 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
     });
     const agents = handle.accessor.get(IAgentLifecycleService);
     if (agents.get(MAIN_AGENT_ID) === undefined) {
-      const main = await agents.create({ agentId: MAIN_AGENT_ID });
-      // Resolve context memory BEFORE restoring so its reducers are registered;
-      // otherwise the wire replay applies context records into a void and the
-      // restored transcript never lands in context memory.
-      main.accessor.get(IAgentContextMemoryService);
-      const mainWireRecord = main.accessor.get(IAgentWireRecordService);
-      await mainWireRecord.restore();
-      const records = mainWireRecord.getRecords() as readonly PersistedRecord[];
-      await main.accessor.get(IAgentWireService).replay(...records);
+      await agents.create({ agentId: MAIN_AGENT_ID });
     }
     await this.announceCreated({ sessionId, handle, source: 'resume' });
     return handle;
@@ -274,7 +266,6 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
     if (handle === undefined) return;
     await this.announceWillClose({ sessionId, handle, reason: 'exit' });
     this.sessions.delete(sessionId);
-    handle.accessor.get(ISessionActivityKernel).beginClosing();
     await this.drainAgents(handle);
     handle.dispose();
     this._onDidCloseSession.fire({ sessionId });
@@ -285,7 +276,6 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
     if (handle === undefined) return;
     const meta = handle.accessor.get(ISessionMetadata);
     await meta.setArchived(true);
-    handle.accessor.get(ISessionActivityKernel).beginClosing();
     await this.drainAgents(handle);
     this.event.publish({
       type: 'event.session.archived',
@@ -328,17 +318,20 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
         ? sourceHandle.accessor.get(ISessionContext).workspaceId
         : indexSummary!.workspaceId;
 
-    const quiesce =
-      sourceHandle !== undefined
-        ? await sourceHandle.accessor.get(ISessionActivityKernel).quiesce('fork')
-        : undefined;
+    // Fork is unconditional — it never rejects on the source being busy.
+    // Copying a live journal yields a torn prefix (a turn cut mid-flight),
+    // which is exactly the state a crash leaves behind, and replay already
+    // normalizes that on every restore. The source keeps running untouched;
+    // the fork simply continues from the copy point. No admission gate, no
+    // quiesce: the only requirement is a durable copy point, which
+    // `copyAgentWire`'s flush provides.
     let targetId: string | undefined;
     let target: ISessionScopeHandle | undefined;
     let targetSessionDir: string | undefined;
     try {
       const workspace = await this.workspaceRegistry.get(workspaceId);
       if (workspace === undefined) {
-        throw new Error2('workspace.not_found', `workspace ${workspaceId} does not exist`);
+        throw new Error2(ErrorCodes.WORKSPACE_NOT_FOUND, `workspace ${workspaceId} does not exist`);
       }
 
       const sourceMeta =
@@ -370,10 +363,10 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
       const sourceAgents = sourceMeta?.agents ?? {};
       const agentIds = Object.keys(sourceAgents);
       for (const agentId of agentIds) {
-        const sourceHomedir = sourceAgents[agentId]!.homedir;
         await this.copyAgentWire({
           sourceHandle,
-          sourceHomedir,
+          sourceWorkspaceId: workspaceId,
+          sourceSessionId: sourceId,
           agentId,
           targetWorkspaceId: targetCtx.workspaceId,
           targetSessionId: targetCtx.sessionId,
@@ -394,15 +387,11 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
 
       for (const agentId of agentIds) {
         const sourceAgent = sourceAgents[agentId]!;
-        const agentHandle = await target.accessor.get(IAgentLifecycleService).create({
+        await target.accessor.get(IAgentLifecycleService).create({
           agentId,
           forkedFrom: sourceAgent.forkedFrom,
           labels: labelsFromAgentMeta(sourceAgent),
         });
-        const forkWireRecord = agentHandle.accessor.get(IAgentWireRecordService);
-        await forkWireRecord.restore();
-        const forkRecords = forkWireRecord.getRecords() as readonly PersistedRecord[];
-        await agentHandle.accessor.get(IAgentWireService).replay(...forkRecords);
       }
 
       await this.appendSessionIndexEntry(targetId, workspace.root);
@@ -427,8 +416,6 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
         await this.hostFs.remove(targetSessionDir).catch(() => {});
       }
       throw error;
-    } finally {
-      quiesce?.dispose();
     }
   }
 
@@ -459,7 +446,8 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
 
   private async copyAgentWire(args: {
     readonly sourceHandle: ISessionScopeHandle | undefined;
-    readonly sourceHomedir: string;
+    readonly sourceWorkspaceId: string;
+    readonly sourceSessionId: string;
     readonly agentId: string;
     readonly targetWorkspaceId: string;
     readonly targetSessionId: string;
@@ -469,34 +457,34 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
         .get(IAgentLifecycleService)
         .get(args.agentId);
       if (agentHandle !== undefined) {
-        await agentHandle.accessor.get(IAgentWireRecordService).flush();
+        await agentHandle.accessor.get(IWireService).flush();
       }
     }
 
     const records = await collect(
-      this.appendLogStore.read<PersistedWireRecord>(
-        wireRecordScope(args.sourceHomedir, this.bootstrap.homeDir),
-        WIRE_RECORD_FILENAME,
+      this.appendLogStore.read<WireRecord>(
+        this.bootstrap.agentScope(
+          args.sourceWorkspaceId,
+          args.sourceSessionId,
+          args.agentId,
+        ),
+        AGENT_WIRE_RECORD_KEY,
       ),
     );
-    // Keep the copied log well-formed for the target's first restore: prepend
-    // the metadata envelope when the source lacks one (restore() would heal it
-    // anyway, but the forked copy should be valid on its own).
     if (records.length === 0) {
-      records.push(metadataRecord());
+      records.push(createWireMetadataRecord());
     } else if (records[0]?.type !== 'metadata') {
-      records.unshift(metadataRecord());
+      records.unshift(createWireMetadataRecord());
     }
     records.push(forkedRecord());
 
-    const targetHomedir = this.bootstrap.agentHomedir(
-      args.targetWorkspaceId,
-      args.targetSessionId,
-      args.agentId,
-    );
     await this.appendLogStore.rewrite(
-      wireRecordScope(targetHomedir, this.bootstrap.homeDir),
-      WIRE_RECORD_FILENAME,
+      this.bootstrap.agentScope(
+        args.targetWorkspaceId,
+        args.targetSessionId,
+        args.agentId,
+      ),
+      AGENT_WIRE_RECORD_KEY,
       records,
     );
   }
@@ -520,7 +508,7 @@ export class SessionLifecycleService extends Disposable implements ISessionLifec
   ): Promise<void> {
     for (const entry of entries) {
       const rel = relBase === '' ? entry.name : `${relBase}/${entry.name}`;
-      if (rel === 'state.json' || rel === 'logs' || entry.name === WIRE_RECORD_FILENAME) {
+      if (rel === 'state.json' || rel === 'logs' || entry.name === AGENT_WIRE_RECORD_KEY) {
         continue;
       }
       if (entry.isSymbolicLink === true) continue;
@@ -597,8 +585,8 @@ function createSessionId(): string {
   return `session_${randomUUID()}`;
 }
 
-function forkedRecord(): PersistedWireRecord {
-  return { type: 'forked', time: Date.now() } as PersistedWireRecord;
+function forkedRecord(): WireRecord {
+  return { type: 'forked', time: Date.now() };
 }
 
 function forkCustomMetadata(
diff --git a/packages/agent-core-v2/src/app/skillCatalog/builtin/builtin.ts b/packages/agent-core-v2/src/app/skillCatalog/builtin/builtin.ts
index 8f5ff6d24..6a1febdb2 100644
--- a/packages/agent-core-v2/src/app/skillCatalog/builtin/builtin.ts
+++ b/packages/agent-core-v2/src/app/skillCatalog/builtin/builtin.ts
@@ -9,6 +9,7 @@
 
 import type { InMemorySkillCatalog } from '#/app/skillCatalog/registry';
 import type { SkillDefinition } from '#/app/skillCatalog/types';
+import { CHECK_KIMI_CODE_DOCS_SKILL } from './check-kimi-code-docs';
 import { CUSTOM_THEME_SKILL } from './custom-theme';
 import { IMPORT_FROM_CC_CODEX_SKILL } from './import-from-cc-codex';
 import { MCP_CONFIG_SKILL } from './mcp-config';
@@ -26,6 +27,7 @@ export const BUILTIN_SKILLS: readonly SkillDefinition[] = [
   UPDATE_CONFIG_SKILL,
   CUSTOM_THEME_SKILL,
   WRITE_GOAL_SKILL,
+  CHECK_KIMI_CODE_DOCS_SKILL,
   SUB_SKILL_PARENT,
   SUB_SKILL_REVIEW,
   SUB_SKILL_CONSOLIDATE,
@@ -38,6 +40,7 @@ export function registerBuiltinSkills(registry: InMemorySkillCatalog): void {
 }
 
 export {
+  CHECK_KIMI_CODE_DOCS_SKILL,
   CUSTOM_THEME_SKILL,
   IMPORT_FROM_CC_CODEX_SKILL,
   MCP_CONFIG_SKILL,
diff --git a/packages/agent-core-v2/src/app/skillCatalog/builtin/check-kimi-code-docs.md b/packages/agent-core-v2/src/app/skillCatalog/builtin/check-kimi-code-docs.md
new file mode 100644
index 000000000..f64d179fe
--- /dev/null
+++ b/packages/agent-core-v2/src/app/skillCatalog/builtin/check-kimi-code-docs.md
@@ -0,0 +1,44 @@
+---
+name: check-kimi-code-docs
+description: Answer questions about the Kimi Code product using the official documentation — CLI usage, configuration, slash commands, features, membership and quota, API onboarding, third-party tool setup, and error codes. Use when the user asks how Kimi Code works, how to set something up, or what a Kimi Code error message means.
+---
+
+# Check Kimi Code docs (check-kimi-code-docs)
+
+Answer Kimi Code **product** questions from the official documentation site, not from memory. This skill covers product usage ("how do I configure a provider", "what does this error mean", "how does membership quota work"); it is not for developing the Kimi Code repository itself.
+
+## The single source of truth
+
+Official documentation (English):
+
+```
+https://www.kimi.com/code/docs/en/
+```
+
+Fetch pages with **FetchURL** before answering. All page links below are relative to this base.
+
+## Which page to read for which question
+
+| Question topic | Page (relative to the base URL) |
+| --- | --- |
+| What Kimi Code is; Base URL / API Key; standard vs high-speed model; platform comparison | `./` (home overview) |
+| Membership plans, quota and rate limits, fuel packs | `kimi-code/membership.html` |
+| Install / login / usage FAQ | `kimi-code/faq.html` |
+| Error codes and their meaning (e.g. 401 for high-speed model access) | `kimi-code/error-reference.html` |
+| Product news and recent changes | `kimi-code/whats-new.html` |
+| Community guidelines; contact and feedback | `kimi-code/community-guidelines.html`, `kimi-code/contact-and-feedback.html` |
+| `config.toml` fields, providers/models, environment variables, data locations, config overrides | `kimi-code-cli/configuration/` — `config-files.html`, `providers.html`, `env-vars.html`, `data-locations.html`, `overrides.html` |
+| Skills, MCP, hooks, plugins, themes, agents/sub-agents, Kimi Datasource | `kimi-code-cli/customization/` — `skills.html`, `mcp.html`, `hooks.html`, `plugins.html`, `themes.html`, `agents.html`; Kimi Datasource lives at `plugins.html#kimi-datasource` |
+| Getting started, sessions and context, goals, interaction and input, IDEs, migration, use cases | `kimi-code-cli/guides/` — `getting-started.html`, `sessions.html`, `goals.html`, `interaction.html`, `ides.html`, `migration.html`, `use-cases.html` |
+| Slash commands, keyboard shortcuts, builtin tools, `kimi` command flags, ACP | `kimi-code-cli/reference/` — `slash-commands.html`, `keyboard.html`, `tools.html`, `kimi-command.html`, `kimi-acp.html` |
+| CLI changelog | `kimi-code-cli/release-notes/changelog.html` |
+| Using Kimi Code in Claude Code and other third-party agents | `third-party-tools/other-coding-agents.html` |
+
+If no row fits the question, fetch the docs home page and follow its navigation links.
+
+## How to answer
+
+1. Pick the page from the table above.
+2. **FetchURL the page before answering** — answer strictly from the fetched content, never from memory.
+3. Cite the page link(s) you used at the end of the answer.
+4. If the fetch fails or the docs do not cover the question, say so plainly: answer from what you already know, attach the docs entry link (`https://www.kimi.com/code/docs/en/`), and mark which parts you could not verify. **Never invent config keys, command names, model IDs, or product behaviors.**
diff --git a/packages/agent-core-v2/src/app/skillCatalog/builtin/check-kimi-code-docs.ts b/packages/agent-core-v2/src/app/skillCatalog/builtin/check-kimi-code-docs.ts
new file mode 100644
index 000000000..01aaa9482
--- /dev/null
+++ b/packages/agent-core-v2/src/app/skillCatalog/builtin/check-kimi-code-docs.ts
@@ -0,0 +1,26 @@
+/**
+ * `skillCatalog` domain (L3) — builtin `check-kimi-code-docs` skill definition.
+ */
+
+import type { SkillDefinition } from '#/app/skillCatalog/types';
+import { parseSkillText } from '#/app/skillCatalog/parser';
+import CHECK_KIMI_CODE_DOCS_BODY from './check-kimi-code-docs.md?raw';
+
+const PSEUDO_PATH = 'builtin://check-kimi-code-docs';
+
+const parsed = parseSkillText({
+  skillMdPath: '/builtin/skills/check-kimi-code-docs.md',
+  skillDirName: 'check-kimi-code-docs',
+  source: 'builtin',
+  text: CHECK_KIMI_CODE_DOCS_BODY,
+});
+
+export const CHECK_KIMI_CODE_DOCS_SKILL: SkillDefinition = {
+  ...parsed,
+  path: PSEUDO_PATH,
+  dir: PSEUDO_PATH,
+  metadata: {
+    ...parsed.metadata,
+    type: parsed.metadata.type ?? 'inline',
+  },
+};
diff --git a/packages/agent-core-v2/src/app/telemetry/agentTelemetryContext.ts b/packages/agent-core-v2/src/app/telemetry/agentTelemetryContext.ts
index 0b5b16eba..7ba536f4a 100644
--- a/packages/agent-core-v2/src/app/telemetry/agentTelemetryContext.ts
+++ b/packages/agent-core-v2/src/app/telemetry/agentTelemetryContext.ts
@@ -3,8 +3,10 @@
  *
  * Agent-scoped ambient telemetry context: a per-agent property bag that domains
  * contribute to (the `plan` domain sets `mode`, the `profile` domain mirrors
- * the resolved model protocol into `provider_type` / `protocol`) and that
- * turn-scoped telemetry snapshots at launch. Decouples turn telemetry from any
+ * the resolved model protocol into `provider_type` / `protocol`, the `loop`
+ * domain sets `turn_id` at turn start and keeps `trace_id` at the active
+ * turn's most recent request) and that turn-scoped
+ * telemetry snapshots at launch. Decouples turn telemetry from any
  * specific contributor so the turn domain does not need to know about plan or
  * profile. Bound at Agent scope.
  */
@@ -15,6 +17,8 @@ export type AgentTelemetryContext = {
   mode: 'agent' | 'plan';
   provider_type?: string;
   protocol?: string;
+  turn_id?: number;
+  trace_id?: string;
 };
 
 export interface IAgentTelemetryContextService {
diff --git a/packages/agent-core-v2/src/app/telemetry/cloudAppender.ts b/packages/agent-core-v2/src/app/telemetry/cloudAppender.ts
index 1c99fc3f9..4687fca3e 100644
--- a/packages/agent-core-v2/src/app/telemetry/cloudAppender.ts
+++ b/packages/agent-core-v2/src/app/telemetry/cloudAppender.ts
@@ -129,6 +129,10 @@ export class CloudAppender implements ITelemetryAppender {
     if (typeof sessionId === 'string') {
       this.sessionId = sessionId;
     }
+    const model = patch['model'];
+    if (typeof model === 'string') {
+      setPrimitive(this.context, 'model', model);
+    }
   }
 
   async flush(): Promise<void> {
diff --git a/packages/agent-core-v2/src/app/telemetry/events.ts b/packages/agent-core-v2/src/app/telemetry/events.ts
index bb1a982f9..774fbf30b 100644
--- a/packages/agent-core-v2/src/app/telemetry/events.ts
+++ b/packages/agent-core-v2/src/app/telemetry/events.ts
@@ -43,25 +43,30 @@ export type StrictPropertyCheck<T, E> = string extends keyof T
     : never;
 
 export interface TurnStartedEvent {
+  turn_id: number;
   mode: 'agent' | 'plan';
   provider_type?: string;
   protocol?: string;
 }
 
 export interface TurnInterruptedEvent {
+  turn_id: number;
   at_step: number;
   mode: 'agent' | 'plan';
   interrupt_reason: 'user_cancelled' | 'aborted' | 'max_steps' | 'error' | 'filtered' | 'blocked';
   provider_type?: string;
   protocol?: string;
+  trace_id?: string;
 }
 
 export interface TurnEndedEvent {
+  turn_id: number;
   reason: 'completed' | 'cancelled' | 'failed';
   duration_ms: number;
   mode: 'agent' | 'plan';
   provider_type?: string;
   protocol?: string;
+  trace_id?: string;
 }
 
 export type ToolCallOutcome = 'success' | 'error' | 'cancelled';
@@ -74,6 +79,7 @@ export interface ToolCallEvent {
   duration_ms: number;
   dup_type: 'normal' | 'same_step' | 'cross_step';
   error_type?: 'cancelled' | 'error';
+  trace_id?: string;
 }
 
 export interface ApiErrorEvent {
@@ -86,6 +92,9 @@ export interface ApiErrorEvent {
   provider_type?: string;
   protocol?: string;
   input_tokens?: number;
+  turn_id?: number;
+  step_no?: number;
+  trace_id?: string;
 }
 
 export interface SkillInvokedEvent {
@@ -103,6 +112,7 @@ export interface InputSteerEvent {
 
 export interface CancelEvent {
   from: 'streaming' | 'compacting';
+  trace_id?: string;
 }
 
 export interface ConversationUndoEvent {
@@ -136,6 +146,7 @@ export interface PermissionApprovalResultEvent {
   duration_ms: number;
   session_cache_written: boolean;
   has_feedback: boolean;
+  trace_id?: string;
 }
 
 export interface PlanSubmittedEvent {
@@ -172,6 +183,7 @@ export interface CompactionFinishedEvent {
   output_tokens?: number;
   input_cache_read?: number;
   input_cache_creation?: number;
+  trace_id?: string;
 }
 
 export interface CompactionFailedEvent {
@@ -182,6 +194,7 @@ export interface CompactionFailedEvent {
   retry_count: number;
   thinking_effort: string;
   error_type: string;
+  trace_id?: string;
 }
 
 export interface ContextProjectionRepairedEvent {
@@ -215,11 +228,14 @@ export interface ThinkingToggleEvent {
   from: string;
 }
 
-export interface QuestionDismissedEvent {}
+export interface QuestionDismissedEvent {
+  trace_id?: string;
+}
 
 export interface QuestionAnsweredEvent {
   answered: number;
   method?: 'enter' | 'space' | 'number_key';
+  trace_id?: string;
 }
 
 export type TelemetryGoalActor = 'user' | 'model' | 'runtime' | 'system';
@@ -262,12 +278,14 @@ export interface ToolCallDedupDetectedEvent {
   tool_name: string;
   dup_type: 'same_step' | 'cross_step';
   args_hash: string;
+  trace_id?: string;
 }
 
 export interface ToolCallRepeatEvent {
   tool_name: string;
   repeat_count: number;
   action: 'none' | 'r1' | 'r2' | 'r3' | 'stop';
+  trace_id?: string;
 }
 
 export interface GrepToolRgFallbackEvent {
@@ -388,6 +406,7 @@ export const telemetryEventDefinitions = {
     owner: 'kimi-code',
     comment: 'A turn starts running.',
     properties: {
+      turn_id: 'Per-agent turn index (main or subagent); not unique across agents in the same session',
       mode: 'Agent mode the turn runs in',
       provider_type: 'Provider protocol type',
       protocol: 'Request protocol',
@@ -397,35 +416,43 @@ export const telemetryEventDefinitions = {
     owner: 'kimi-code',
     comment: 'A running turn is interrupted.',
     properties: {
+      turn_id: 'Per-agent turn index (main or subagent); not unique across agents in the same session',
       at_step: 'Step index the turn reached before interruption',
       mode: 'Agent mode the turn ran in',
       interrupt_reason: 'Why the turn was interrupted',
       provider_type: 'Provider protocol type',
       protocol: 'Request protocol',
+      trace_id:
+        'Trace id of the most recent LLM request in this turn (the failed request when the turn errored); absent for non-Kimi protocols',
     },
   }),
   turn_ended: defineTelemetryEvent<TurnEndedEvent>({
     owner: 'kimi-code',
     comment: 'A turn ends, unconditionally.',
     properties: {
+      turn_id: 'Per-agent turn index (main or subagent); not unique across agents in the same session',
       reason: 'How the turn ended',
       duration_ms: 'Turn wall-clock time in milliseconds',
       mode: 'Agent mode the turn ran in',
       provider_type: 'Provider protocol type',
       protocol: 'Request protocol',
+      trace_id:
+        'Trace id of the most recent LLM request in this turn; absent for non-Kimi protocols',
     },
   }),
   tool_call: defineTelemetryEvent<ToolCallEvent>({
     owner: 'kimi-code',
     comment: 'A tool call finishes execution.',
     properties: {
-      turn_id: 'Turn index within the session',
+      turn_id: 'Per-agent turn index (main or subagent); not unique across agents in the same session',
       tool_call_id: 'Provider-assigned tool call id',
       tool_name: 'Registered tool name',
       outcome: 'Execution outcome',
       duration_ms: 'Wall-clock execution time in milliseconds',
       dup_type: 'Whether the call was a duplicate within the same step or across steps',
       error_type: 'Error category when the call failed',
+      trace_id:
+        'Trace id of the LLM request that produced this tool call; absent for non-Kimi protocols',
     },
   }),
   api_error: defineTelemetryEvent<ApiErrorEvent>({
@@ -441,6 +468,10 @@ export const telemetryEventDefinitions = {
       provider_type: 'Provider protocol type',
       protocol: 'Request protocol',
       input_tokens: "Current turn's accumulated total input tokens",
+      turn_id: 'Turn index within the session, when the request belongs to a turn',
+      step_no: 'Step index within the turn, when the request belongs to a turn step',
+      trace_id:
+        'Trace id of the failed request, from its response headers or its error response; absent when the failure happened before any response headers arrived (network errors, local aborts), and for non-Kimi protocols',
     },
   }),
   skill_invoked: defineTelemetryEvent<SkillInvokedEvent>({
@@ -464,7 +495,11 @@ export const telemetryEventDefinitions = {
   cancel: defineTelemetryEvent<CancelEvent>({
     owner: 'kimi-code',
     comment: 'The user cancels ongoing work.',
-    properties: { from: 'What was running when cancelled' },
+    properties: {
+      from: 'What was running when cancelled',
+      trace_id:
+        'Trace id of the in-flight request, or of the most recent request between steps; absent for non-Kimi protocols',
+    },
   }),
   conversation_undo: defineTelemetryEvent<ConversationUndoEvent>({
     owner: 'kimi-code',
@@ -503,6 +538,8 @@ export const telemetryEventDefinitions = {
       duration_ms: 'Time the approval took in milliseconds',
       session_cache_written: 'Whether a session approval rule was cached',
       has_feedback: 'Whether the user attached feedback',
+      trace_id:
+        'Trace id of the LLM request that produced the gated tool call; absent for non-Kimi protocols',
     },
   }),
   plan_submitted: defineTelemetryEvent<PlanSubmittedEvent>({
@@ -541,6 +578,8 @@ export const telemetryEventDefinitions = {
       output_tokens: 'Output tokens',
       input_cache_read: 'Cache-read input tokens',
       input_cache_creation: 'Cache-creation input tokens',
+      trace_id:
+        'Trace id of the final compaction request round; absent for non-Kimi protocols',
     },
   }),
   compaction_failed: defineTelemetryEvent<CompactionFailedEvent>({
@@ -554,6 +593,8 @@ export const telemetryEventDefinitions = {
       retry_count: 'Number of retries attempted',
       thinking_effort: 'Thinking effort level in effect',
       error_type: 'Error class name',
+      trace_id:
+        'Trace id of the failed compaction request, from its response headers or its error response; absent when the failure happened before any request or before response headers arrived (network errors), and for non-Kimi protocols',
     },
   }),
   context_projection_repaired: defineTelemetryEvent<ContextProjectionRepairedEvent>({
@@ -601,7 +642,10 @@ export const telemetryEventDefinitions = {
   question_dismissed: defineTelemetryEvent<QuestionDismissedEvent>({
     owner: 'kimi-code',
     comment: 'A user question prompt is dismissed.',
-    properties: {},
+    properties: {
+      trace_id:
+        'Trace id of the LLM request that produced the questioning tool call; absent for non-Kimi protocols',
+    },
   }),
   question_answered: defineTelemetryEvent<QuestionAnsweredEvent>({
     owner: 'kimi-code',
@@ -609,6 +653,8 @@ export const telemetryEventDefinitions = {
     properties: {
       answered: 'Number of questions answered',
       method: 'Input method used to answer',
+      trace_id:
+        'Trace id of the LLM request that produced the questioning tool call; absent for non-Kimi protocols',
     },
   }),
   goal_created: defineTelemetryEvent<GoalCreatedEvent>({
@@ -657,12 +703,14 @@ export const telemetryEventDefinitions = {
     owner: 'kimi-code',
     comment: 'A duplicate tool call is detected.',
     properties: {
-      turn_id: 'Turn index within the session',
+      turn_id: 'Per-agent turn index (main or subagent); not unique across agents in the same session',
       step_no: 'Step index within the turn',
       tool_call_id: 'Provider-assigned tool call id',
       tool_name: 'Registered tool name',
       dup_type: 'Whether the duplicate is within the same step or across steps',
       args_hash: 'Hash of the tool call arguments',
+      trace_id:
+        'Trace id of the LLM request that produced the duplicate tool call; absent for non-Kimi protocols',
     },
   }),
   tool_call_repeat: defineTelemetryEvent<ToolCallRepeatEvent>({
@@ -672,6 +720,8 @@ export const telemetryEventDefinitions = {
       tool_name: 'Registered tool name',
       repeat_count: 'Length of the repeat streak',
       action: 'Intervention action taken',
+      trace_id:
+        'Trace id of the LLM request that produced the repeated tool call; absent for non-Kimi protocols',
     },
   }),
   grep_tool_rg_fallback: defineTelemetryEvent<GrepToolRgFallbackEvent>({
diff --git a/packages/agent-core-v2/src/app/web/providers/local-fetch-url.ts b/packages/agent-core-v2/src/app/web/providers/local-fetch-url.ts
index 30ae12b0c..bd785f0d2 100644
--- a/packages/agent-core-v2/src/app/web/providers/local-fetch-url.ts
+++ b/packages/agent-core-v2/src/app/web/providers/local-fetch-url.ts
@@ -1,5 +1,26 @@
+/**
+ * `web` domain (L4) — local `UrlFetcher` used when no managed fetch service
+ * is configured. GETs URLs with a Chrome-like UA and SSRF hardening: http(s)
+ * schemes only; unless `allowPrivateAddresses` is set, IP literals and
+ * DNS-resolved addresses in loopback / RFC1918 / link-local / CGNAT / ULA
+ * ranges are refused, including IPv4-mapped IPv6 forms; redirects are
+ * followed manually with the same validation re-run on every hop; and each
+ * request's connection is pinned to the DNS answers validation approved, so
+ * a connect-time re-resolution cannot be rebound elsewhere (pinning is
+ * skipped for IP literals and for requests a proxy will carry — NO_PROXY
+ * bypasses still pin). Oversized bodies are refused; plain texts pass
+ * through verbatim and HTML is reduced to its main text.
+ */
+
+import { lookup as callbackLookup, type LookupAddress, type LookupOptions } from 'node:dns';
+import { lookup } from 'node:dns/promises';
+import { BlockList, isIP, type LookupFunction } from 'node:net';
+
 import { Readability } from '@mozilla/readability';
 import { parseHTML as rawParseHTML } from 'linkedom';
+import { Agent, type Dispatcher } from 'undici';
+
+import { isProxyConfigured, makeNoProxyMatcher, resolveNoProxy } from '#/_base/utils/proxy';
 
 import { HttpFetchError, type UrlFetcher, type UrlFetchResult } from '../tools/fetch-url-types';
 
@@ -20,6 +41,10 @@ const DEFAULT_USER_AGENT =
 
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 
+const MAX_REDIRECT_HOPS = 10;
+
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+
 export interface LocalFetchURLProviderOptions {
   userAgent?: string;
   fetchImpl?: typeof fetch;
@@ -44,14 +69,25 @@ export class LocalFetchURLProvider implements UrlFetcher {
     url: string,
     options?: { toolCallId?: string; signal?: AbortSignal },
   ): Promise<UrlFetchResult> {
-    assertSafeFetchTarget(url, this.allowPrivateAddresses);
-
-    const response = await this.fetchImpl(url, {
-      method: 'GET',
-      headers: { 'User-Agent': this.userAgent },
-      signal: options?.signal,
-    });
+    const dispatchers: Dispatcher[] = [];
+    try {
+      const response = await this.requestWithValidatedRedirects(
+        url,
+        options?.signal,
+        dispatchers,
+      );
+      return await this.readResponse(response);
+    } finally {
+      await Promise.all(
+        dispatchers.map((dispatcher) =>
+          dispatcher.close().catch(() => {
+          }),
+        ),
+      );
+    }
+  }
 
+  private async readResponse(response: Response): Promise<UrlFetchResult> {
     if (response.status >= 400) {
       await response.body?.cancel().catch(() => {
       });
@@ -65,6 +101,8 @@ export class LocalFetchURLProvider implements UrlFetcher {
     if (contentLengthRaw !== null) {
       const cl = Number(contentLengthRaw);
       if (Number.isFinite(cl) && cl > this.maxBytes) {
+        await response.body?.cancel().catch(() => {
+        });
         throw new Error(
           `Response body too large: ${String(cl)} bytes exceeds maxBytes (${String(this.maxBytes)}).`,
         );
@@ -88,6 +126,55 @@ export class LocalFetchURLProvider implements UrlFetcher {
     return { content: this.extractMainContent(body), kind: 'extracted' };
   }
 
+  private async requestWithValidatedRedirects(
+    url: string,
+    signal: AbortSignal | undefined,
+    dispatchers: Dispatcher[],
+  ): Promise<Response> {
+    let currentUrl = url;
+    let redirects = 0;
+    for (;;) {
+      const target = await resolveSafeFetchTarget(currentUrl, this.allowPrivateAddresses);
+      const response = await this.fetchImpl(currentUrl, {
+        method: 'GET',
+        headers: { 'User-Agent': this.userAgent },
+        signal,
+        redirect: 'manual',
+        dispatcher: this.pinnedDispatcherFor(target, dispatchers) as unknown,
+      } as RequestInit);
+      if (!REDIRECT_STATUSES.has(response.status)) return response;
+      const location = response.headers.get('location');
+      if (location === null) return response;
+      await response.body?.cancel().catch(() => {
+      });
+      if (redirects >= MAX_REDIRECT_HOPS) {
+        throw new Error(
+          `Too many redirects while fetching "${url}" (limit ${String(MAX_REDIRECT_HOPS)}).`,
+        );
+      }
+      redirects += 1;
+      currentUrl = new URL(location, currentUrl).toString();
+    }
+  }
+
+  private pinnedDispatcherFor(
+    target: SafeFetchTarget,
+    dispatchers: Dispatcher[],
+  ): Dispatcher | undefined {
+    if (target.addresses === undefined) return undefined;
+    if (
+      isProxyConfigured(process.env) &&
+      !makeNoProxyMatcher(resolveNoProxy(process.env))(target.host, target.port)
+    ) {
+      return undefined;
+    }
+    const dispatcher = new Agent({
+      connect: { lookup: pinnedLookup(target.host, target.addresses) },
+    });
+    dispatchers.push(dispatcher);
+    return dispatcher;
+  }
+
   private extractMainContent(html: string): string {
     const primary = parseHTML(html);
     try {
@@ -123,7 +210,35 @@ export class LocalFetchURLProvider implements UrlFetcher {
   }
 }
 
-function assertSafeFetchTarget(url: string, allowPrivate: boolean): void {
+const PRIVATE_ADDRESS_BLOCKLIST = (() => {
+  const list = new BlockList();
+  list.addSubnet('0.0.0.0', 8, 'ipv4');
+  list.addSubnet('10.0.0.0', 8, 'ipv4');
+  list.addSubnet('100.64.0.0', 10, 'ipv4');
+  list.addSubnet('127.0.0.0', 8, 'ipv4');
+  list.addSubnet('169.254.0.0', 16, 'ipv4');
+  list.addSubnet('172.16.0.0', 12, 'ipv4');
+  list.addSubnet('192.168.0.0', 16, 'ipv4');
+  list.addSubnet('::', 128, 'ipv6');
+  list.addSubnet('::1', 128, 'ipv6');
+  list.addSubnet('fc00::', 7, 'ipv6');
+  list.addSubnet('fe80::', 10, 'ipv6');
+  return list;
+})();
+
+function isBlockedAddress(address: string): boolean {
+  const normalized = address.split('%', 1)[0] ?? address;
+  if (isIP(normalized) === 4) return PRIVATE_ADDRESS_BLOCKLIST.check(normalized, 'ipv4');
+  return isIP(normalized) === 6 && PRIVATE_ADDRESS_BLOCKLIST.check(normalized, 'ipv6');
+}
+
+interface SafeFetchTarget {
+  host: string;
+  port: string;
+  addresses?: LookupAddress[];
+}
+
+async function resolveSafeFetchTarget(url: string, allowPrivate: boolean): Promise<SafeFetchTarget> {
   let parsed: URL;
   try {
     parsed = new URL(url);
@@ -133,45 +248,53 @@ function assertSafeFetchTarget(url: string, allowPrivate: boolean): void {
   if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
     throw new Error(`Unsupported URL scheme "${parsed.protocol}" — only http(s) allowed.`);
   }
-  if (allowPrivate) return;
   const hostRaw = parsed.hostname.toLowerCase();
   const host = hostRaw.startsWith('[') && hostRaw.endsWith(']') ? hostRaw.slice(1, -1) : hostRaw;
+  const port = parsed.port !== '' ? parsed.port : parsed.protocol === 'https:' ? '443' : '80';
+  if (allowPrivate) return { host, port };
+  if (isIP(host) !== 0) {
+    if (isBlockedAddress(host)) {
+      throw new Error(`Refusing to fetch private address: "${host}"`);
+    }
+    return { host, port };
+  }
   if (host === 'localhost' || host.endsWith('.localhost')) {
     throw new Error(`Refusing to fetch private host: "${host}"`);
   }
-  if (
-    host === '::1' ||
-    host === '::' ||
-    host.startsWith('fe80:') ||
-    host.startsWith('fc') ||
-    host.startsWith('fd')
-  ) {
-    throw new Error(`Refusing to fetch private host: "${host}"`);
+  let addresses: LookupAddress[];
+  try {
+    addresses = await lookup(host, { all: true });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot resolve host "${host}" for the fetch safety check: ${detail}`, {
+      cause: error,
+    });
   }
-  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
-  if (v4 !== null) {
-    const octets = [v4[1], v4[2], v4[3], v4[4]].map(Number);
-    if (octets.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
-      throw new Error(`Invalid IPv4 literal: "${host}"`);
-    }
-    const [a, b] = octets as [number, number, number, number];
-    const isLoopback = a === 127;
-    const isPrivate10 = a === 10;
-    const isPrivate192 = a === 192 && b === 168;
-    const isPrivate172 = a === 172 && b >= 16 && b <= 31;
-    const isLinkLocal = a === 169 && b === 254;
-    const isZero = a === 0;
-    const isCgnat = a === 100 && b >= 64 && b <= 127;
-    if (
-      isLoopback ||
-      isPrivate10 ||
-      isPrivate192 ||
-      isPrivate172 ||
-      isLinkLocal ||
-      isZero ||
-      isCgnat
-    ) {
-      throw new Error(`Refusing to fetch private address: "${host}"`);
+  for (const { address } of addresses) {
+    if (isBlockedAddress(address)) {
+      throw new Error(`Refusing to fetch host "${host}": resolves to private address "${address}".`);
     }
   }
+  return { host, port, addresses };
 }
+
+function pinnedLookup(host: string, addresses: LookupAddress[]): LookupFunction {
+  return (hostname: string, options: LookupOptions | undefined, callback: PinnedLookupCallback) => {
+    if (hostname !== host) {
+      callbackLookup(hostname, options ?? {}, callback);
+      return;
+    }
+    if (options?.all === true) {
+      callback(null, [...addresses]);
+      return;
+    }
+    const single = addresses.find((entry) => entry.family === options?.family) ?? addresses[0]!;
+    callback(null, single.address, single.family);
+  };
+}
+
+type PinnedLookupCallback = (
+  err: NodeJS.ErrnoException | null,
+  addressOrList: string | LookupAddress[],
+  family?: number,
+) => void;
diff --git a/packages/agent-core-v2/src/app/workspaceRegistry/errors.ts b/packages/agent-core-v2/src/app/workspaceRegistry/errors.ts
new file mode 100644
index 000000000..9c7752791
--- /dev/null
+++ b/packages/agent-core-v2/src/app/workspaceRegistry/errors.ts
@@ -0,0 +1,9 @@
+import { registerErrorDomain, type ErrorDomain } from '#/_base/errors/codes';
+
+export const WorkspaceErrors = {
+  codes: {
+    WORKSPACE_NOT_FOUND: 'workspace.not_found',
+  },
+} as const satisfies ErrorDomain;
+
+registerErrorDomain(WorkspaceErrors);
diff --git a/packages/agent-core-v2/src/app/workspaceRegistry/fileWorkspacePersistence.ts b/packages/agent-core-v2/src/app/workspaceRegistry/fileWorkspacePersistence.ts
index dfa05670b..7f04827d0 100644
--- a/packages/agent-core-v2/src/app/workspaceRegistry/fileWorkspacePersistence.ts
+++ b/packages/agent-core-v2/src/app/workspaceRegistry/fileWorkspacePersistence.ts
@@ -4,7 +4,10 @@
  * File backend of `IWorkspacePersistence`. Persists the catalog as a single
  * v1-compatible `workspaces.json` document at the storage root
  * (`<homeDir>/workspaces.json`, via `scope = ''`) through the
- * `IAtomicDocumentStore` access-pattern Store. Bound at App scope.
+ * `IAtomicDocumentStore` access-pattern Store. The `deleted_workspace_ids`
+ * tombstone list round-trips with the catalog so soft deletions survive
+ * regardless of which engine (v1 or v2) last wrote the file. Bound at App
+ * scope.
  */
 
 import { InstantiationType } from '#/_base/di/extensions';
@@ -16,6 +19,7 @@ import {
   IWorkspacePersistence,
   type PersistedWorkspaceEntry,
   type PersistedWorkspaceFile,
+  type WorkspaceCatalog,
 } from './workspacePersistence';
 
 const WORKSPACE_REGISTRY_VERSION = 1;
@@ -27,7 +31,7 @@ export class FileWorkspacePersistence implements IWorkspacePersistence {
 
   constructor(@IAtomicDocumentStore private readonly docs: IAtomicDocumentStore) {}
 
-  async load(): Promise<Workspace[] | undefined> {
+  async load(): Promise<WorkspaceCatalog | undefined> {
     const file = await this.docs.get<PersistedWorkspaceFile>(
       WORKSPACE_REGISTRY_SCOPE,
       WORKSPACE_REGISTRY_KEY,
@@ -42,11 +46,11 @@ export class FileWorkspacePersistence implements IWorkspacePersistence {
       return undefined;
     }
     const now = Date.now();
-    const result: Workspace[] = [];
+    const workspaces: Workspace[] = [];
     for (const [id, raw] of Object.entries(file.workspaces)) {
-      const entry = sanitizeEntry(raw, now);
+      const entry = sanitizeEntry(raw);
       if (entry === null) continue;
-      result.push({
+      workspaces.push({
         id,
         root: entry.root,
         name: entry.name,
@@ -54,12 +58,16 @@ export class FileWorkspacePersistence implements IWorkspacePersistence {
         lastOpenedAt: parseTime(entry.last_opened_at, now),
       });
     }
-    return result;
+    const rawDeleted = (file as { deleted_workspace_ids?: unknown }).deleted_workspace_ids;
+    const deletedIds = Array.isArray(rawDeleted)
+      ? rawDeleted.filter((id): id is string => typeof id === 'string')
+      : [];
+    return { workspaces, deletedIds };
   }
 
-  async save(workspaces: readonly Workspace[]): Promise<void> {
+  async save(catalog: WorkspaceCatalog): Promise<void> {
     const record: Record<string, PersistedWorkspaceEntry> = {};
-    for (const ws of workspaces) {
+    for (const ws of catalog.workspaces) {
       record[ws.id] = {
         root: ws.root,
         name: ws.name,
@@ -70,12 +78,13 @@ export class FileWorkspacePersistence implements IWorkspacePersistence {
     const file: PersistedWorkspaceFile = {
       version: WORKSPACE_REGISTRY_VERSION,
       workspaces: record,
+      deleted_workspace_ids: [...catalog.deletedIds],
     };
     await this.docs.set(WORKSPACE_REGISTRY_SCOPE, WORKSPACE_REGISTRY_KEY, file);
   }
 }
 
-function sanitizeEntry(value: unknown, _now: number): PersistedWorkspaceEntry | null {
+function sanitizeEntry(value: unknown): PersistedWorkspaceEntry | null {
   if (typeof value !== 'object' || value === null) return null;
   const v = value as Partial<PersistedWorkspaceEntry>;
   if (
diff --git a/packages/agent-core-v2/src/app/workspaceRegistry/workspacePersistence.ts b/packages/agent-core-v2/src/app/workspaceRegistry/workspacePersistence.ts
index 8a06729a5..46ae19c20 100644
--- a/packages/agent-core-v2/src/app/workspaceRegistry/workspacePersistence.ts
+++ b/packages/agent-core-v2/src/app/workspaceRegistry/workspacePersistence.ts
@@ -3,13 +3,20 @@
  *
  * Domain-specific persistence Store for the known-workspaces catalog. It hides
  * the on-disk document layout (`<homeDir>/workspaces.json`, the v1-compatible
- * `{ version, workspaces: { [id]: entry } }` shape) and its serialization
- * concerns (ISO ↔ epoch-ms, record ↔ array) from the registry. The generic
- * `IAtomicDocumentStore` it builds on stays schema-agnostic.
+ * `{ version, workspaces: { [id]: entry }, deleted_workspace_ids: string[] }`
+ * shape — shared with agent-core, which reads and writes the same file) and
+ * its serialization concerns (ISO ↔ epoch-ms, record ↔ array) from the
+ * registry. The generic `IAtomicDocumentStore` it builds on stays
+ * schema-agnostic.
+ *
+ * `deleted_workspace_ids` is the soft-delete tombstone list: ids the user
+ * explicitly removed. Tombstoned entries are absent from `workspaces`, but
+ * their ids must survive load/save round-trips so the session-index merge
+ * never resurrects them.
  *
  * `load()` returns `undefined` to mean "no usable catalog" so the registry can
- * trigger a one-shot rebuild from the legacy session index; an empty array is
- * a valid, already-materialized catalog and must NOT trigger a rebuild.
+ * trigger a one-shot rebuild from the legacy session index; an empty catalog
+ * is a valid, already-materialized state and must NOT trigger a rebuild.
  */
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
@@ -26,13 +33,19 @@ export interface PersistedWorkspaceEntry {
 export interface PersistedWorkspaceFile {
   readonly version: number;
   readonly workspaces: Record<string, PersistedWorkspaceEntry>;
+  readonly deleted_workspace_ids: string[];
+}
+
+export interface WorkspaceCatalog {
+  readonly workspaces: readonly Workspace[];
+  readonly deletedIds: readonly string[];
 }
 
 export interface IWorkspacePersistence {
   readonly _serviceBrand: undefined;
 
-  load(): Promise<Workspace[] | undefined>;
-  save(workspaces: readonly Workspace[]): Promise<void>;
+  load(): Promise<WorkspaceCatalog | undefined>;
+  save(catalog: WorkspaceCatalog): Promise<void>;
 }
 
 export const IWorkspacePersistence: ServiceIdentifier<IWorkspacePersistence> =
diff --git a/packages/agent-core-v2/src/app/workspaceRegistry/workspaceRegistryService.ts b/packages/agent-core-v2/src/app/workspaceRegistry/workspaceRegistryService.ts
index 3b45b82e7..75277c292 100644
--- a/packages/agent-core-v2/src/app/workspaceRegistry/workspaceRegistryService.ts
+++ b/packages/agent-core-v2/src/app/workspaceRegistry/workspaceRegistryService.ts
@@ -1,20 +1,42 @@
 /**
  * `workspaceRegistry` domain (L1) — `IWorkspaceRegistry` implementation.
  *
- * Process-wide catalog of known workspaces, now durable: an in-memory cache
- * is loaded once from `IWorkspacePersistence` (`<homeDir>/workspaces.json`, v1
- * compatible) and every mutation writes back through it. When the catalog is
- * absent or malformed, it is rebuilt once from the legacy
- * `<homeDir>/session_index.jsonl` (one workspace per distinct absolute
- * `workDir`) and then persisted. All access is serialized through a
- * promise-chain mutex so load/rebuild/mutations never race.
+ * Process-wide catalog of known workspaces, durable in
+ * `<homeDir>/workspaces.json` (the v1-compatible file shared with
+ * agent-core). The service keeps NO in-memory write cache: every operation
+ * is a fresh read-modify-write against the file, serialized through a
+ * promise-chain mutex. This is required, not just tidy — the same file is
+ * written concurrently by other processes (the v1 TUI registers session cwds
+ * via `touchWorkspaceRegistry`, which also re-reads the file on every call),
+ * so a write-through cache would clobber external additions and tombstones
+ * with stale state. Atomic renames at the persistence layer plus fresh
+ * read-modify-write on both engines shrink the lost-update window to a
+ * single read-modify-write, and the next session-index merge heals anything
+ * still lost there.
+ *
+ * Once per process, the first operation triggers the startup sync with the
+ * legacy `<homeDir>/session_index.jsonl`:
+ *
+ * 1. No usable catalog file → one-shot rebuild (one workspace per distinct
+ *    absolute `workDir`), persisted.
+ * 2. Catalog loaded → only workDirs the file does not know about yet are
+ *    added (e.g. sessions created by the v1 TUI since the last sync),
+ *    persisted if anything changed.
+ *
+ * Deletion is soft: `delete` drops the entry but records the id in
+ * `deleted_workspace_ids`, and the merge never resurrects a tombstoned id.
+ * An explicit `createOrTouch` clears the tombstone — the user opening the
+ * folder again is a stronger signal than the historical index.
  *
  * `createOrTouch` is the single choke point every workspace/session creation
  * funnels through, so it owns the root-existence contract: the root must be
  * an existing directory on the host filesystem, otherwise it throws
- * `fs.path_not_found` (mirrors v1's `WorkspaceRootNotFoundError`). The rebuild
- * path bypasses the check on purpose — it catalogs where sessions *were*, not
- * where new ones may open. Bound at App scope.
+ * `fs.path_not_found` (mirrors v1's `WorkspaceRootNotFoundError`). The
+ * directory probe follows symlinks (`IHostFileSystem.stat` is lstat-based, so
+ * a symlink-form root is re-checked through `realpath`), while the workspace
+ * identity stays lexical — v1 deliberately never realpaths the root either.
+ * The rebuild and merge paths bypass the check on purpose — they catalog
+ * where sessions *were*, not where new ones may open. Bound at App scope.
  */
 
 import { basename, isAbsolute } from 'pathe';
@@ -27,7 +49,7 @@ import { IHostFileSystem } from '#/os/interface/hostFileSystem';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 
 import { IWorkspaceRegistry, type Workspace, type WorkspaceUpdate } from './workspaceRegistry';
-import { IWorkspacePersistence } from './workspacePersistence';
+import { IWorkspacePersistence, type WorkspaceCatalog } from './workspacePersistence';
 
 const SESSION_INDEX_SCOPE = '';
 const SESSION_INDEX_KEY = 'session_index.jsonl';
@@ -43,7 +65,8 @@ interface SessionIndexLine {
 export class WorkspaceRegistryService implements IWorkspaceRegistry {
   declare readonly _serviceBrand: undefined;
 
-  private cache: Map<string, Workspace> | undefined;
+  /** Whether the once-per-process session-index sync already ran. */
+  private merged = false;
   private opQueue: Promise<unknown> = Promise.resolve();
 
   constructor(
@@ -54,21 +77,23 @@ export class WorkspaceRegistryService implements IWorkspaceRegistry {
 
   list(): Promise<readonly Workspace[]> {
     return this.runExclusive(async () => {
-      const cache = await this.ensureLoaded();
-      return dedupeByRoot(cache);
+      await this.ensureMerged();
+      const catalog = await this.loadCatalog();
+      const byId = new Map(catalog.workspaces.map((ws) => [ws.id, ws]));
+      return dedupeByRoot(byId);
     });
   }
 
   get(id: string): Promise<Workspace | undefined> {
     return this.runExclusive(async () => {
-      const cache = await this.ensureLoaded();
-      return cache.get(id);
+      await this.ensureMerged();
+      const catalog = await this.loadCatalog();
+      return catalog.workspaces.find((ws) => ws.id === id);
     });
   }
 
   createOrTouch(root: string, name?: string): Promise<Workspace> {
     return this.runExclusive(async () => {
-      const cache = await this.ensureLoaded();
       let stat;
       try {
         stat = await this.hostFs.stat(root);
@@ -79,11 +104,22 @@ export class WorkspaceRegistryService implements IWorkspaceRegistry {
         }
         throw error;
       }
+      if (!stat.isDirectory) {
+        try {
+          stat = await this.hostFs.stat(await this.hostFs.realpath(root));
+        } catch {
+          // Fall through to the not-a-directory error below.
+        }
+      }
       if (!stat.isDirectory) {
         throw new Error2(ErrorCodes.FS_PATH_NOT_FOUND, `workspace root ${root} is not a directory`);
       }
+      await this.ensureMerged();
+      const catalog = await this.loadCatalog();
+      const byId = new Map(catalog.workspaces.map((ws) => [ws.id, ws]));
+      const deletedIds = new Set(catalog.deletedIds);
       const id = encodeWorkDirKey(root);
-      const existing = cache.get(id);
+      const existing = byId.get(id);
       const now = Date.now();
       const ws: Workspace =
         existing !== undefined
@@ -95,70 +131,125 @@ export class WorkspaceRegistryService implements IWorkspaceRegistry {
               createdAt: now,
               lastOpenedAt: now,
             };
-      cache.set(id, ws);
-      await this.store.save([...cache.values()]);
+      byId.set(id, ws);
+      // An explicit add clears any prior deletion tombstone.
+      deletedIds.delete(id);
+      await this.store.save({ workspaces: [...byId.values()], deletedIds: [...deletedIds] });
       return ws;
     });
   }
 
   update(id: string, patch: WorkspaceUpdate): Promise<Workspace | undefined> {
     return this.runExclusive(async () => {
-      const cache = await this.ensureLoaded();
-      const existing = cache.get(id);
+      await this.ensureMerged();
+      const catalog = await this.loadCatalog();
+      const existing = catalog.workspaces.find((ws) => ws.id === id);
       if (existing === undefined) return undefined;
       const updated: Workspace = {
         ...existing,
         ...(patch.name !== undefined ? { name: patch.name } : {}),
       };
-      cache.set(id, updated);
-      await this.store.save([...cache.values()]);
+      await this.store.save({
+        workspaces: catalog.workspaces.map((ws) => (ws.id === id ? updated : ws)),
+        deletedIds: catalog.deletedIds,
+      });
       return updated;
     });
   }
 
   delete(id: string): Promise<void> {
     return this.runExclusive(async () => {
-      const cache = await this.ensureLoaded();
-      cache.delete(id);
-      await this.store.save([...cache.values()]);
+      await this.ensureMerged();
+      const catalog = await this.loadCatalog();
+      // Soft delete: tombstone the id so the session-index merge cannot
+      // resurrect it, even if sessions still reference the workDir.
+      await this.store.save({
+        workspaces: catalog.workspaces.filter((ws) => ws.id !== id),
+        deletedIds: [...new Set([...catalog.deletedIds, id])],
+      });
     });
   }
 
-  private async ensureLoaded(): Promise<Map<string, Workspace>> {
-    if (this.cache !== undefined) return this.cache;
+  /** Once-per-process startup sync with the legacy session index (see the
+   *  file header). Runs inside the op mutex, so it cannot interleave with a
+   *  mutation's read-modify-write. */
+  private async ensureMerged(): Promise<void> {
+    if (this.merged) return;
     const loaded = await this.store.load();
-    if (loaded !== undefined) {
-      this.cache = new Map(loaded.map((ws) => [ws.id, ws]));
-      return this.cache;
+    if (loaded === undefined) {
+      const rebuilt = await this.rebuildFromSessionIndex();
+      await this.store.save({ workspaces: [...rebuilt.values()], deletedIds: [] });
+      this.merged = true;
+      return;
     }
-    const rebuilt = await this.rebuildFromSessionIndex();
-    this.cache = rebuilt;
-    await this.store.save([...rebuilt.values()]);
-    return this.cache;
+    const byId = new Map(loaded.workspaces.map((ws) => [ws.id, ws]));
+    const deletedIds = new Set(loaded.deletedIds);
+    if (await this.mergeFromSessionIndex(byId, deletedIds)) {
+      await this.store.save({ workspaces: [...byId.values()], deletedIds: [...deletedIds] });
+    }
+    this.merged = true;
+  }
+
+  /** Read the current catalog; a missing or malformed file is an empty
+   *  catalog (mirrors v1's tolerant read). */
+  private async loadCatalog(): Promise<WorkspaceCatalog> {
+    return (await this.store.load()) ?? { workspaces: [], deletedIds: [] };
+  }
+
+  /** Add every distinct workDir from the legacy session index that the
+   *  catalog does not know about yet. Tombstoned ids are skipped, so a
+   *  soft-deleted workspace stays deleted. Returns whether anything changed. */
+  private async mergeFromSessionIndex(
+    byId: Map<string, Workspace>,
+    deletedIds: ReadonlySet<string>,
+  ): Promise<boolean> {
+    let changed = false;
+    const now = Date.now();
+    for (const workDir of await this.readSessionIndexWorkDirs()) {
+      const id = encodeWorkDirKey(workDir);
+      if (byId.has(id) || deletedIds.has(id)) continue;
+      byId.set(id, {
+        id,
+        root: workDir,
+        name: basename(workDir),
+        createdAt: now,
+        lastOpenedAt: now,
+      });
+      changed = true;
+    }
+    return changed;
   }
 
   private async rebuildFromSessionIndex(): Promise<Map<string, Workspace>> {
     const result = new Map<string, Workspace>();
-    const bytes = await this.storage.read(SESSION_INDEX_SCOPE, SESSION_INDEX_KEY);
-    if (bytes === undefined) return result;
     const now = Date.now();
+    for (const workDir of await this.readSessionIndexWorkDirs()) {
+      const id = encodeWorkDirKey(workDir);
+      if (result.has(id)) continue;
+      result.set(id, {
+        id,
+        root: workDir,
+        name: basename(workDir),
+        createdAt: now,
+        lastOpenedAt: now,
+      });
+    }
+    return result;
+  }
+
+  private async readSessionIndexWorkDirs(): Promise<readonly string[]> {
+    const bytes = await this.storage.read(SESSION_INDEX_SCOPE, SESSION_INDEX_KEY);
+    if (bytes === undefined) return [];
+    const workDirs: string[] = [];
     for (const line of textDecoder.decode(bytes).split(/\r?\n/)) {
       const trimmed = line.trim();
       if (trimmed === '') continue;
       const entry = parseSessionIndexLine(trimmed);
       if (entry === undefined) continue;
       if (!isAbsolute(entry.workDir)) continue;
-      const id = encodeWorkDirKey(entry.workDir);
-      if (result.has(id)) continue;
-      result.set(id, {
-        id,
-        root: entry.workDir,
-        name: basename(entry.workDir),
-        createdAt: now,
-        lastOpenedAt: now,
-      });
+      workDirs.push(entry.workDir);
     }
-    return result;
+    return workDirs;
   }
 
   private runExclusive<T>(op: () => Promise<T>): Promise<T> {
@@ -193,9 +284,9 @@ function parseSessionIndexLine(line: string): SessionIndexLine | undefined {
   }
 }
 
-function dedupeByRoot(cache: ReadonlyMap<string, Workspace>): Workspace[] {
+function dedupeByRoot(byId: ReadonlyMap<string, Workspace>): Workspace[] {
   const byRoot = new Map<string, Workspace>();
-  for (const ws of cache.values()) {
+  for (const ws of byId.values()) {
     const existing = byRoot.get(ws.root);
     if (existing === undefined) {
       byRoot.set(ws.root, ws);
diff --git a/packages/agent-core-v2/src/errors.ts b/packages/agent-core-v2/src/errors.ts
index 8e9e2cc80..b6935173a 100644
--- a/packages/agent-core-v2/src/errors.ts
+++ b/packages/agent-core-v2/src/errors.ts
@@ -9,7 +9,6 @@
 
 import { CoreErrors } from '#/_base/errors/codes';
 import { AgentLifecycleErrors } from '#/session/agentLifecycle/errors';
-import { ActivityErrors } from '#/activity/errors';
 import { AuthErrors } from '#/app/auth/errors';
 import { TaskErrors } from '#/agent/task/errors';
 import { ChatProviderErrors } from '#/app/protocol/errors';
@@ -34,7 +33,7 @@ import { StorageErrors } from '#/persistence/interface/storage';
 import { TerminalErrors } from '#/os/interface/terminalErrors';
 import { UsageErrors } from '#/agent/usage/errors';
 import { WireErrors } from '#/wire/errors';
-import { WireRecordErrors } from '#/agent/wireRecord/errors';
+import { WorkspaceErrors } from '#/app/workspaceRegistry/errors';
 
 export * from '#/_base/errors/codes';
 export * from '#/_base/errors/errorMessage';
@@ -42,7 +41,6 @@ export * from '#/_base/errors/errors';
 export * from '#/_base/errors/serialize';
 export * from '#/_base/errors/unexpectedError';
 export { AgentLifecycleErrors } from '#/session/agentLifecycle/errors';
-export { ActivityErrors } from '#/activity/errors';
 export { AuthErrors } from '#/app/auth/errors';
 export { TaskErrors } from '#/agent/task/errors';
 export { ChatProviderErrors } from '#/app/protocol/errors';
@@ -67,12 +65,11 @@ export { StorageErrors } from '#/persistence/interface/storage';
 export { TerminalErrors } from '#/os/interface/terminalErrors';
 export { UsageErrors } from '#/agent/usage/errors';
 export { WireErrors } from '#/wire/errors';
-export { WireRecordErrors } from '#/agent/wireRecord/errors';
+export { WorkspaceErrors } from '#/app/workspaceRegistry/errors';
 
 export const ErrorCodes = {
   ...CoreErrors.codes,
   ...AgentLifecycleErrors.codes,
-  ...ActivityErrors.codes,
   ...AuthErrors.codes,
   ...TaskErrors.codes,
   ...ChatProviderErrors.codes,
@@ -97,5 +94,13 @@ export const ErrorCodes = {
   ...TerminalErrors.codes,
   ...UsageErrors.codes,
   ...WireErrors.codes,
-  ...WireRecordErrors.codes,
+  ...WorkspaceErrors.codes,
 } as const;
+
+/**
+ * The closed union of every error code a Kimi domain may throw — derived from
+ * the `ErrorCodes` aggregate rather than declared centrally, so each domain's
+ * `errors.ts` is the single source of truth: adding or renaming a code is a
+ * domain-local change with no central list to keep in sync.
+ */
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
diff --git a/packages/agent-core-v2/src/index.ts b/packages/agent-core-v2/src/index.ts
index bc0761b4e..b6513a711 100644
--- a/packages/agent-core-v2/src/index.ts
+++ b/packages/agent-core-v2/src/index.ts
@@ -19,9 +19,10 @@ export * from '#/_base/log/logConfig';
 export * from '#/_base/log/formatter';
 export * from '#/_base/log/fileLog';
 export * from '#/_base/log/logService';
-export { IAgentWireService, ISessionWireService } from '#/wire/tokens';
-export { type IWireService, type WireEmission } from '#/wire/wireService';
-export { defineDerivedModel, type DerivedModelDef } from '#/wire/model';
+export * from '#/wire/wire';
+export * from '#/wire/wireService';
+export * from '#/wire/record';
+export * from '#/wire/migration/migration';
 export * from '#/session/sessionLog/sessionLogService';
 export * from '#/app/telemetry/telemetry';
 export * from '#/app/telemetry/events';
@@ -168,10 +169,8 @@ export * from '#/app/flag/flagService';
 import '#/app/multiServer/flag';
 export * from '#/app/multiServer/flag';
 
-export * from '#/activity/activity';
-export * from '#/activity/activityOps';
-import '#/activity/agentActivityService';
-import '#/activity/sessionActivityKernel';
+export * from '#/agent/activityView/activityView';
+import '#/agent/activityView/activityViewService';
 import '#/agent/plan/profile/plan';
 import '#/agent/plan/tools/enter-plan-mode';
 import '#/agent/plan/tools/exit-plan-mode';
@@ -183,6 +182,8 @@ import '#/agent/goal/tools/create-goal';
 import '#/agent/goal/tools/get-goal';
 import '#/agent/goal/tools/set-goal-budget';
 import '#/agent/goal/tools/update-goal';
+export * from '#/agent/goal/goalDeadlineScheduler';
+import '#/agent/goal/goalDeadlineSchedulerService';
 export * from '#/agent/goal/goal';
 export * from '#/agent/goal/goalService';
 export * from '#/agent/goal/types';
@@ -191,9 +192,6 @@ export * from '#/agent/swarm/swarm';
 export * from '#/agent/swarm/swarmService';
 export * from '#/agent/usage/usage';
 export * from '#/agent/usage/usageService';
-export * from '#/agent/runtime/runtime';
-export * from '#/agent/runtime/runtimeOps';
-export * from '#/agent/runtime/runtimeService';
 export * from '#/agent/toolDedupe/toolDedupe';
 export * from '#/agent/toolDedupe/toolDedupeService';
 import '#/agent/toolSelect/flag';
@@ -206,6 +204,12 @@ export * from '#/agent/toolSelect/toolSelectAnnouncements';
 export * from '#/agent/toolSelect/toolSelectAnnouncementsService';
 
 import '#/agent/task/configSection';
+export {
+  resolveAgentTaskConfig,
+  resolvePrintBackgroundMode,
+  type AgentTaskConfig,
+  type PrintBackgroundMode,
+} from '#/agent/task/configSection';
 import '#/agent/task/tools/task-list';
 import '#/agent/task/tools/task-output';
 import '#/agent/task/tools/task-stop';
@@ -235,6 +239,7 @@ export * from '#/session/subagent/subagentService';
 export * from '#/session/subagent/tools/subagent-task';
 export { AGENT_RUN_PROMPT_ORIGIN } from '#/session/subagent/runAgentTurn';
 export * from '#/session/subagent/mirrorAgentRun';
+import '#/session/subagent/configSection';
 import '#/session/subagent/tools/agent';
 export * from '#/app/sessionLifecycle/sessionLifecycle';
 export * from '#/app/sessionLifecycle/sessionLifecycleService';
@@ -251,8 +256,6 @@ export * from '#/app/sessionLegacy/sessionLegacyService';
 export * from '#/session/interaction/interaction';
 export * from '#/session/interaction/interactionService';
 export * from '#/session/sessionContext/sessionContext';
-export * from '#/session/sessionActivity/sessionActivity';
-export * from '#/session/sessionActivity/sessionActivityService';
 
 import '#/session/approval/approval';
 import '#/session/approval/approvalService';
@@ -424,9 +427,6 @@ export * from '#/agent/prompt/promptService';
 import '#/app/messageLegacy/errors';
 export * from '#/app/messageLegacy/messageLegacy';
 export * from '#/app/messageLegacy/messageLegacyService';
-export * from '#/agent/replayBuilder/agentReplayService';
-export * from '#/agent/replayBuilder/replayProjection';
-export * from '#/agent/replayBuilder/replayTimelineModel';
 export * from '#/agent/replayBuilder/types';
 export * from '#/agent/shellCommand/shellCommand';
 export * from '#/agent/shellCommand/shellCommandService';
@@ -466,7 +466,3 @@ export type { ToolContribution, ToolContributionOptions } from '#/agent/toolRegi
 export * from '#/agent/userTool/userTool';
 export * from '#/agent/userTool/userToolOps';
 export * from '#/agent/userTool/userToolService';
-export * from '#/agent/wireRecord/wireRecord';
-export * from '#/agent/wireRecord/wireRecordService';
-export * from '#/agent/wireRecord/agentWireService';
-export * from '#/agent/wireRecord/metadataOps';
diff --git a/packages/agent-core-v2/src/os/backends/node-local/hostFsService.ts b/packages/agent-core-v2/src/os/backends/node-local/hostFsService.ts
index f9d7fb11e..8d911ce5d 100644
--- a/packages/agent-core-v2/src/os/backends/node-local/hostFsService.ts
+++ b/packages/agent-core-v2/src/os/backends/node-local/hostFsService.ts
@@ -5,7 +5,17 @@
  * Bound at App scope.
  */
 
-import { appendFile, lstat, open, readFile, readdir, mkdir, rm, writeFile } from 'node:fs/promises';
+import {
+  appendFile,
+  lstat,
+  open,
+  readFile,
+  readdir,
+  mkdir,
+  realpath as nodeRealpath,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
@@ -222,6 +232,14 @@ export class HostFileSystem implements IHostFileSystem {
       throw toHostFsError(error, { path, op: 'remove' });
     }
   }
+
+  async realpath(path: string): Promise<string> {
+    try {
+      return await nodeRealpath(path);
+    } catch (error) {
+      throw toHostFsError(error, { path, op: 'realpath' });
+    }
+  }
 }
 
 registerScopedService(
diff --git a/packages/agent-core-v2/src/os/backends/node-local/tools/bash.ts b/packages/agent-core-v2/src/os/backends/node-local/tools/bash.ts
index 564d1f3a0..f7d018992 100644
--- a/packages/agent-core-v2/src/os/backends/node-local/tools/bash.ts
+++ b/packages/agent-core-v2/src/os/backends/node-local/tools/bash.ts
@@ -50,6 +50,7 @@ import { registerTool } from '#/agent/toolRegistry/toolContribution';
 import { toInputJsonSchema } from '#/tool/input-schema';
 import { literalRulePattern, matchesGlobRuleSubject } from '#/tool/rule-match';
 import { renderPrompt } from '#/_base/utils/render-prompt';
+import { userCancellationReason } from '#/_base/utils/abort';
 import bashDescriptionTemplate from './bash.md?raw';
 import { ProcessTask } from './process-task';
 
@@ -58,7 +59,6 @@ const DEFAULT_TIMEOUT_S = 60;
 const MAX_TIMEOUT_S = 5 * 60;
 const DEFAULT_BACKGROUND_TIMEOUT_S = 10 * 60;
 const MAX_BACKGROUND_TIMEOUT_S = 24 * 60 * 60;
-const USER_INTERRUPT_REASON = 'Interrupted by user';
 
 export const BashInputSchema = z
   .object({
@@ -395,8 +395,11 @@ export class BashTool implements BuiltinTool<BashInput> {
       result = builder.error(`Command killed by timeout (${timeoutLabel})`, {
         brief: `Killed by timeout (${timeoutLabel})`,
       });
-    } else if (current?.status === 'killed' && current.stopReason === USER_INTERRUPT_REASON) {
-      result = builder.error(USER_INTERRUPT_REASON, { brief: USER_INTERRUPT_REASON });
+    } else if (
+      current?.status === 'killed' &&
+      current.stopReason === userCancellationReason().message
+    ) {
+      result = builder.error('Interrupted by user', { brief: 'Interrupted by user' });
     } else if (
       (current?.status === 'failed' || current?.status === 'killed') &&
       current.stopReason !== undefined
@@ -453,9 +456,7 @@ export class BashTool implements BuiltinTool<BashInput> {
 
     const foregroundResult = builder.ok('');
     const foregroundOutput = foregroundResult.output.length > 0 ? foregroundResult.output : '';
-    const message = backgroundResultMessage(labels.title, foregroundResult.message);
     const result: ExecutableToolResult & {
-      readonly message: string;
       readonly brief: string;
       readonly truncated: boolean;
     } = {
@@ -464,7 +465,6 @@ export class BashTool implements BuiltinTool<BashInput> {
         foregroundOutput.length === 0
           ? metadata
           : `${metadata}\n\nforeground_output:\n${foregroundOutput}`,
-      message,
       brief: labels.brief,
       truncated: foregroundResult.truncated,
     };
@@ -496,12 +496,6 @@ export class BashTool implements BuiltinTool<BashInput> {
 
 registerTool(BashTool);
 
-function backgroundResultMessage(title: string, suffix: string): string {
-  const normalized = title.endsWith('.') ? title : `${title}.`;
-  if (suffix.length === 0) return normalized;
-  return suffix.endsWith('.') ? `${normalized} ${suffix}` : `${normalized} ${suffix}.`;
-}
-
 function formatTimeoutLabel(timeoutMs: number): string {
   return timeoutMs % 1000 === 0 ? `${String(timeoutMs / 1000)}s` : `${String(timeoutMs)}ms`;
 }
diff --git a/packages/agent-core-v2/src/os/interface/hostFileSystem.ts b/packages/agent-core-v2/src/os/interface/hostFileSystem.ts
index a6ce33be0..9f1eae998 100644
--- a/packages/agent-core-v2/src/os/interface/hostFileSystem.ts
+++ b/packages/agent-core-v2/src/os/interface/hostFileSystem.ts
@@ -3,8 +3,10 @@
  *
  * Defines the `IHostFileSystem` used by the program side (persistence, skill
  * loading, workspace registry) and the os file tools to read and write files on
- * the real local disk, plus the stat/entry models. App-scoped — one shared
- * instance.
+ * the real local disk, plus the stat/entry models. `realpath` canonicalizes a
+ * path by resolving every symlink component (Node `fs.realpath` semantics) and
+ * rejects with `os.fs.not_found` for a missing path; consumers use it to make
+ * lexical path confinement symlink-aware. App-scoped — one shared instance.
  */
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
@@ -46,6 +48,7 @@ export interface IHostFileSystem {
   readdir(path: string): Promise<readonly HostDirEntry[]>;
   mkdir(path: string, options?: { readonly recursive?: boolean }): Promise<void>;
   remove(path: string): Promise<void>;
+  realpath(path: string): Promise<string>;
 }
 
 export const IHostFileSystem: ServiceIdentifier<IHostFileSystem> =
diff --git a/packages/agent-core-v2/src/os/interface/terminal.ts b/packages/agent-core-v2/src/os/interface/terminal.ts
index c17de551f..c3da910d3 100644
--- a/packages/agent-core-v2/src/os/interface/terminal.ts
+++ b/packages/agent-core-v2/src/os/interface/terminal.ts
@@ -8,24 +8,74 @@
  * (`ISessionTerminalService`) lives in `src/session/terminal` and is the
  * surface most business code and the edge consume.
  *
- * Wire types (`Terminal`, `CreateTerminalRequest`, frame messages) are sourced
- * from `@moonshot-ai/protocol`.
+ * Wire types (`Terminal`, `CreateTerminalRequest`, frame messages) are defined
+ * here — the terminal REST schemas as zod, the attach-frame messages as plain
+ * types.
  */
 
-import type {
-  CreateTerminalRequest,
-  Terminal,
-  TerminalExitMessage,
-  TerminalOutputMessage,
-} from '@moonshot-ai/protocol';
+import { z } from 'zod';
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 import type { Event } from '#/_base/event';
+import { isoDateTimeSchema } from '#/_base/utils/isoDateTime';
 
-export type { CreateTerminalRequest, Terminal, TerminalExitMessage, TerminalOutputMessage };
+const relativeCwdSchema = z
+  .string()
+  .min(1)
+  .refine((value) => !isAbsolutePath(value), 'cwd must be relative to the session workspace');
+
+export const terminalStatusSchema = z.enum(['running', 'exited']);
+export type TerminalStatus = z.infer<typeof terminalStatusSchema>;
+
+export const terminalSchema = z.object({
+  id: z.string().min(1),
+  session_id: z.string().min(1),
+  cwd: z.string().min(1),
+  shell: z.string().min(1),
+  cols: z.number().int().positive(),
+  rows: z.number().int().positive(),
+  status: terminalStatusSchema,
+  created_at: isoDateTimeSchema,
+  exited_at: isoDateTimeSchema.optional(),
+  exit_code: z.number().int().nullable().optional(),
+});
+export type Terminal = z.infer<typeof terminalSchema>;
+
+export const createTerminalRequestSchema = z.object({
+  cwd: relativeCwdSchema.optional(),
+  shell: z.string().min(1).optional(),
+  cols: z.number().int().positive().optional(),
+  rows: z.number().int().positive().optional(),
+});
+export type CreateTerminalRequest = z.infer<typeof createTerminalRequestSchema>;
+
+export interface TerminalOutputMessage {
+  type: 'terminal_output';
+  seq: number;
+  session_id: string;
+  terminal_id: string;
+  timestamp: string;
+  payload: { data: string };
+}
+
+export interface TerminalExitMessage {
+  type: 'terminal_exit';
+  session_id: string;
+  terminal_id: string;
+  timestamp: string;
+  payload: { exit_code?: number | null | undefined };
+}
 
 export type TerminalFrame = TerminalOutputMessage | TerminalExitMessage;
 
+function isAbsolutePath(value: string): boolean {
+  return (
+    value.startsWith('/') ||
+    value.startsWith('\\') ||
+    /^[A-Za-z]:[\\/]/.test(value)
+  );
+}
+
 export interface TerminalAttachSink {
   readonly id: string;
   send(frame: TerminalFrame): void;
diff --git a/packages/agent-core-v2/src/persistence/backends/node-fs/fileStorageService.ts b/packages/agent-core-v2/src/persistence/backends/node-fs/fileStorageService.ts
index e5dbf0d8a..4bb02fcbf 100644
--- a/packages/agent-core-v2/src/persistence/backends/node-fs/fileStorageService.ts
+++ b/packages/agent-core-v2/src/persistence/backends/node-fs/fileStorageService.ts
@@ -17,7 +17,7 @@
  * It uses raw `node:fs` rather than `kaos`: the storage kernel needs direct
  * control over append offsets, fsync, atomic rename and streaming, which the
  * agent-execution-environment abstraction does not expose. Higher-level code
- * (`wireRecord`, `blobStore`) goes through the Store / Storage interfaces above
+ * (wire journal, blob store) goes through the Store / Storage interfaces above
  * this backend, never `node:fs` directly.
  */
 
diff --git a/packages/agent-core-v2/src/session/agentLifecycle/agentLifecycleService.ts b/packages/agent-core-v2/src/session/agentLifecycle/agentLifecycleService.ts
index e8288ee58..24cf4fdea 100644
--- a/packages/agent-core-v2/src/session/agentLifecycle/agentLifecycleService.ts
+++ b/packages/agent-core-v2/src/session/agentLifecycle/agentLifecycleService.ts
@@ -7,10 +7,8 @@
  * per-agent wire records and the wire state machine, the blob store, and MCP,
  * and registers the agent in the session registry. New logs receive a metadata
  * envelope while non-empty unversioned logs are rejected. Removal awaits the
- * agent task manager's graceful exit policy, then drains the agent's activity
- * kernel and flushes pending wire-log appends through `wire` before releasing
- * the child scope, so the last records of a turn survive a process exit that
- * follows disposal. Bound at Session scope.
+ * agent task manager's graceful exit policy before draining turns and full
+ * compaction, then disposing the child scope. Bound at Session scope.
  *
  * No agent id is special here: the main agent is simply the agent created
  * with the conventional `MAIN_AGENT_ID`, and `fork` requires its source to
@@ -25,7 +23,6 @@ import { InstantiationType } from '#/_base/di/extensions';
 import { IInstantiationService } from '#/_base/di/instantiation';
 import { Disposable, type IDisposable } from '#/_base/di/lifecycle';
 import { Emitter } from '#/_base/event';
-import { onUnexpectedError } from '#/_base/errors/unexpectedError';
 import {
   createScopedChildHandle,
   type IAgentScopeHandle,
@@ -35,32 +32,38 @@ import {
 import { IBootstrapService } from '#/app/bootstrap/bootstrap';
 import { IConfigService } from '#/app/config/config';
 import { IEventBus } from '#/app/event/eventBus';
-import { ErrorCodes, Error2 } from '#/errors';
 import { DEFAULT_PERMISSION_MODE_SECTION } from '#/agent/permissionMode/configSection';
+import { PermissionModeConfiguredModel } from '#/agent/permissionMode/permissionModeOps';
 import type { PermissionMode } from '#/agent/permissionPolicy/types';
-import { IAgentWireService } from '#/wire/tokens';
 import { IAgentToolDedupeService } from '#/agent/toolDedupe/toolDedupe';
 import { IAgentTaskService } from '#/agent/task/task';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import { ISessionMetadata } from '#/session/sessionMetadata/sessionMetadata';
 import { ISessionMcpService } from '#/session/mcp/sessionMcp';
 import { IAgentScopeContext, makeAgentScopeContext } from '#/agent/scopeContext/scopeContext';
-import { IAgentActivityService, ISessionActivityKernel } from '#/activity/activity';
+import { IAgentLoopService } from '#/agent/loop/loop';
+import { IAgentActivityView } from '#/agent/activityView/activityView';
 import { IAgentProfileService } from '#/agent/profile/profile';
+import { abortError } from '#/_base/utils/abort';
 import { IAgentLoopContinuationService } from '#/agent/loop/loopContinuation';
 import { IAgentStepRetryService } from '#/agent/stepRetry/stepRetry';
 import { IAgentToolSelectService } from '#/agent/toolSelect/toolSelect';
 import { IAgentToolSelectAnnouncementsService } from '#/agent/toolSelect/toolSelectAnnouncements';
 import { IAgentPermissionModeService } from '#/agent/permissionMode/permissionMode';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
+import { IAgentContextInjectorService } from '#/agent/contextInjector/contextInjector';
+import { IAgentFullCompactionService } from '#/agent/fullCompaction/fullCompaction';
+import { IAgentGoalService } from '#/agent/goal/goal';
+import { IAgentPlanService } from '#/agent/plan/plan';
+import { IAgentUserToolService } from '#/agent/userTool/userTool';
 import { IAgentBuiltinToolsRegistrar } from '#/agent/toolRegistry/builtinToolsRegistrar';
 import { IAgentMediaToolsRegistrar } from '#/agent/media/mediaTools';
 import { IImageConfigBridge } from '#/agent/media/imageConfigBridge';
 import { IAgentMcpService } from '#/agent/mcp/mcp';
 import { IAgentExternalHooksService } from '#/agent/externalHooks/externalHooks';
-import { IAgentReplayService } from '#/agent/replayBuilder/agentReplayService';
 import { IAgentPluginService } from '#/agent/plugin/agentPlugin';
 import { ISessionInteractionService } from '#/session/interaction/interaction';
+import { IWireService } from '#/wire/wire';
 import {
   type AgentListFilter,
   type CreateAgentOptions,
@@ -95,7 +98,6 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
     @IBootstrapService private readonly bootstrap: IBootstrapService,
     @IConfigService private readonly config: IConfigService,
     @ISessionMcpService private readonly sessionMcp: ISessionMcpService,
-    @ISessionActivityKernel private readonly activityKernel: ISessionActivityKernel,
     @ISessionInteractionService private readonly interaction: ISessionInteractionService,
   ) {
     super();
@@ -135,7 +137,6 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
       const existing = this.handles.get(opts.agentId);
       if (existing !== undefined) return existing;
     }
-    this.assertCanCreate();
     const agentId = opts.agentId ?? `agent-${nextAgentId++}`;
     const promise = this.doCreate(agentId, opts);
     this.creating.set(agentId, promise);
@@ -148,9 +149,6 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
 
   private async doCreate(agentId: string, opts: CreateAgentOptions): Promise<IAgentScopeHandle> {
     const mcpReady = this.sessionMcp.ensureMcpReady();
-    // Per-agent homedir → the wire-record persistence key (`hashKey(homedir)`).
-    // Bootstrap computes it under the session dir, mirroring v1's
-    // `<sessionDir>/agents/<id>`; business code never assembles the path itself.
     const agentHomedir = this.bootstrap.agentHomedir(
       this.ctx.workspaceId,
       this.ctx.sessionId,
@@ -167,12 +165,14 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
       agentId,
       // The only per-agent seed: identity facts. Every other agent-scope
       // service either derives its configuration from `IAgentScopeContext`
-      // (wire, wireRecord, blob) or resolves it through the scope tree (the
+      // (wire, blob) or resolves it through the scope tree (the
       // session's shared MCP manager via `ISessionMcpService`).
       { extra: [[IAgentScopeContext, makeAgentScopeContext({ agentId, agentScope })]] },
     ) as IAgentScopeHandle;
     this.handles.set(agentId, handle);
     try {
+      const wire = handle.accessor.get(IWireService);
+      await wire.seal();
       await this.sessionMetadata.registerAgent(agentId, {
         homedir: agentHomedir,
         type: agentId === 'main' ? 'main' : 'sub',
@@ -183,15 +183,8 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
       this.onDidCreateEmitter.fire(handle);
       this.igniteEagerServices(handle);
       await mcpReady;
+      await wire.restore();
       await this.bindBootstrap(handle, opts);
-      // Bootstrap (profile binding and the force-instantiated observer
-      // services) is complete: drive the activity kernel `initializing → idle`
-      // so the agent can admit turns. Until this point `begin` rejects with
-      // `activity.initializing`. The wire log's metadata envelope is NOT
-      // seeded here — `wireRecord.restore()` heals envelope-less logs on
-      // resume (prepend + rewrite), so creation stays free of log-format
-      // concerns.
-      handle.accessor.get(IAgentActivityService).markReady();
       return handle;
     } catch (error) {
       // Startup failed: drop the half-built agent so the next `create` starts
@@ -205,16 +198,6 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
     }
   }
 
-  private assertCanCreate(): void {
-    if (!this.activityKernel.canAccept('agent.create')) {
-      throw new Error2(
-        ErrorCodes.ACTIVITY_SESSION_REJECTED,
-        `Session is ${this.activityKernel.lane()}; agent creation rejected`,
-        { details: { lane: this.activityKernel.lane() } },
-      );
-    }
-  }
-
   // Force-instantiate the agent-scope observer/registrar services before the
   // first turn: each exists only for its constructor side effects (registering
   // built-in tools, subscribing hooks), so nothing injects them directly.
@@ -238,12 +221,17 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
     handle.accessor.get(IAgentToolSelectAnnouncementsService);
     handle.accessor.get(IAgentStepRetryService);
     handle.accessor.get(IAgentLoopContinuationService);
-    // Replay service: attaches the `ReplayTimelineModel` derived model before
-    // session resume replays this agent's wire log — derived models only fold
-    // ops that pass through after attach, so a late attach would leave resumed
-    // sessions with an empty replay timeline and the TUI could not rehydrate
-    // screen history.
-    handle.accessor.get(IAgentReplayService);
+    handle.accessor.get(IAgentContextMemoryService);
+    handle.accessor.get(IAgentContextInjectorService);
+    handle.accessor.get(IAgentGoalService);
+    handle.accessor.get(IAgentPlanService);
+    handle.accessor.get(IAgentTaskService);
+    handle.accessor.get(IAgentUserToolService);
+    handle.accessor.get(IAgentFullCompactionService);
+    // The activity view publishes `agent.activity.updated` from its constructor
+    // subscriptions; without an explicit resolve nothing injects it and the
+    // wire would never see the projection.
+    handle.accessor.get(IAgentActivityView);
   }
 
   private async bindBootstrap(
@@ -253,12 +241,14 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
     if (opts.binding !== undefined) {
       await handle.accessor.get(IAgentProfileService).bind(opts.binding);
     }
-    // Every fresh agent starts from the configured default permission posture;
-    // dispatchers that want a specific mode (subagent inheritance) set it on
-    // the child themselves after creation. On resume the wire replay
-    // overwrites this with the persisted mode.
+    // Apply the configured default only when restore found no persisted mode.
+    // A resumed Agent's journal owns its permission posture; callers that need
+    // an explicit override (for example subagent inheritance) do so after
+    // creation through the permission service.
+    const wire = handle.accessor.get(IWireService);
     const permissionMode = this.config.get<PermissionMode>(DEFAULT_PERMISSION_MODE_SECTION);
-    if (permissionMode !== undefined) {
+    const hasRestoredPermissionMode = wire.getModel(PermissionModeConfiguredModel);
+    if (permissionMode !== undefined && !hasRestoredPermissionMode) {
       handle.accessor.get(IAgentPermissionModeService).setMode(permissionMode);
     }
   }
@@ -314,14 +304,18 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
     if (handle === undefined) return;
     this.handles.delete(agentId);
     await handle.accessor.get(IAgentTaskService).stopAllOnExit('Session closed');
-    const activity = handle.accessor.get(IAgentActivityService);
-    activity.beginDisposal();
-    await activity.settled();
-    try {
-      await handle.accessor.get(IAgentWireService).flush();
-    } catch (error) {
-      onUnexpectedError(error);
+    const loop = handle.accessor.get(IAgentLoopService);
+    const compaction = handle.accessor.get(IAgentFullCompactionService).compacting;
+    const compactionSettled = compaction?.promise.catch(() => undefined) ?? Promise.resolve();
+    const reason = abortError('Agent removed');
+    for (const turnId of loop.status().pendingTurnIds) {
+      loop.cancel(turnId, reason);
     }
+    loop.cancel(undefined, reason);
+    if (compaction !== null && !compaction.abortController.signal.aborted) {
+      compaction.abortController.abort(reason);
+    }
+    await Promise.all([loop.settled(), compactionSettled]);
     handle.dispose();
     this.onDidDisposeEmitter.fire(agentId);
   }
diff --git a/packages/agent-core-v2/src/session/approval/approval.ts b/packages/agent-core-v2/src/session/approval/approval.ts
index 6bd2ee2f0..4f323265d 100644
--- a/packages/agent-core-v2/src/session/approval/approval.ts
+++ b/packages/agent-core-v2/src/session/approval/approval.ts
@@ -8,7 +8,7 @@
  */
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 
 export interface ApprovalRequest {
   readonly id?: string;
diff --git a/packages/agent-core-v2/src/session/cron/cronOps.ts b/packages/agent-core-v2/src/session/cron/cronOps.ts
index 9936798ff..271b6b8e0 100644
--- a/packages/agent-core-v2/src/session/cron/cronOps.ts
+++ b/packages/agent-core-v2/src/session/cron/cronOps.ts
@@ -17,7 +17,7 @@
  * `OP_REGISTRY` at import time.
  */
 
-import type { CronJobOrigin } from '@moonshot-ai/protocol';
+import type { CronJobOrigin } from '#/agent/contextMemory/types';
 import { z } from 'zod';
 
 import { defineModel } from '#/wire/model';
diff --git a/packages/agent-core-v2/src/session/cron/sessionCronServiceImpl.ts b/packages/agent-core-v2/src/session/cron/sessionCronServiceImpl.ts
index bfedd6ea0..1bde48af2 100644
--- a/packages/agent-core-v2/src/session/cron/sessionCronServiceImpl.ts
+++ b/packages/agent-core-v2/src/session/cron/sessionCronServiceImpl.ts
@@ -6,7 +6,7 @@
  * (tick / coalesce / jitter / cursor), persists mutations through the
  * App-scoped `ICronTaskPersistence`, mirrors mutations as `cron.add` /
  * `cron.delete` / `cron.cursor` Ops on the main agent's `wire` (cross-scope
- * borrow) so `wire.replay` can rebuild the `CronModel`, publishes `cron.fired`
+ * borrow) so wire restore can rebuild the `CronModel`, publishes `cron.fired`
  * to the main agent's `IEventBus`, steers the main agent
  * through `IAgentPromptService` when a task fires, and registers the cron
  * tools (`CronCreate` / `CronList` / `CronDelete`) into the main agent's
@@ -17,7 +17,7 @@
 import { ulid } from 'ulid';
 
 import type { ContentPart } from '#/app/llmProtocol/message';
-import type { CronJobOrigin, CronMissedOrigin } from '@moonshot-ai/protocol';
+import type { CronJobOrigin, CronMissedOrigin } from '#/agent/contextMemory/types';
 
 import { Disposable, toDisposable } from '#/_base/di/lifecycle';
 import { InstantiationType } from '#/_base/di/extensions';
@@ -39,7 +39,7 @@ import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle'
 import type { ContextMessage } from '#/agent/contextMemory/types';
 import { IAgentPromptService } from '#/agent/prompt/prompt';
 import type { Op } from '#/wire/op';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentLoopService, type Turn } from '#/agent/loop/loop';
@@ -91,13 +91,13 @@ export class SessionCronServiceImpl extends Disposable implements ISessionCronSe
     this._register(
       this.agentLifecycle.onDidCreate((handle) => {
         if (handle.id !== 'main') return;
-        void this.bindMainAgent(handle);
+        this.bindMainAgent(handle);
       }),
     );
 
     const existingMain = this.agentLifecycle.get('main');
     if (existingMain) {
-      void this.bindMainAgent(existingMain);
+      this.bindMainAgent(existingMain);
     }
 
     this._register(
@@ -107,24 +107,23 @@ export class SessionCronServiceImpl extends Disposable implements ISessionCronSe
     );
   }
 
-  private async bindMainAgent(handle: IAgentScopeHandle): Promise<void> {
-    await this.config.ready;
-    this.resolveClocks();
-    const wire = handle.accessor.get(IAgentWireService);
+  private bindMainAgent(handle: IAgentScopeHandle): void {
+    const wire = handle.accessor.get(IWireService);
     this._register(
-      wire.onRestored(() => {
+      wire.hooks.onDidRestore.register('cron', async (_ctx, next) => {
+        await this.config.ready;
+        this.resolveClocks();
         this.tasks.clear();
         for (const [id, task] of wire.getModel(CronModel)) {
           this.tasks.set(id, task as CronTask);
         }
-        void this.loadFromStore({ replace: false }).then(() => this.start());
+        await this.loadFromStore({ replace: false });
+        await this.start();
+        await next();
       }),
     );
 
     this.registerCronTools(handle);
-
-    await this.loadFromStore();
-    await this.start();
   }
 
   private registerCronTools(handle: IAgentScopeHandle): void {
@@ -485,7 +484,7 @@ export class SessionCronServiceImpl extends Disposable implements ISessionCronSe
   private dispatchCron(op: Op): void {
     const mainHandle = this.agentLifecycle.get('main');
     if (!mainHandle) return;
-    mainHandle.accessor.get(IAgentWireService).dispatch(op);
+    mainHandle.accessor.get(IWireService).dispatch(op);
   }
 
   private signalCron(event: DomainEvent): void {
diff --git a/packages/agent-core-v2/src/session/cron/tools/cron-create.ts b/packages/agent-core-v2/src/session/cron/tools/cron-create.ts
index b4fb6b998..61546c970 100644
--- a/packages/agent-core-v2/src/session/cron/tools/cron-create.ts
+++ b/packages/agent-core-v2/src/session/cron/tools/cron-create.ts
@@ -201,7 +201,6 @@ export class CronCreateTool implements BuiltinTool<CronCreateInput> {
         return {
           output: formatOutput(output),
           isError: false,
-          message: `Scheduled cron ${task.id}`,
         };
       },
     };
diff --git a/packages/agent-core-v2/src/session/sessionActivity/sessionActivity.ts b/packages/agent-core-v2/src/session/sessionActivity/sessionActivity.ts
deleted file mode 100644
index ac80e2d10..000000000
--- a/packages/agent-core-v2/src/session/sessionActivity/sessionActivity.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * `sessionActivity` domain (L6) — session-level activity and status.
- *
- * Defines the public contract of session activity: the `SessionStatus` model
- * and the `ISessionActivity` used to query the session's derived lifecycle
- * phase (`status`) and whether it is idle (`isIdle`). Session-scoped — one
- * instance per session. The status is derived from the session's pending
- * interactions and each agent's active turn; it owns no state.
- */
-
-import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-
-export type SessionStatus = 'running' | 'idle' | 'awaiting_approval' | 'awaiting_question';
-
-export interface ISessionActivity {
-  readonly _serviceBrand: undefined;
-
-  status(): SessionStatus;
-  isIdle(): boolean;
-}
-
-export const ISessionActivity: ServiceIdentifier<ISessionActivity> =
-  createDecorator<ISessionActivity>('sessionActivity');
diff --git a/packages/agent-core-v2/src/session/sessionActivity/sessionActivityService.ts b/packages/agent-core-v2/src/session/sessionActivity/sessionActivityService.ts
deleted file mode 100644
index 992e645e0..000000000
--- a/packages/agent-core-v2/src/session/sessionActivity/sessionActivityService.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * `sessionActivity` domain (L6) — `ISessionActivity` implementation.
- *
- * Derives the session's lifecycle phase from the pending interactions held by
- * the `interaction` kernel (awaiting approval / question) and each agent's
- * active turn (`loop`, reached through `agentLifecycle` handles). Bound at
- * Session scope.
- */
-
-import { InstantiationType } from '#/_base/di/extensions';
-import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
-import { ISessionInteractionService } from '#/session/interaction/interaction';
-import { IAgentLoopService } from '#/agent/loop/loop';
-
-import { ISessionActivity, type SessionStatus } from './sessionActivity';
-
-export class SessionActivity implements ISessionActivity {
-  declare readonly _serviceBrand: undefined;
-
-  constructor(
-    @IAgentLifecycleService private readonly agents: IAgentLifecycleService,
-    @ISessionInteractionService private readonly interaction: ISessionInteractionService,
-  ) {}
-
-  status(): SessionStatus {
-    if (this.interaction.listPending('approval').length > 0) return 'awaiting_approval';
-    if (this.interaction.listPending('question').length > 0) return 'awaiting_question';
-    if (this.hasActiveTurn()) return 'running';
-    return 'idle';
-  }
-
-  isIdle(): boolean {
-    return this.status() === 'idle';
-  }
-
-  private hasActiveTurn(): boolean {
-    for (const handle of this.agents.list()) {
-      const loop = handle.accessor.get(IAgentLoopService);
-      if (loop.status().state === 'running') return true;
-    }
-    return false;
-  }
-}
-
-registerScopedService(LifecycleScope.Session, ISessionActivity, SessionActivity, InstantiationType.Eager, 'sessionActivity');
diff --git a/packages/agent-core-v2/src/session/sessionFs/fs.ts b/packages/agent-core-v2/src/session/sessionFs/fs.ts
index fb6822461..f19320310 100644
--- a/packages/agent-core-v2/src/session/sessionFs/fs.ts
+++ b/packages/agent-core-v2/src/session/sessionFs/fs.ts
@@ -2,36 +2,219 @@
  * `sessionFs` domain (L2) — wire-shaped filesystem operations.
  *
  * Defines the `ISessionFsService` that backs the fs REST surface: content search,
- * content grep, and git status/diff. It orchestrates the os `IHostFileSystem`
+ * content grep, and git status/diff, together with the zod DTO schemas the
+ * transports validate against. It orchestrates the os `IHostFileSystem`
  * (file IO, resolved against the workspace root) plus `ISessionProcessRunner`
- * (for `rg` / `git` / `gh`) and returns protocol-shaped responses.
+ * (for `rg` / `git` / `gh`). Git status/diff DTOs live in the `git` domain.
  * Session-scoped — the scope itself is the session, so no `sessionId` is
  * threaded through.
  */
 
+import { z } from 'zod';
+
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-import type {
-  FsDiffRequest,
-  FsDiffResponse,
-  FsGitStatusRequest,
-  FsGitStatusResponse,
-  FsGrepRequest,
-  FsGrepResponse,
-  FsListManyRequest,
-  FsListManyResponse,
-  FsListRequest,
-  FsListResponse,
-  FsMkdirRequest,
-  FsMkdirResponse,
-  FsReadRequest,
-  FsReadResponse,
-  FsSearchRequest,
-  FsSearchResponse,
-  FsStatManyRequest,
-  FsStatManyResponse,
-  FsStatRequest,
-  FsStatResponse,
-} from '@moonshot-ai/protocol';
+import { isoDateTimeSchema } from '#/_base/utils/isoDateTime';
+import {
+  fsGitStatusSchema,
+  type FsDiffRequest,
+  type FsDiffResponse,
+  type FsGitStatusRequest,
+  type FsGitStatusResponse,
+} from '#/app/git/git';
+
+export {
+  fsDiffRequestSchema,
+  fsDiffResponseSchema,
+  fsGitStatusRequestSchema,
+  fsGitStatusResponseSchema,
+} from '#/app/git/git';
+export type { FsDiffRequest, FsDiffResponse, FsGitStatusRequest, FsGitStatusResponse };
+
+export const fsKindSchema = z.enum(['file', 'directory', 'symlink']);
+export type FsKind = z.infer<typeof fsKindSchema>;
+
+export const fsEntrySchema = z.object({
+  path: z.string(),
+  name: z.string(),
+  kind: fsKindSchema,
+  size: z.number().int().nonnegative().optional(),
+  modified_at: isoDateTimeSchema,
+  etag: z.string().optional(),
+  mime: z.string().optional(),
+  language_id: z.string().optional(),
+  is_binary: z.boolean().optional(),
+  is_symlink_to: z.string().optional(),
+  git_status: fsGitStatusSchema.optional(),
+  child_count: z.number().int().nonnegative().optional(),
+});
+export type FsEntry = z.infer<typeof fsEntrySchema>;
+
+export const fsSearchHitSchema = z.object({
+  path: z.string(),
+  name: z.string(),
+  kind: fsKindSchema,
+  score: z.number().min(0).max(1),
+  match_positions: z.array(z.number().int().nonnegative()),
+});
+export type FsSearchHit = z.infer<typeof fsSearchHitSchema>;
+
+export const fsGrepMatchSchema = z.object({
+  line: z.number().int().positive(),
+  col: z.number().int().positive(),
+  text: z.string(),
+  before: z.array(z.string()),
+  after: z.array(z.string()),
+});
+export type FsGrepMatch = z.infer<typeof fsGrepMatchSchema>;
+
+export const fsGrepFileHitSchema = z.object({
+  path: z.string(),
+  matches: z.array(fsGrepMatchSchema),
+});
+export type FsGrepFileHit = z.infer<typeof fsGrepFileHitSchema>;
+
+export const fsListSortSchema = z.enum([
+  'type_first',
+  'name_asc',
+  'name_desc',
+  'mtime_desc',
+  'size_desc',
+]);
+export type FsListSort = z.infer<typeof fsListSortSchema>;
+
+export const fsListRequestSchema = z.object({
+  path: z.string().default('.'),
+  depth: z.number().int().min(1).max(10).default(1),
+  limit: z.number().int().min(1).max(1000).default(200),
+  show_hidden: z.boolean().default(false),
+  follow_gitignore: z.boolean().default(true),
+  exclude_globs: z.array(z.string()).optional(),
+  sort: fsListSortSchema.default('type_first'),
+  include_git_status: z.boolean().default(false),
+});
+export type FsListRequest = z.infer<typeof fsListRequestSchema>;
+
+export const fsListResponseSchema = z.object({
+  items: z.array(fsEntrySchema),
+  children_by_path: z.record(z.string(), z.array(fsEntrySchema)).optional(),
+  truncated: z.boolean(),
+});
+export type FsListResponse = z.infer<typeof fsListResponseSchema>;
+
+export const fsReadEncodingRequestSchema = z.enum(['auto', 'utf-8', 'base64']);
+export const fsReadEncodingResponseSchema = z.enum(['utf-8', 'base64']);
+export type FsReadEncoding = z.infer<typeof fsReadEncodingResponseSchema>;
+
+export const fsReadRequestSchema = z.object({
+  path: z.string().min(1),
+  offset: z.number().int().nonnegative().default(0),
+  length: z.number().int().min(1).max(10_485_760).default(1_048_576),
+  encoding: fsReadEncodingRequestSchema.default('auto'),
+});
+export type FsReadRequest = z.infer<typeof fsReadRequestSchema>;
+
+export const fsReadResponseSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+  encoding: fsReadEncodingResponseSchema,
+  size: z.number().int().nonnegative(),
+  truncated: z.boolean(),
+  etag: z.string(),
+  mime: z.string(),
+  language_id: z.string().optional(),
+  line_count: z.number().int().nonnegative().optional(),
+  is_binary: z.boolean(),
+});
+export type FsReadResponse = z.infer<typeof fsReadResponseSchema>;
+
+export const fsMkdirRequestSchema = z.object({
+  path: z.string().min(1),
+  recursive: z.boolean().default(false),
+});
+export type FsMkdirRequest = z.infer<typeof fsMkdirRequestSchema>;
+
+export const fsMkdirResponseSchema = fsEntrySchema;
+export type FsMkdirResponse = z.infer<typeof fsMkdirResponseSchema>;
+
+export const fsListManyRequestSchema = z.object({
+  paths: z.array(z.string().min(1)).min(1).max(100),
+  depth: z.number().int().min(1).max(10).default(1),
+  limit: z.number().int().min(1).max(1000).default(200),
+  show_hidden: z.boolean().default(false),
+  follow_gitignore: z.boolean().default(true),
+  exclude_globs: z.array(z.string()).optional(),
+  sort: fsListSortSchema.default('type_first'),
+  include_git_status: z.boolean().default(false),
+});
+export type FsListManyRequest = z.infer<typeof fsListManyRequestSchema>;
+
+export const fsListManyPartialErrorSchema = z.object({
+  code: z.number().int(),
+  msg: z.string(),
+});
+export type FsListManyPartialError = z.infer<typeof fsListManyPartialErrorSchema>;
+
+export const fsListManyResponseSchema = z.object({
+  results: z.record(z.string(), z.array(fsEntrySchema)),
+  truncated_paths: z.array(z.string()).optional(),
+  partial_errors: z.record(z.string(), fsListManyPartialErrorSchema).optional(),
+});
+export type FsListManyResponse = z.infer<typeof fsListManyResponseSchema>;
+
+export const fsStatRequestSchema = z.object({
+  path: z.string().min(1),
+});
+export type FsStatRequest = z.infer<typeof fsStatRequestSchema>;
+
+export const fsStatResponseSchema = fsEntrySchema;
+export type FsStatResponse = z.infer<typeof fsStatResponseSchema>;
+
+export const fsStatManyRequestSchema = z.object({
+  paths: z.array(z.string().min(1)).min(1).max(1000),
+});
+export type FsStatManyRequest = z.infer<typeof fsStatManyRequestSchema>;
+
+export const fsStatManyResponseSchema = z.object({
+  entries: z.record(z.string(), fsEntrySchema.nullable()),
+});
+export type FsStatManyResponse = z.infer<typeof fsStatManyResponseSchema>;
+
+export const fsSearchRequestSchema = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).default(50),
+  include_globs: z.array(z.string()).optional(),
+  exclude_globs: z.array(z.string()).optional(),
+  follow_gitignore: z.boolean().default(true),
+});
+export type FsSearchRequest = z.infer<typeof fsSearchRequestSchema>;
+
+export const fsSearchResponseSchema = z.object({
+  items: z.array(fsSearchHitSchema),
+  truncated: z.boolean(),
+});
+export type FsSearchResponse = z.infer<typeof fsSearchResponseSchema>;
+
+export const fsGrepRequestSchema = z.object({
+  pattern: z.string().min(1),
+  regex: z.boolean().default(false),
+  case_sensitive: z.boolean().default(true),
+  include_globs: z.array(z.string()).optional(),
+  exclude_globs: z.array(z.string()).optional(),
+  follow_gitignore: z.boolean().default(true),
+  max_files: z.number().int().min(1).max(10_000).default(200),
+  max_matches_per_file: z.number().int().min(1).max(10_000).default(50),
+  max_total_matches: z.number().int().min(1).max(100_000).default(5000),
+  context_lines: z.number().int().min(0).max(10).default(2),
+});
+export type FsGrepRequest = z.infer<typeof fsGrepRequestSchema>;
+
+export const fsGrepResponseSchema = z.object({
+  files: z.array(fsGrepFileHitSchema),
+  files_scanned: z.number().int().nonnegative(),
+  truncated: z.boolean(),
+  elapsed_ms: z.number().int().nonnegative(),
+});
+export type FsGrepResponse = z.infer<typeof fsGrepResponseSchema>;
 
 export interface FsPathResolved {
   readonly absolute: string;
diff --git a/packages/agent-core-v2/src/session/sessionFs/fsSearch.ts b/packages/agent-core-v2/src/session/sessionFs/fsSearch.ts
index efd2f37fd..0c4ed321f 100644
--- a/packages/agent-core-v2/src/session/sessionFs/fsSearch.ts
+++ b/packages/agent-core-v2/src/session/sessionFs/fsSearch.ts
@@ -6,7 +6,7 @@
  * be unit-tested directly. Ported from v1 `services/fs/fsSearchService.ts`.
  */
 
-import type { FsGrepRequest } from '@moonshot-ai/protocol';
+import type { FsGrepRequest } from './fs';
 
 export function computeFuzzyScore(name: string, queryLower: string): number {
   if (queryLower.length === 0) return 0;
diff --git a/packages/agent-core-v2/src/session/sessionFs/fsService.ts b/packages/agent-core-v2/src/session/sessionFs/fsService.ts
index 8eecf00dc..cf4349d3f 100644
--- a/packages/agent-core-v2/src/session/sessionFs/fsService.ts
+++ b/packages/agent-core-v2/src/session/sessionFs/fsService.ts
@@ -9,14 +9,15 @@
  * `IGitService`; this service only confines paths and computes repo-relative
  * paths before calling it.
  *
- * Path confinement is lexical (`ISessionWorkspaceContext.isWithin`); it does not
- * follow symlinks, matching the rest of v2 (`_base/tools/policies/path-access.ts`).
+ * Path confinement applies the lexical `ISessionWorkspaceContext.isWithin`
+ * check first, then re-verifies the candidate through `IHostFileSystem.realpath`
+ * (resolving the longest existing prefix, so not-yet-created paths still work):
+ * a symlink inside the workspace must not steer fs actions to files outside it.
  */
 
-import { basename, extname, isAbsolute, join, relative, sep } from 'node:path';
+import { basename, dirname, extname, isAbsolute, join, relative, sep } from 'node:path';
 
 import {
-  ErrorCode,
   type FsDiffRequest,
   type FsDiffResponse,
   type FsEntry,
@@ -41,12 +42,27 @@ import {
   type FsStatManyResponse,
   type FsStatRequest,
   type FsStatResponse,
-} from '@moonshot-ai/protocol';
+} from './fs';
+
+/**
+ * The v1 numeric wire codes this edge surface throws inside its
+ * `{ code, msg }` wire errors (`toWireError`). Mirrors the envelope error
+ * table owned by the transport (kap-server); kept as local literals because
+ * they are part of this service's v1 edge contract.
+ */
+const FsWireErrorCode = {
+  FS_PATH_NOT_FOUND: 40409,
+  FS_IS_DIRECTORY: 40906,
+  FS_IS_BINARY: 40907,
+  FS_TOO_LARGE: 41302,
+  FS_TOO_MANY_RESULTS: 41303,
+  INTERNAL_ERROR: 50001,
+} as const;
 import ignore, { type Ignore } from 'ignore';
 
 import { InstantiationType } from '#/_base/di/extensions';
 import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
-import { ErrorCodes, Error2, unwrapErrorCause } from '#/errors';
+import { ErrorCodes, Error2, isError2, unwrapErrorCause } from '#/errors';
 import { IGitService } from '#/app/git/git';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { IHostFileSystem, type HostDirEntry, type HostFileStat } from '#/os/interface/hostFileSystem';
@@ -97,7 +113,7 @@ export class SessionFsService implements ISessionFsService {
   }
 
   async list(req: FsListRequest): Promise<FsListResponse> {
-    const abs = this.resolveWithin(req.path);
+    const abs = await this.resolveWithin(req.path);
     const rel = this.toRel(abs);
 
     let topStat: HostFileStat;
@@ -189,7 +205,7 @@ export class SessionFsService implements ISessionFsService {
   }
 
   async read(req: FsReadRequest): Promise<FsReadResponse> {
-    const abs = this.resolveWithin(req.path);
+    const abs = await this.resolveWithin(req.path);
     const rel = this.toRel(abs);
 
     let st: HostFileStat;
@@ -289,7 +305,7 @@ export class SessionFsService implements ISessionFsService {
   }
 
   async stat(req: FsStatRequest): Promise<FsStatResponse> {
-    const abs = this.resolveWithin(req.path);
+    const abs = await this.resolveWithin(req.path);
     const rel = this.toRel(abs);
     let st: HostFileStat;
     try {
@@ -302,10 +318,12 @@ export class SessionFsService implements ISessionFsService {
   }
 
   async statMany(req: FsStatManyRequest): Promise<FsStatManyResponse> {
-    const resolved = req.paths.map((p) => {
-      const abs = this.resolveWithin(p);
-      return { raw: p, rel: this.toRel(abs), abs };
-    });
+    const resolved = await Promise.all(
+      req.paths.map(async (p) => {
+        const abs = await this.resolveWithin(p);
+        return { raw: p, rel: this.toRel(abs), abs };
+      }),
+    );
 
     const entries: Record<string, FsEntry | null> = {};
     await Promise.all(
@@ -323,7 +341,7 @@ export class SessionFsService implements ISessionFsService {
   }
 
   async mkdir(req: FsMkdirRequest): Promise<FsMkdirResponse> {
-    const abs = this.resolveWithin(req.path);
+    const abs = await this.resolveWithin(req.path);
     const rel = this.toRel(abs);
     try {
       await this.hostFs.mkdir(abs, { recursive: req.recursive });
@@ -346,7 +364,7 @@ export class SessionFsService implements ISessionFsService {
   }
 
   async resolvePath(relPath: string): Promise<FsPathResolved> {
-    const abs = this.resolveWithin(relPath);
+    const abs = await this.resolveWithin(relPath);
     const rel = this.toRel(abs);
     let st: HostFileStat;
     try {
@@ -358,7 +376,7 @@ export class SessionFsService implements ISessionFsService {
   }
 
   async resolveDownload(relPath: string): Promise<FsDownloadResolved> {
-    const abs = this.resolveWithin(relPath);
+    const abs = await this.resolveWithin(relPath);
     const rel = this.toRel(abs);
     let st: HostFileStat;
     try {
@@ -442,7 +460,7 @@ export class SessionFsService implements ISessionFsService {
     if (req.paths !== undefined && req.paths.length > 0) {
       filter = new Set();
       for (const p of req.paths) {
-        filter.add(this.toRel(this.resolveWithin(p)));
+        filter.add(this.toRel(await this.resolveWithin(p)));
       }
     }
 
@@ -451,7 +469,7 @@ export class SessionFsService implements ISessionFsService {
 
   async diff(req: FsDiffRequest): Promise<FsDiffResponse> {
     const cwd = this.workspace.workDir;
-    const abs = this.resolveWithin(req.path);
+    const abs = await this.resolveWithin(req.path);
     return this.git.diff(cwd, this.toRel(abs), abs);
   }
 
@@ -669,7 +687,43 @@ export class SessionFsService implements ISessionFsService {
     return this.rgResolution;
   }
 
-  private resolveWithin(inputPath: string): string {
+  private realRootsCache: { readonly key: string; readonly roots: readonly string[] } | undefined;
+
+  private async realRoots(): Promise<readonly string[]> {
+    const dirs = [this.workspace.workDir, ...this.workspace.additionalDirs];
+    const key = dirs.join('\n');
+    if (this.realRootsCache?.key === key) return this.realRootsCache.roots;
+    const roots: string[] = [];
+    for (const dir of dirs) {
+      try {
+        roots.push(await this.hostFs.realpath(dir));
+      } catch {
+        roots.push(dir);
+      }
+    }
+    this.realRootsCache = { key, roots };
+    return roots;
+  }
+
+  private async realpathExistingPrefix(abs: string): Promise<string> {
+    const tail: string[] = [];
+    let current = abs;
+    for (let i = 0; i < 256; i++) {
+      try {
+        const real = await this.hostFs.realpath(current);
+        return tail.length === 0 ? real : join(real, ...tail.reverse());
+      } catch (err) {
+        if (!isMissingPathError(err)) throw err;
+        const parent = dirname(current);
+        if (parent === current) return abs;
+        tail.push(basename(current));
+        current = parent;
+      }
+    }
+    return abs;
+  }
+
+  private async resolveWithin(inputPath: string): Promise<string> {
     if (inputPath === '' || inputPath === '/') {
       throw new Error2(ErrorCodes.FS_PATH_ESCAPES, `path "${inputPath}" rejected (empty)`, {
         details: { path: inputPath, reason: 'empty' },
@@ -692,6 +746,15 @@ export class SessionFsService implements ISessionFsService {
         details: { path: inputPath, reason: 'resolved_outside' },
       });
     }
+    const resolved = await this.realpathExistingPrefix(abs);
+    const roots = await this.realRoots();
+    if (!roots.some((root) => isInsideOrEqual(resolved, root))) {
+      throw new Error2(
+        ErrorCodes.FS_PATH_ESCAPES,
+        `path "${inputPath}" escapes workspace through a symlink`,
+        { details: { path: inputPath, reason: 'symlink_outside' } },
+      );
+    }
     return abs;
   }
 
@@ -905,6 +968,24 @@ function errnoCode(err: unknown): string | undefined {
   return undefined;
 }
 
+function isMissingPathError(err: unknown): boolean {
+  if (isError2(err)) {
+    return (
+      err.code === ErrorCodes.OS_FS_NOT_FOUND || err.code === ErrorCodes.OS_FS_NOT_DIRECTORY
+    );
+  }
+  const code = errnoCode(err);
+  return code === 'ENOENT' || code === 'ENOTDIR';
+}
+
+function isInsideOrEqual(child: string, parent: string): boolean {
+  const rel = relative(parent, child);
+  if (rel === '') return true;
+  if (rel.startsWith('..')) return false;
+  if (isAbsolute(rel)) return false;
+  return true;
+}
+
 function mapFsError(err: unknown, inputPath: string): Error {
   const code = errnoCode(err);
   if (code === 'ENOENT' || code === 'ENOTDIR') {
@@ -919,19 +1000,19 @@ function toWireError(err: unknown): { code: number; msg: string } {
   if (err instanceof Error2) {
     switch (err.code) {
       case ErrorCodes.FS_PATH_NOT_FOUND:
-        return { code: ErrorCode.FS_PATH_NOT_FOUND, msg: err.message };
+        return { code: FsWireErrorCode.FS_PATH_NOT_FOUND, msg: err.message };
       case ErrorCodes.FS_IS_DIRECTORY:
-        return { code: ErrorCode.FS_IS_DIRECTORY, msg: err.message };
+        return { code: FsWireErrorCode.FS_IS_DIRECTORY, msg: err.message };
       case ErrorCodes.FS_IS_BINARY:
-        return { code: ErrorCode.FS_IS_BINARY, msg: err.message };
+        return { code: FsWireErrorCode.FS_IS_BINARY, msg: err.message };
       case ErrorCodes.FS_TOO_LARGE:
-        return { code: ErrorCode.FS_TOO_LARGE, msg: err.message };
+        return { code: FsWireErrorCode.FS_TOO_LARGE, msg: err.message };
       case ErrorCodes.FS_TOO_MANY_RESULTS:
-        return { code: ErrorCode.FS_TOO_MANY_RESULTS, msg: err.message };
+        return { code: FsWireErrorCode.FS_TOO_MANY_RESULTS, msg: err.message };
     }
   }
   return {
-    code: ErrorCode.INTERNAL_ERROR,
+    code: FsWireErrorCode.INTERNAL_ERROR,
     msg: err instanceof Error ? err.message : 'internal error',
   };
 }
diff --git a/packages/agent-core-v2/src/session/sessionFs/fsWatch.ts b/packages/agent-core-v2/src/session/sessionFs/fsWatch.ts
index 4b3c123c6..6e44c4778 100644
--- a/packages/agent-core-v2/src/session/sessionFs/fsWatch.ts
+++ b/packages/agent-core-v2/src/session/sessionFs/fsWatch.ts
@@ -11,7 +11,25 @@
 
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 import type { Event } from '#/_base/event';
-import type { FsChangeEvent } from '@moonshot-ai/protocol';
+
+export type FsChangeKind = 'file' | 'directory' | 'symlink';
+
+export type FsChangeAction = 'created' | 'modified' | 'deleted';
+
+export interface FsChangeEntry {
+  path: string;
+  change: FsChangeAction;
+  kind: FsChangeKind;
+  size_delta?: number | undefined;
+  etag?: string | undefined;
+}
+
+export interface FsChangeEvent {
+  changes: FsChangeEntry[];
+  coalesced_window_ms: number;
+  truncated?: boolean | undefined;
+  count?: number | undefined;
+}
 
 export interface ISessionFsWatchService {
   readonly _serviceBrand: undefined;
diff --git a/packages/agent-core-v2/src/session/sessionFs/fsWatchService.ts b/packages/agent-core-v2/src/session/sessionFs/fsWatchService.ts
index 50129c0eb..a440595bd 100644
--- a/packages/agent-core-v2/src/session/sessionFs/fsWatchService.ts
+++ b/packages/agent-core-v2/src/session/sessionFs/fsWatchService.ts
@@ -26,7 +26,7 @@ import {
   IHostFsWatchService,
 } from '#/os/interface/hostFsWatch';
 import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceContext';
-import type { FsChangeEntry, FsChangeEvent } from '@moonshot-ai/protocol';
+import type { FsChangeEntry, FsChangeEvent } from './fsWatch';
 
 import { ISessionFsWatchService } from './fsWatch';
 
diff --git a/packages/agent-core-v2/src/session/sessionInit/sessionInitService.ts b/packages/agent-core-v2/src/session/sessionInit/sessionInitService.ts
index 45c5dea05..a8eac5136 100644
--- a/packages/agent-core-v2/src/session/sessionInit/sessionInitService.ts
+++ b/packages/agent-core-v2/src/session/sessionInit/sessionInitService.ts
@@ -10,7 +10,7 @@
  * subagent finishes, reloads `AGENTS.md` through the `profile` context helper
  * (over the os `hostFs` + host home dir, with the `bootstrap` brand dir) and
  * appends an `init`-variant system reminder to the main agent via
- * `systemReminder`, then flushes the main agent's `wireRecord` log. Bound at
+ * `systemReminder`, then flushes the main agent's wire journal. Bound at
  * Session scope.
  *
  * Port of v1 `Session.generateAgentsMd()`. The main-agent lookup is a hard
@@ -31,7 +31,7 @@ import { IAgentProfileService } from '#/agent/profile/profile';
 import { loadAgentsMd } from '#/agent/profile/context';
 import { IAgentPermissionModeService } from '#/agent/permissionMode/permissionMode';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { IWireService } from '#/wire/wire';
 import { ErrorCodes, Error2 } from '#/errors';
 import { IAgentLifecycleService, MAIN_AGENT_ID } from '#/session/agentLifecycle/agentLifecycle';
 import { emitAgentRunSpawned, mirrorAgentRun } from '#/session/subagent/mirrorAgentRun';
@@ -117,7 +117,7 @@ export class SessionInitService implements ISessionInitService {
           kind: 'injection',
           variant: 'init',
         });
-      await main.accessor.get(IAgentWireRecordService).flush();
+      await main.accessor.get(IWireService).flush();
     } catch (error) {
       // User cancellations (Ctrl+C → cancelInit) must surface as aborts, not
       // as init failures — the TUI resets quietly on `isAbortError`.
diff --git a/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadata.ts b/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadata.ts
index fbaed0f29..28c14ad24 100644
--- a/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadata.ts
+++ b/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadata.ts
@@ -13,7 +13,9 @@ import type { Event } from '#/_base/event';
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 
 export interface AgentMeta {
-  readonly homedir: string;
+  /** Absolute standard path retained for older v1 readers. Current readers
+   * derive the agent directory from the session scope and ignore this field. */
+  readonly homedir?: string;
   readonly type?: 'main' | 'sub' | 'independent';
   readonly parentAgentId?: string | null;
   readonly forkedFrom?: string;
diff --git a/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadataService.ts b/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadataService.ts
index e05901c17..239abe87b 100644
--- a/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadataService.ts
+++ b/packages/agent-core-v2/src/session/sessionMetadata/sessionMetadataService.ts
@@ -4,8 +4,16 @@
  * Persists the session metadata document (`state.json`) through the `storage`
  * access-pattern store (`IAtomicDocumentStore`), rooted at the `metaScope`
  * namespace from `sessionContext`. Loads the existing document on
- * construction (creating it on first run), and logs through `log`. Bound at
- * Session scope.
+ * construction (creating it on first run), and logs through `log`. The
+ * document always carries the `agents` / `custom` maps that v1's
+ * `Session.resume()` reads unconditionally — seeded at creation, backfilled
+ * and persisted on load for documents written before the seeding existed
+ * (without touching `updatedAt`, so a format heal never reorders session
+ * listings) — keeping sessions on a shared `KIMI_CODE_HOME` resumable by
+ * released v1 builds. Re-registering an agent whose metadata is unchanged is
+ * a no-op (no write, no mirror, no event), so resuming a session — which
+ * re-registers its agents as they materialize — never bumps `updatedAt` and
+ * never reorders session listings. Bound at Session scope.
  *
  * Read-model mirroring (flag `persistence_minidb_readmodel`): after a metadata
  * update is persisted, the fresh summary is mirrored into the `IQueryStore`
@@ -94,6 +102,8 @@ export class SessionMetadata extends Disposable implements ISessionMetadata {
   async registerAgent(agentId: string, meta: AgentMeta): Promise<void> {
     return this.enqueueUpdate(async () => {
       await this.ready;
+      const existing = this.data.agents?.[agentId];
+      if (existing !== undefined && agentMetaEquals(existing, meta)) return;
       const agents = { ...this.data.agents, [agentId]: meta };
       await this.applyUpdate({ agents });
     });
@@ -131,6 +141,14 @@ export class SessionMetadata extends Disposable implements ISessionMetadata {
     const existing = await this.store.get<SessionMeta>(this.scope, META_KEY);
     if (existing !== undefined) {
       this.data = normalizeSessionMeta(existing, this.ctx.sessionId);
+      if (this.data.agents === undefined || this.data.custom === undefined) {
+        this.data = {
+          ...this.data,
+          agents: this.data.agents ?? {},
+          custom: this.data.custom ?? {},
+        };
+        await this.store.set(this.scope, META_KEY, this.data);
+      }
       return;
     }
     const now = Date.now();
@@ -141,12 +159,33 @@ export class SessionMetadata extends Disposable implements ISessionMetadata {
       createdAt: now,
       updatedAt: now,
       archived: false,
+      agents: {},
+      custom: {},
     };
     await this.store.set(this.scope, META_KEY, this.data);
     this.log.debug('session metadata created', { sessionId: this.ctx.sessionId });
   }
 }
 
+function agentMetaEquals(a: AgentMeta, b: AgentMeta): boolean {
+  return (
+    a.homedir === b.homedir &&
+    a.type === b.type &&
+    (a.parentAgentId ?? null) === (b.parentAgentId ?? null) &&
+    a.forkedFrom === b.forkedFrom &&
+    a.swarmItem === b.swarmItem &&
+    recordEquals(a.labels, b.labels)
+  );
+}
+
+function recordEquals(a: AgentMeta['labels'], b: AgentMeta['labels']): boolean {
+  const entriesA = Object.entries(a ?? {});
+  const entriesB = Object.entries(b ?? {});
+  return (
+    entriesA.length === entriesB.length && entriesA.every(([key, value]) => b?.[key] === value)
+  );
+}
+
 export function normalizeSessionMeta(raw: SessionMeta, sessionId: string): SessionMeta {
   const legacy = raw as unknown as {
     createdAt?: unknown;
diff --git a/packages/agent-core-v2/src/session/subagent/configSection.ts b/packages/agent-core-v2/src/session/subagent/configSection.ts
new file mode 100644
index 000000000..57aa44d28
--- /dev/null
+++ b/packages/agent-core-v2/src/session/subagent/configSection.ts
@@ -0,0 +1,79 @@
+/**
+ * `subagent` domain (L6) — subagent config-section schema, env binding, and
+ * timeout resolution.
+ *
+ * Owns the `[subagent]` configuration section (`timeout_ms` on disk) together
+ * with the `KIMI_SUBAGENT_TIMEOUT_MS` env override, mirroring v1's
+ * `resolveSubagentTimeoutMs` precedence (env > config.toml > 2h default). Both
+ * collaboration tools — `Agent` in this domain and `AgentSwarm` in the `swarm`
+ * domain — resolve their per-run timeout through `resolveSubagentTimeoutMs`,
+ * and render the timeout message with `formatSubagentTimeoutDescription`.
+ * Self-registered at module load via `registerConfigSection`, so the `config`
+ * domain never imports this domain's types.
+ */
+
+import { z } from 'zod';
+
+import { type EnvBindings, envBindings, type IConfigService } from '#/app/config/config';
+import { registerConfigSection } from '#/app/config/configSectionContributions';
+
+export const SUBAGENT_SECTION = 'subagent';
+
+export const SubagentConfigSchema = z.object({
+  /** Per-run subagent timeout in milliseconds; set a large value to effectively disable the cap. */
+  timeoutMs: z.number().int().min(1).optional(),
+});
+
+export type SubagentConfig = z.infer<typeof SubagentConfigSchema>;
+
+/** Default per-run subagent timeout: 2 hours, same as v1. */
+export const DEFAULT_SUBAGENT_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+
+export const SUBAGENT_TIMEOUT_ENV = 'KIMI_SUBAGENT_TIMEOUT_MS';
+
+/** Parse the env override; anything but a positive integer is ignored (v1 semantics). */
+function parseTimeoutMsEnv(raw: string): number | undefined {
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed >= 1 ? parsed : undefined;
+}
+
+export const subagentEnvBindings: EnvBindings<SubagentConfig> = envBindings(
+  SubagentConfigSchema,
+  {
+    timeoutMs: { env: SUBAGENT_TIMEOUT_ENV, parse: parseTimeoutMsEnv },
+  },
+);
+
+registerConfigSection(SUBAGENT_SECTION, SubagentConfigSchema, {
+  defaultValue: { timeoutMs: DEFAULT_SUBAGENT_TIMEOUT_MS },
+  env: subagentEnvBindings,
+});
+
+/**
+ * Resolve the effective per-run subagent timeout. Governs foreground and
+ * background subagents (and AgentSwarm) through the task manager's per-task
+ * timeout.
+ */
+export function resolveSubagentTimeoutMs(config: IConfigService): number {
+  return (
+    config.get<SubagentConfig | undefined>(SUBAGENT_SECTION)?.timeoutMs ??
+    DEFAULT_SUBAGENT_TIMEOUT_MS
+  );
+}
+
+/** Human-readable duration for the subagent timeout message. */
+export function formatSubagentTimeoutDescription(ms: number): string {
+  if (ms % (60 * 60 * 1000) === 0) {
+    const h = ms / (60 * 60 * 1000);
+    return `${h} hour${h === 1 ? '' : 's'}`;
+  }
+  if (ms % (60 * 1000) === 0) {
+    const m = ms / (60 * 1000);
+    return `${m} minute${m === 1 ? '' : 's'}`;
+  }
+  if (ms % 1000 === 0) {
+    const s = ms / 1000;
+    return `${s} second${s === 1 ? '' : 's'}`;
+  }
+  return `${ms} ms`;
+}
diff --git a/packages/agent-core-v2/src/session/subagent/mirrorAgentRun.ts b/packages/agent-core-v2/src/session/subagent/mirrorAgentRun.ts
index e38a35c51..1e1cdec24 100644
--- a/packages/agent-core-v2/src/session/subagent/mirrorAgentRun.ts
+++ b/packages/agent-core-v2/src/session/subagent/mirrorAgentRun.ts
@@ -27,18 +27,44 @@ import { IAgentContextSizeService } from '#/agent/contextSize/contextSize';
 import { isProviderRateLimitError } from '#/app/llmProtocol/errors';
 import { type TokenUsage } from '#/app/llmProtocol/usage';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
-import type {
-  SubagentCompletedEvent,
-  SubagentFailedEvent,
-  SubagentSpawnedEvent,
-  SubagentStartedEvent,
-} from '@moonshot-ai/protocol';
 import { IEventBus } from '#/app/event/eventBus';
 import { isAbortError } from '#/_base/utils/abort';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 
 import { type AgentRunHandle, ISessionSubagentService } from './subagent';
 
+export interface SubagentSpawnedEvent {
+  readonly type: 'subagent.spawned';
+  readonly subagentId: string;
+  readonly subagentName: string;
+  readonly parentToolCallId: string;
+  readonly parentToolCallUuid?: string;
+  readonly parentAgentId?: string;
+  readonly callerAgentId?: string;
+  readonly description?: string;
+  readonly swarmIndex?: number;
+  readonly runInBackground: boolean;
+}
+
+export interface SubagentStartedEvent {
+  readonly type: 'subagent.started';
+  readonly subagentId: string;
+}
+
+export interface SubagentCompletedEvent {
+  readonly type: 'subagent.completed';
+  readonly subagentId: string;
+  readonly resultSummary: string;
+  readonly usage?: TokenUsage;
+  readonly contextTokens?: number;
+}
+
+export interface SubagentFailedEvent {
+  readonly type: 'subagent.failed';
+  readonly subagentId: string;
+  readonly error: string;
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'subagent.spawned': SubagentSpawnedEvent;
diff --git a/packages/agent-core-v2/src/session/subagent/runAgentTurn.ts b/packages/agent-core-v2/src/session/subagent/runAgentTurn.ts
index c77d0485c..edb98f91d 100644
--- a/packages/agent-core-v2/src/session/subagent/runAgentTurn.ts
+++ b/packages/agent-core-v2/src/session/subagent/runAgentTurn.ts
@@ -79,8 +79,10 @@ async function awaitRun(
   const controller = new AbortController();
   const unlink = linkAbortSignal(options.signal, controller);
   const loop = target.accessor.get(IAgentLoopService);
-  const cancelTurn = (reason: unknown): void => {
-    loop.cancel(undefined, reason);
+  // Cancel by turn id: `loop.cancel(undefined, …)` only reaches the active
+  // turn, but this run's turn may still be queued when the abort lands.
+  const cancelTurn = (turnToCancel: Turn, reason: unknown): void => {
+    loop.cancel(turnToCancel.id, reason);
   };
   let turnRef: Turn = turn;
   try {
@@ -100,24 +102,43 @@ async function awaitRun(
   } finally {
     unlink();
     if (controller.signal.aborted) {
-      cancelTurn(controller.signal.reason);
+      cancelTurn(turnRef, controller.signal.reason);
     }
   }
 }
 
+/**
+ * Await a turn's terminal result, cancelling it first when the run aborts.
+ *
+ * This deliberately does NOT race `turn.result` against the abort signal:
+ * the loop only goes idle once `runTurn` unwinds (`releaseActiveTurn`), and
+ * downstream consumers — task settlement, the `task.killed` notification,
+ * and the resume guard reading `loop.status()` — must not observe the run
+ * as finished before that. A turn that never responds to the cancel is
+ * still bounded by the task layer's SIGTERM grace, not by an early
+ * rejection here.
+ */
 async function awaitTurn(
   turn: Turn,
   controller: AbortController,
-  cancelTurn: (reason: unknown) => void,
+  cancelTurn: (turn: Turn, reason: unknown) => void,
 ): Promise<TurnResult> {
-  const onAbort = (): void => {
-    cancelTurn(controller.signal.reason);
+  const cancelOnAbort = (): void => {
+    cancelTurn(turn, controller.signal.reason);
   };
-  controller.signal.addEventListener('abort', onAbort, { once: true });
+  controller.signal.addEventListener('abort', cancelOnAbort, { once: true });
   try {
-    return await Promise.race([turn.result, abortPromise(controller.signal)]);
+    if (controller.signal.aborted) {
+      cancelOnAbort();
+    }
+    const result = await turn.result;
+    // Rethrow the original abort reason instead of returning the cancelled
+    // result: consumers match the reason by identity (`isAbortError` /
+    // `error === sink.signal.reason`) to tell a kill apart from a failure.
+    controller.signal.throwIfAborted();
+    return result;
   } finally {
-    controller.signal.removeEventListener('abort', onAbort);
+    controller.signal.removeEventListener('abort', cancelOnAbort);
   }
 }
 
@@ -126,7 +147,7 @@ async function distillSummary(
   controller: AbortController,
   policy: AgentProfileSummaryPolicy | undefined,
   setTurn: (turn: Turn) => void,
-  cancelTurn: (reason: unknown) => void,
+  cancelTurn: (turn: Turn, reason: unknown) => void,
 ): Promise<string> {
   const memory = target.accessor.get(IAgentContextMemoryService);
   let summary = latestAssistantText(memory.get());
@@ -194,21 +215,6 @@ function providerRateLimitErrorFromPayload(error: KimiErrorPayload): APIProvider
   return new APIProviderRateLimitError(error.message, requestId);
 }
 
-function abortPromise(signal: AbortSignal): Promise<never> {
-  if (signal.aborted) {
-    return Promise.reject(signal.reason ?? userCancellationReason());
-  }
-  return new Promise<never>((_resolve, reject) => {
-    signal.addEventListener(
-      'abort',
-      () => {
-        reject(signal.reason ?? userCancellationReason());
-      },
-      { once: true },
-    );
-  });
-}
-
 function latestAssistantText(messages: readonly ContextMessage[]): string {
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i]!;
diff --git a/packages/agent-core-v2/src/session/subagent/tools/agent.md b/packages/agent-core-v2/src/session/subagent/tools/agent.md
index ec0533e7e..d8b65d7c0 100644
--- a/packages/agent-core-v2/src/session/subagent/tools/agent.md
+++ b/packages/agent-core-v2/src/session/subagent/tools/agent.md
@@ -9,7 +9,7 @@ Writing the prompt:
 Usage notes:
 - When the task continues earlier work a subagent already did, prefer resuming that agent (pass its `resume` id) over spawning a fresh instance — the resumed agent keeps its prior context.
 - A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.
-- Subagents use a fixed 30-minute timeout. If one times out, resume the same agent instead of starting over.
+- Subagents use a fixed 2-hour timeout. If one times out, resume the same agent instead of starting over.
 
 When NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.
 
diff --git a/packages/agent-core-v2/src/session/subagent/tools/agent.ts b/packages/agent-core-v2/src/session/subagent/tools/agent.ts
index 6193b0a06..5999e9d0e 100644
--- a/packages/agent-core-v2/src/session/subagent/tools/agent.ts
+++ b/packages/agent-core-v2/src/session/subagent/tools/agent.ts
@@ -17,7 +17,11 @@
 import { z } from 'zod';
 
 import type { IAgentScopeHandle } from '#/_base/di/scope';
-import { isUserCancellation } from '#/_base/utils/abort';
+import {
+  isAbortError,
+  isUserCancellation,
+  userCancellationReason,
+} from '#/_base/utils/abort';
 import { toInputJsonSchema } from '#/tool/input-schema';
 import { matchesGlobRuleSubject } from '#/tool/rule-match';
 import {
@@ -29,7 +33,6 @@ import { IAgentPermissionModeService } from '#/agent/permissionMode/permissionMo
 import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import { IAgentLoopService } from '#/agent/loop/loop';
 import { IAgentUserToolService } from '#/agent/userTool/userTool';
-import { isAbortError } from '#/_base/utils/abort';
 import {
   ToolAccesses,
   type BuiltinTool,
@@ -41,6 +44,7 @@ import { registerTool } from '#/agent/toolRegistry/toolContribution';
 import { IAgentProfileCatalogService, type AgentProfile } from '#/app/agentProfileCatalog/agentProfileCatalog';
 import { applyProfilePromptPrefix } from '#/app/agentProfileCatalog/promptPrefix';
 import { ILogService } from '#/_base/log/log';
+import { IConfigService } from '#/app/config/config';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { isSubagentMeta, subagentLabels, subagentParentAgentId } from '#/session/agentLifecycle/subagentMetadata';
 import { ISessionProcessRunner } from '#/session/process/processRunner';
@@ -49,6 +53,10 @@ import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceCo
 
 import { emitAgentRunSpawned, mirrorAgentRun } from '../mirrorAgentRun';
 import { ISessionSubagentService } from '../subagent';
+import {
+  formatSubagentTimeoutDescription,
+  resolveSubagentTimeoutMs,
+} from '../configSection';
 import { SubagentTask, type SubagentHandle } from './subagent-task';
 
 import AGENT_BACKGROUND_DISABLED_DESCRIPTION from './agent-background-disabled.md?raw';
@@ -57,8 +65,6 @@ import AGENT_DESCRIPTION_BASE from './agent.md?raw';
 
 const DEFAULT_PROFILE_NAME = 'coder';
 const RESUMED_LABEL = 'subagent';
-export const DEFAULT_SUBAGENT_TIMEOUT_MS = 30 * 60 * 1000;
-export const DEFAULT_SUBAGENT_TIMEOUT_DESCRIPTION = '30 minutes';
 
 export const AgentToolInputSchema = z.preprocess(
   (input) => {
@@ -124,7 +130,8 @@ const BACKGROUND_AGENT_UNAVAILABLE =
 const RESUME_WITH_TYPE_UNAVAILABLE =
   'Cannot set subagent_type when resuming an existing agent. Resume by agent id only.';
 const USER_INTERRUPTED_SUBAGENT_MESSAGE =
-  "The user manually interrupted this subagent (and any sibling agents launched alongside it). This was a deliberate user action, not a system error, a timeout, or a capacity/concurrency limit. Do not retry automatically or speculate about why it failed — wait for the user's next instruction.";
+  'The subagent was stopped before it finished by user.';
+const SUBAGENT_STOPPED_MESSAGE = 'The subagent was stopped before it finished.';
 
 
 export class AgentTool implements BuiltinTool<AgentToolInput> {
@@ -146,6 +153,7 @@ export class AgentTool implements BuiltinTool<AgentToolInput> {
     @ISessionMetadata private readonly sessionMetadata: ISessionMetadata,
     @ILogService private readonly log: ILogService,
     @IAgentPermissionModeService private readonly permissionMode: IAgentPermissionModeService,
+    @IConfigService private readonly config: IConfigService,
   ) {
     this.callerAgentId = scopeContext.agentId;
     this.canRunInBackground = () =>
@@ -334,6 +342,7 @@ export class AgentTool implements BuiltinTool<AgentToolInput> {
       if (runInBackground && !allowBackground) {
         return { output: BACKGROUND_AGENT_UNAVAILABLE, isError: true };
       }
+      const timeoutMs = resolveSubagentTimeoutMs(this.config);
 
       const controller = new AbortController();
       const abortBeforeRegister = (): void => {
@@ -363,7 +372,7 @@ export class AgentTool implements BuiltinTool<AgentToolInput> {
       try {
         const registerOptions: RegisterAgentTaskOptions = {
           detached: runInBackground,
-          timeoutMs: DEFAULT_SUBAGENT_TIMEOUT_MS,
+          timeoutMs,
           signal: runInBackground ? undefined : signal,
         };
         taskId = this.tasks.registerTask(
@@ -403,7 +412,7 @@ export class AgentTool implements BuiltinTool<AgentToolInput> {
           output: formatBackgroundAgentResult(taskId, handle, args.description, allowBackground),
         };
       }
-      return await this.formatForegroundResult(taskId, handle);
+      return await this.formatForegroundResult(taskId, handle, timeoutMs);
     } catch (error) {
       return { output: `subagent error: ${launchErrorMessage(error, signal)}`, isError: true };
     }
@@ -412,6 +421,7 @@ export class AgentTool implements BuiltinTool<AgentToolInput> {
   private async formatForegroundResult(
     taskId: string,
     handle: SubagentHandle,
+    timeoutMs: number,
   ): Promise<ExecutableToolResult> {
     const info = this.tasks.getTask(taskId);
     if (info?.status === 'completed') {
@@ -421,12 +431,8 @@ export class AgentTool implements BuiltinTool<AgentToolInput> {
     }
     const timedOut = info?.status === 'timed_out';
     const message = timedOut
-      ? `Agent timed out after ${DEFAULT_SUBAGENT_TIMEOUT_DESCRIPTION}.`
-      : info?.stopReason === 'Interrupted by user'
-        ? USER_INTERRUPTED_SUBAGENT_MESSAGE
-        : info?.stopReason !== undefined
-          ? info.stopReason
-          : 'The subagent was stopped before it finished.';
+      ? `Agent timed out after ${formatSubagentTimeoutDescription(timeoutMs)}.`
+      : formatSubagentStoppedMessage(info?.stopReason);
     return {
       output: formatForegroundAgentFailure(handle, message, timedOut),
       isError: true,
@@ -509,6 +515,19 @@ function formatForegroundAgentFailure(
 
 function launchErrorMessage(error: unknown, signal: AbortSignal): string {
   if (isUserCancellation(signal.reason)) return USER_INTERRUPTED_SUBAGENT_MESSAGE;
-  if (isAbortError(error)) return 'The subagent was stopped before it finished.';
+  if (isAbortError(error)) return formatSubagentStoppedMessage(errorMessage(signal.reason));
   return error instanceof Error ? error.message : String(error);
 }
+
+function formatSubagentStoppedMessage(reason: string | undefined): string {
+  const normalized = reason?.trim();
+  if (normalized === userCancellationReason().message) return USER_INTERRUPTED_SUBAGENT_MESSAGE;
+  if (normalized === undefined || normalized.length === 0) return SUBAGENT_STOPPED_MESSAGE;
+  return `${SUBAGENT_STOPPED_MESSAGE} Reason: ${normalized}`;
+}
+
+function errorMessage(error: unknown): string | undefined {
+  if (typeof error === 'string') return error;
+  if (error instanceof Error) return error.message;
+  return undefined;
+}
diff --git a/packages/agent-core-v2/src/session/swarm/sessionSwarmService.ts b/packages/agent-core-v2/src/session/swarm/sessionSwarmService.ts
index 8b3a529c9..33be825af 100644
--- a/packages/agent-core-v2/src/session/swarm/sessionSwarmService.ts
+++ b/packages/agent-core-v2/src/session/swarm/sessionSwarmService.ts
@@ -23,7 +23,6 @@ import { IAgentProfileService } from '#/agent/profile/profile';
 import { IAgentPermissionModeService } from '#/agent/permissionMode/permissionMode';
 import { IAgentLoopService } from '#/agent/loop/loop';
 import { IAgentUserToolService } from '#/agent/userTool/userTool';
-import type { SubagentSuspendedEvent } from '@moonshot-ai/protocol';
 import { IEventBus } from '#/app/event/eventBus';
 import { IAgentProfileCatalogService } from '#/app/agentProfileCatalog/agentProfileCatalog';
 import { applyProfilePromptPrefix } from '#/app/agentProfileCatalog/promptPrefix';
@@ -56,6 +55,12 @@ import {
   type AgentRunAttemptHandle,
 } from './agentRunBatch';
 
+export interface SubagentSuspendedEvent {
+  readonly type: 'subagent.suspended';
+  readonly subagentId: string;
+  readonly reason: string;
+}
+
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
     'subagent.suspended': SubagentSuspendedEvent;
diff --git a/packages/agent-core-v2/src/session/todo/sessionTodoService.ts b/packages/agent-core-v2/src/session/todo/sessionTodoService.ts
index 9bb146e8e..6c51e0225 100644
--- a/packages/agent-core-v2/src/session/todo/sessionTodoService.ts
+++ b/packages/agent-core-v2/src/session/todo/sessionTodoService.ts
@@ -4,21 +4,17 @@
  * Holds the session's shared todo list as a stateless facade over the main
  * agent's `TodoModel`: `getTodos` reads `wire.getModel(TodoModel)` live, and
  * every mutation only dispatches a `tools.update_store` Op to the main agent's
- * wire (the
- * single source of truth and replayable timeline); `onDidChange` is bridged
- * from `wire.subscribe(TodoModel)`. The service keeps no list copy of its own,
- * so the live view and the post-replay view can never drift. Binds the
+ * wire (the single source of truth and replayable timeline), then emits
+ * `onDidChange` from the rebuilt Model. The service keeps no list copy of its
+ * own, so the live view and the post-replay view can never drift. Binds the
  * `TodoListTool` and the stale-todo reminder into every agent (`onDidCreate`),
- * and the model subscription into the main agent (`onDidCreateMain`),
  * borrowing each agent's services through its `IAgentScopeHandle.accessor`.
- * Per-agent bindings are disposed when the agent is disposed. Bound at Session
- * scope.
+ * Per-agent bindings are disposed when the agent is disposed. Bound at
+ * Session scope.
  *
- * Debt: the session's todo list is still persisted on the MAIN agent's wire (a
- * Session → Agent edge), so it follows the main agent's lifetime. Once
- * `ISessionWireService` is wired up with its own log + replay, move `TodoModel`
- * there — swap `@IAgentWireService` for `@ISessionWireService` and drop the
- * main-agent subscription. The stateless facade makes that a one-line change.
+ * The session owns the todo facade and tool bindings, while the main Agent wire
+ * owns the replayable state. This is an explicit cross-scope orchestration
+ * boundary: there is no second session-level wire aggregate or journal.
  */
 
 import { Disposable, toDisposable, type IDisposable } from '#/_base/di/lifecycle';
@@ -32,7 +28,7 @@ import { IAgentProfileService } from '#/agent/profile/profile';
 import { SPINE_FLAG_ID } from '#/agent/spine/flag';
 import { IFlagService } from '#/app/flag/flag';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 
 import { ISessionTodoService } from './sessionTodo';
 import { TodoModel, todoSet } from './todoOps';
@@ -58,7 +54,6 @@ export class SessionTodoService extends Disposable implements ISessionTodoServic
     this._register(
       this.agentLifecycle.onDidCreate((handle) => {
         this.bindAgent(handle);
-        if (handle.id === MAIN_AGENT_ID) this.bindMainWire(handle);
       }),
     );
     this._register(
@@ -67,7 +62,6 @@ export class SessionTodoService extends Disposable implements ISessionTodoServic
 
     for (const handle of this.agentLifecycle.list()) {
       this.bindAgent(handle);
-      if (handle.id === MAIN_AGENT_ID) this.bindMainWire(handle);
     }
 
     this._register(
@@ -82,7 +76,7 @@ export class SessionTodoService extends Disposable implements ISessionTodoServic
   getTodos(): readonly TodoItem[] {
     const main = this.agentLifecycle.get(MAIN_AGENT_ID);
     if (main === undefined) return [];
-    return main.accessor.get(IAgentWireService).getModel(TodoModel);
+    return main.accessor.get(IWireService).getModel(TodoModel);
   }
 
   setTodos(todos: readonly TodoItem[]): void {
@@ -100,16 +94,9 @@ export class SessionTodoService extends Disposable implements ISessionTodoServic
   private dispatchTodoSet(todos: readonly TodoItem[]): void {
     const main = this.agentLifecycle.get(MAIN_AGENT_ID);
     if (main === undefined) return;
-    const wire = main.accessor.get(IAgentWireService);
+    const wire = main.accessor.get(IWireService);
     wire.dispatch(todoSet({ key: 'todo', value: todos }));
-  }
-
-  private bindMainWire(handle: IAgentScopeHandle): void {
-    const wire = handle.accessor.get(IAgentWireService);
-    const disposable = wire.subscribe(TodoModel, (state) => {
-      this.onDidChangeEmitter.fire(state);
-    });
-    this.trackAgentBinding(handle.id, disposable);
+    this.onDidChangeEmitter.fire(wire.getModel(TodoModel));
   }
 
   private bindAgent(handle: IAgentScopeHandle): void {
diff --git a/packages/agent-core-v2/src/session/todo/todoOps.ts b/packages/agent-core-v2/src/session/todo/todoOps.ts
index 148d8346b..29a931aa4 100644
--- a/packages/agent-core-v2/src/session/todo/todoOps.ts
+++ b/packages/agent-core-v2/src/session/todo/todoOps.ts
@@ -11,10 +11,10 @@
  * render, the stale reminder, the compaction summary) can trust the Model
  * without re-validating. Consumed cross-scope by the Session-scope
  * `SessionTodoService`: it dispatches to the MAIN agent's wire (the single
- * source of truth and replayable timeline) and, on `wire.onRestored`, reads the
- * rebuilt Model back from that same wire. The Ops register into the global
- * `OP_REGISTRY` at import time, so they are in place before the main agent
- * replays.
+ * source of truth and replayable timeline), and `getTodos` reads the rebuilt
+ * Model back from that same wire after restore. The Ops register into the
+ * global `OP_REGISTRY` at import time, so they are in place before the main
+ * agent restores.
  */
 
 import { z } from 'zod';
diff --git a/packages/agent-core-v2/src/tool/result-builder.ts b/packages/agent-core-v2/src/tool/result-builder.ts
index 34cf147db..ae0d917c4 100644
--- a/packages/agent-core-v2/src/tool/result-builder.ts
+++ b/packages/agent-core-v2/src/tool/result-builder.ts
@@ -21,11 +21,10 @@ export interface ToolResultBuilderOptions {
 }
 
 export type ExecutableToolResultBuilderResult = (
-  | ExecutableToolSuccessResult
   | ExecutableToolErrorResult
+  | ExecutableToolSuccessResult
 ) & {
   readonly output: string;
-  readonly message: string;
   readonly truncated: boolean;
   readonly brief?: string;
 };
@@ -126,7 +125,6 @@ export class ToolResultBuilder {
             ? `${output}${finalMessage}`
             : `${output}\n${finalMessage}`
         : output,
-      message: finalMessage,
       truncated: this.truncationHappened,
       brief: options.brief,
     };
@@ -152,7 +150,6 @@ export class ToolResultBuilder {
             : output.endsWith('\n')
               ? `${output}${finalMessage}`
               : `${output}\n${finalMessage}`,
-      message: finalMessage,
       truncated: this.truncationHappened,
       brief: options.brief,
     };
diff --git a/packages/agent-core-v2/src/tool/toolContract.ts b/packages/agent-core-v2/src/tool/toolContract.ts
index 07774be0f..f8fafd077 100644
--- a/packages/agent-core-v2/src/tool/toolContract.ts
+++ b/packages/agent-core-v2/src/tool/toolContract.ts
@@ -17,6 +17,7 @@
 
 import type { ContentPart, ToolCall } from '#/app/llmProtocol/message';
 import type { Tool } from '#/app/llmProtocol/tool';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 import type { ToolInputDisplay } from '@moonshot-ai/protocol';
 
 export type ExecutableToolOutput = string | ContentPart[];
@@ -39,7 +40,6 @@ export interface ExecutableToolSuccessResult {
   readonly output: ExecutableToolOutput;
   readonly isError?: false | undefined;
   readonly stopTurn?: boolean | undefined;
-  readonly message?: string | undefined;
   readonly truncated?: boolean | undefined;
   readonly note?: string;
   readonly delivery?: ToolDelivery | undefined;
@@ -48,7 +48,6 @@ export interface ExecutableToolSuccessResult {
 export interface ExecutableToolErrorResult {
   readonly output: ExecutableToolOutput;
   readonly isError: true;
-  readonly message?: string | undefined;
   readonly stopTurn?: boolean | undefined;
   readonly truncated?: boolean | undefined;
   readonly note?: string;
@@ -68,6 +67,7 @@ export interface ToolUpdate {
 export interface ExecutableToolContext {
   readonly turnId: number;
   readonly toolCallId: string;
+  readonly trace?: LLMRequestTrace;
   readonly metadata?: unknown;
   readonly signal: AbortSignal;
   readonly onUpdate?: ((update: ToolUpdate) => void) | undefined;
diff --git a/packages/agent-core-v2/src/tool/toolInputDisplay.ts b/packages/agent-core-v2/src/tool/toolInputDisplay.ts
new file mode 100644
index 000000000..1229c95fa
--- /dev/null
+++ b/packages/agent-core-v2/src/tool/toolInputDisplay.ts
@@ -0,0 +1,87 @@
+/**
+ * `ToolInputDisplay` — structured UI hint describing a tool call's input, so
+ * approval panels and tool renderers can present it without re-deriving it
+ * from raw arguments. Carried by `RunnableToolExecution.display`,
+ * `ToolResult.display`, and the `tool.call.started` event.
+ */
+export type ToolInputDisplay =
+  | {
+      kind: 'command';
+      command: string;
+      cwd?: string | undefined;
+      description?: string | undefined;
+      language?: 'bash' | undefined;
+    }
+  | {
+      kind: 'file_io';
+      operation: 'read' | 'write' | 'edit' | 'glob' | 'grep';
+      path: string;
+      detail?: string | undefined;
+      content?: string | undefined;
+      before?: string | undefined;
+      after?: string | undefined;
+    }
+  | {
+      kind: 'diff';
+      path: string;
+      before: string;
+      after: string;
+      hunks?: number | undefined;
+    }
+  | {
+      kind: 'search';
+      query: string;
+      scope?: string | undefined;
+    }
+  | {
+      kind: 'url_fetch';
+      url: string;
+      method?: string | undefined;
+    }
+  | {
+      kind: 'agent_call';
+      agent_name: string;
+      prompt: string;
+      background?: boolean | undefined;
+    }
+  | {
+      kind: 'skill_call';
+      skill_name: string;
+      args?: string | undefined;
+    }
+  | {
+      kind: 'todo_list';
+      items: { title: string; status: string }[];
+    }
+  | {
+      kind: 'task';
+      task_id: string;
+      status: string;
+      description: string;
+      task_kind?: string | undefined;
+    }
+  | {
+      kind: 'task_stop';
+      task_id: string;
+      task_description: string;
+    }
+  | {
+      kind: 'plan_review';
+      plan: string;
+      path?: string | undefined;
+      options?: readonly { label: string; description: string }[] | undefined;
+    }
+  | {
+      kind: 'goal_start';
+      objective: string;
+      completionCriterion?: string | undefined;
+      // Current permission mode at approval time. The client uses it to pick the
+      // start menu (manual vs yolo); `auto` never reaches this display because it
+      // auto-approves the goal without a prompt.
+      mode: 'manual' | 'yolo';
+    }
+  | {
+      kind: 'generic';
+      summary: string;
+      detail?: unknown;
+    };
diff --git a/packages/agent-core-v2/src/wire/errors.ts b/packages/agent-core-v2/src/wire/errors.ts
index e109cf6e2..30e934b06 100644
--- a/packages/agent-core-v2/src/wire/errors.ts
+++ b/packages/agent-core-v2/src/wire/errors.ts
@@ -4,7 +4,7 @@
  *
  * Aggregates the wire domain's coded errors: `DuplicateOpError` (thrown by
  * `defineOp` in `op.ts`) and `CycleError` (thrown by the dispatch drain in
- * `wireServiceImpl.ts`) stay co-located with their throw sites but extend
+ * `wireService.ts`) stay co-located with their throw sites but extend
  * `WireError`; `wire.unknown_record` is constructed here for replay-time
  * reporting of records whose Op type is absent from `OP_REGISTRY`.
  */
@@ -17,6 +17,7 @@ export const WireErrors = {
     WIRE_DUPLICATE_OP: 'wire.duplicate_op',
     WIRE_CYCLE: 'wire.cycle',
     WIRE_UNKNOWN_RECORD: 'wire.unknown_record',
+    RECORDS_WRITE_FAILED: 'records.write_failed',
   },
   info: {
     'wire.duplicate_op': {
@@ -37,6 +38,11 @@ export const WireErrors = {
       public: true,
       action: 'The record was written by a newer version; upgrade or drop it.',
     },
+    'records.write_failed': {
+      title: 'Wire journal write failed',
+      retryable: false,
+      public: true,
+    },
   },
 } as const satisfies ErrorDomain;
 
diff --git a/packages/agent-core-v2/src/agent/wireRecord/migration/migration.ts b/packages/agent-core-v2/src/wire/migration/migration.ts
similarity index 84%
rename from packages/agent-core-v2/src/agent/wireRecord/migration/migration.ts
rename to packages/agent-core-v2/src/wire/migration/migration.ts
index 41e0fe5bb..f572b886c 100644
--- a/packages/agent-core-v2/src/agent/wireRecord/migration/migration.ts
+++ b/packages/agent-core-v2/src/wire/migration/migration.ts
@@ -1,21 +1,22 @@
+import type { WireRecord } from '#/wire/record';
+
 import { migrateV1_0ToV1_1 } from './v1.1';
 import { migrateV1_1ToV1_2 } from './v1.2';
 import { migrateV1_2ToV1_3 } from './v1.3';
 import { migrateV1_3ToV1_4 } from './v1.4';
+import { migrateV1_4ToV1_5 } from './v1.5';
 
 export {
   migrateV1_0ToV1_1,
   migrateV1_1ToV1_2,
   migrateV1_2ToV1_3,
   migrateV1_3ToV1_4,
+  migrateV1_4ToV1_5,
 };
 
-export const AGENT_WIRE_PROTOCOL_VERSION = '1.4';
+export const WIRE_PROTOCOL_VERSION = '1.5';
 
-export interface WireMigrationRecord {
-  readonly type: string;
-  [key: string]: unknown;
-}
+export type WireMigrationRecord = WireRecord;
 
 export interface WireMigration {
   readonly sourceVersion: string;
@@ -28,20 +29,21 @@ const MIGRATIONS: readonly WireMigration[] = [
   migrateV1_1ToV1_2,
   migrateV1_2ToV1_3,
   migrateV1_3ToV1_4,
+  migrateV1_4ToV1_5,
 ];
 
 export function isNewerWireVersion(readVersion: string): boolean {
-  return compareWireVersions(readVersion, AGENT_WIRE_PROTOCOL_VERSION) > 0;
+  return compareWireVersions(readVersion, WIRE_PROTOCOL_VERSION) > 0;
 }
 
 export function resolveWireMigrations(readVersion: string): readonly WireMigration[] {
-  if (compareWireVersions(readVersion, AGENT_WIRE_PROTOCOL_VERSION) >= 0) {
+  if (compareWireVersions(readVersion, WIRE_PROTOCOL_VERSION) >= 0) {
     return [];
   }
 
   const migrations: WireMigration[] = [];
   let version = readVersion;
-  while (compareWireVersions(version, AGENT_WIRE_PROTOCOL_VERSION) < 0) {
+  while (compareWireVersions(version, WIRE_PROTOCOL_VERSION) < 0) {
     const migration = findMigration(version);
     if (migration === undefined) {
       throw new Error(`Missing wire migration for version ${version}`);
diff --git a/packages/agent-core-v2/src/agent/wireRecord/migration/v1.1.ts b/packages/agent-core-v2/src/wire/migration/v1.1.ts
similarity index 100%
rename from packages/agent-core-v2/src/agent/wireRecord/migration/v1.1.ts
rename to packages/agent-core-v2/src/wire/migration/v1.1.ts
diff --git a/packages/agent-core-v2/src/agent/wireRecord/migration/v1.2.ts b/packages/agent-core-v2/src/wire/migration/v1.2.ts
similarity index 100%
rename from packages/agent-core-v2/src/agent/wireRecord/migration/v1.2.ts
rename to packages/agent-core-v2/src/wire/migration/v1.2.ts
diff --git a/packages/agent-core-v2/src/agent/wireRecord/migration/v1.3.ts b/packages/agent-core-v2/src/wire/migration/v1.3.ts
similarity index 100%
rename from packages/agent-core-v2/src/agent/wireRecord/migration/v1.3.ts
rename to packages/agent-core-v2/src/wire/migration/v1.3.ts
diff --git a/packages/agent-core-v2/src/agent/wireRecord/migration/v1.4.ts b/packages/agent-core-v2/src/wire/migration/v1.4.ts
similarity index 100%
rename from packages/agent-core-v2/src/agent/wireRecord/migration/v1.4.ts
rename to packages/agent-core-v2/src/wire/migration/v1.4.ts
diff --git a/packages/agent-core-v2/src/wire/migration/v1.5.ts b/packages/agent-core-v2/src/wire/migration/v1.5.ts
new file mode 100644
index 000000000..8b18e7b07
--- /dev/null
+++ b/packages/agent-core-v2/src/wire/migration/v1.5.ts
@@ -0,0 +1,28 @@
+/**
+ * Wire protocol 1.5 persists an epoch-ms anchor at every goal create/resume
+ * boundary and wall-clock checkpoint. Version 1.4 records already carry an
+ * epoch-ms `time`, so the migration can recover that boundary without
+ * inventing a crash timestamp or adding periodic checkpoint writes. Existing
+ * anchors are authoritative.
+ */
+import type { WireMigration, WireMigrationRecord } from './migration';
+
+export const migrateV1_4ToV1_5: WireMigration = {
+  sourceVersion: '1.4',
+  targetVersion: '1.5',
+  migrateRecord(record: WireMigrationRecord): WireMigrationRecord {
+    if (!advancesActiveInterval(record)) return record;
+    if (record['wallClockResumedAt'] !== undefined) return record;
+    if (typeof record['time'] !== 'number') return record;
+    return { ...record, wallClockResumedAt: record['time'] };
+  },
+};
+
+function advancesActiveInterval(record: WireMigrationRecord): boolean {
+  return (
+    record.type === 'goal.create' ||
+    (record.type === 'goal.update' &&
+      (record['status'] === 'active' ||
+        (record['status'] === undefined && typeof record['wallClockMs'] === 'number')))
+  );
+}
diff --git a/packages/agent-core-v2/src/wire/model.ts b/packages/agent-core-v2/src/wire/model.ts
index 83e303134..2693f2529 100644
--- a/packages/agent-core-v2/src/wire/model.ts
+++ b/packages/agent-core-v2/src/wire/model.ts
@@ -29,11 +29,10 @@
  * cast happens once inside `WireService`.
  *
  * A primary Model may register cross-model reducers keyed by foreign op types:
- * `WireService.execute` runs them on both dispatch and replay, so v1-derived
+ * `WireService` runs them on both dispatch and restore, so v1-derived
  * restore effects can stay replayable without persisting extra records.
- *
  * `DeepReadonly<T>` recursively maps a state type to its deeply-readonly view
- * for the references returned by `getModel` / `subscribe`: functions pass
+ * for the references returned by `getModel`: functions pass
  * through, `Map` / `Set` widen to `ReadonlyMap` / `ReadonlySet`, arrays and
  * tuples widen to `ReadonlyArray`, plain objects become a readonly mapped type,
  * and primitives are unchanged. It pairs with the runtime `Object.freeze`
@@ -42,12 +41,12 @@
 
 import { bindDefineOp, type DefineOpFn } from '#/wire/op';
 import type { ModelReducers } from '#/wire/types';
-import type { PersistedRecord } from '#/wire/wireService';
+import type { WireRecord } from '#/wire/record';
 
 export type PartsTransformer = (parts: readonly unknown[]) => Promise<readonly unknown[]>;
 
 export interface ModelBlobCodec<S> {
-  dehydrate(record: PersistedRecord, transform: PartsTransformer): PersistedRecord | Promise<PersistedRecord>;
+  dehydrate(record: WireRecord, transform: PartsTransformer): WireRecord | Promise<WireRecord>;
   rehydrate(state: S, transform: PartsTransformer): S | Promise<S>;
 }
 
@@ -95,22 +94,6 @@ export function defineModel<S>(
   return def;
 }
 
-export interface DerivedModelDef<S> {
-  readonly name: string;
-  readonly initial: () => S;
-  readonly reducers: Readonly<ModelReducers<S>>;
-  readonly blobs?: ModelBlobCodec<S>;
-}
-
-export function defineDerivedModel<S>(
-  name: string,
-  initial: () => S,
-  reducers: ModelReducers<S>,
-  opts?: { blobs?: ModelBlobCodec<S> },
-): DerivedModelDef<S> {
-  return { name, initial, reducers, blobs: opts?.blobs };
-}
-
 export type DeepReadonly<T> = T extends (...args: infer A) => infer R
   ? (...args: A) => R
   : T extends ReadonlyMap<infer K, infer V>
diff --git a/packages/agent-core-v2/src/wire/op.ts b/packages/agent-core-v2/src/wire/op.ts
index ea2b0db12..d635ddb5d 100644
--- a/packages/agent-core-v2/src/wire/op.ts
+++ b/packages/agent-core-v2/src/wire/op.ts
@@ -8,12 +8,12 @@
  * callable (`goalCreate(payload)`) and inspectable (`goalCreate.apply`,
  * `goalCreate.type`). Every Op carries a mandatory pure `apply` and may carry
  * an optional `toEvent` that derives an `IEventBus` fact from the payload and
- * the post-apply state (published by `WireService` on `dispatch`, never on
- * `replay`). A mandatory `schema` (zod, declared before `apply`) is the
+ * the post-apply state (published by `WireService` on live `dispatch`,
+ * never during `restore`). A mandatory `schema` (zod, declared before `apply`) is the
  * payload's single source of truth: `P` is inferred from it, so Op authors
  * never restate payload interfaces, and it is stored on the descriptor for
  * payload validation at wire boundaries; the runtime paths (`dispatch` /
- * `replay`) never consult it. The descriptor's payload is erased
+ * `restore`) never consult it. The descriptor's payload is erased
  * to `any` on `Op.descriptor` (mirroring `OP_REGISTRY`) so `Op` stays
  * covariant in `P` — a heterogeneous batch of Ops, each with a different
  * payload type, stays assignable to the single `dispatch(...ops: Op[])` rest
@@ -23,8 +23,7 @@
  * definition into the `types.ts` registries (which map op types to `typeof`
  * the Op); registration constrains only the persistence policy — a registered
  * type must honor its map, an unregistered type keeps its free `persist`
- * option. Descriptors may opt out of timestamp stamping (`stamp: false`) for
- * the metadata envelope. Scope-agnostic.
+ * option. Scope-agnostic.
  */
 
 import type { z } from 'zod';
@@ -50,7 +49,6 @@ export interface OpDescriptor<K extends string, S, P> {
   readonly apply: (state: S, payload: P) => S;
   readonly toEvent?: (payload: P, state: S) => unknown;
   readonly persist?: boolean;
-  readonly stamp?: boolean;
 }
 
 export interface Op<K extends string = string, P = unknown> {
@@ -67,7 +65,6 @@ interface OpBehaviorOptions<S, P> {
   readonly schema: z.ZodType<P>;
   readonly apply: (state: S, payload: P) => S;
   readonly toEvent?: (payload: P, state: S) => unknown;
-  readonly stamp?: boolean;
 }
 
 type RegisteredOpConstraint<K extends string> = K extends ConflictingOpType
@@ -122,7 +119,6 @@ export function defineOp<const K extends string, S, P>(
     apply: behavior.apply,
     toEvent: behavior.toEvent,
     persist: behavior.persist,
-    stamp: behavior.stamp,
   };
   OP_REGISTRY.set(type, descriptor);
   const factory = (payload: P): Op<K, P> => ({ type, payload, descriptor });
diff --git a/packages/agent-core-v2/src/wire/record.ts b/packages/agent-core-v2/src/wire/record.ts
new file mode 100644
index 000000000..92a9bc28f
--- /dev/null
+++ b/packages/agent-core-v2/src/wire/record.ts
@@ -0,0 +1,68 @@
+/**
+ * `wire` domain (L2) — the persisted journal record language.
+ *
+ * A `WireRecord` is the flat JSONL representation of one persisted Op. The
+ * first line of an Agent journal is a `WireMetadataRecord`; metadata is a
+ * journal envelope, not an Op, so it never enters the model reducer registry.
+ * This module owns only pure encoding and decoding.
+ */
+
+import type { Op } from '#/wire/op';
+
+import { WIRE_PROTOCOL_VERSION } from './migration/migration';
+
+export const AGENT_WIRE_RECORD_KEY = 'wire.jsonl';
+
+export interface WireRecord {
+  readonly type: string;
+  readonly time?: number;
+  readonly [key: string]: unknown;
+}
+
+export interface WireMetadataRecord extends WireRecord {
+  readonly type: 'metadata';
+  readonly protocol_version: string;
+  readonly created_at: number;
+}
+
+export function isWireRecord(record: unknown): record is WireRecord {
+  return (
+    record !== null &&
+    typeof record === 'object' &&
+    !Array.isArray(record) &&
+    typeof (record as { type?: unknown }).type === 'string'
+  );
+}
+
+export function createWireMetadataRecord(now = Date.now()): WireMetadataRecord {
+  return {
+    type: 'metadata',
+    protocol_version: WIRE_PROTOCOL_VERSION,
+    created_at: now,
+  };
+}
+
+export function isWireMetadataRecord(record: WireRecord): record is WireMetadataRecord {
+  return (
+    record.type === 'metadata' &&
+    typeof record['protocol_version'] === 'string' &&
+    typeof record['created_at'] === 'number'
+  );
+}
+
+export function opToWireRecord(op: Op, now = Date.now()): WireRecord {
+  const payload = op.payload;
+  const record: Record<string, unknown> =
+    payload !== null && typeof payload === 'object' && !Array.isArray(payload)
+      ? { type: op.type, ...(payload as Record<string, unknown>) }
+      : { type: op.type, payload };
+  if (record['time'] === undefined) record['time'] = now;
+  return record as WireRecord;
+}
+
+export function wireRecordToPayload(record: WireRecord): unknown {
+  const { type: _type, time: _time, ...payload } = record;
+  return Object.keys(payload).length === 1 && 'payload' in payload
+    ? payload['payload']
+    : payload;
+}
diff --git a/packages/agent-core-v2/src/wire/tokens.ts b/packages/agent-core-v2/src/wire/tokens.ts
deleted file mode 100644
index 144060b42..000000000
--- a/packages/agent-core-v2/src/wire/tokens.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * `wire` domain (L2) — scope-specific DI tokens (`IAgentWireService`,
- * `ISessionWireService`) over the single `IWireService` contract.
- *
- * One `WireService` implementation serves every scope; per-scope isolation
- * comes from distinct tokens, each seeded with its own persistence key at scope
- * creation. Domain services inject the token for their scope
- * (`@IAgentWireService`, `@ISessionWireService`). No App-scope token yet — add
- * one when a use case appears.
- */
-
-import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
-
-import type { IWireService } from './wireService';
-
-export const IAgentWireService: ServiceIdentifier<IWireService> =
-  createDecorator<IWireService>('agentWireService');
-
-export const ISessionWireService: ServiceIdentifier<IWireService> =
-  createDecorator<IWireService>('sessionWireService');
diff --git a/packages/agent-core-v2/src/wire/wire.ts b/packages/agent-core-v2/src/wire/wire.ts
new file mode 100644
index 000000000..86e36fd66
--- /dev/null
+++ b/packages/agent-core-v2/src/wire/wire.ts
@@ -0,0 +1,36 @@
+/**
+ * `wire` domain (L2) — the single Agent-scoped wire aggregate contract.
+ *
+ * The service owns one Agent's replayable model state and its journal as one
+ * consistency boundary: restore reads, validates, migrates, rewrites, replays,
+ * rehydrates, and then runs the ordered restore hook. Seal initializes a fresh
+ * journal before session metadata makes the Agent visible to legacy readers.
+ * Live dispatch applies an Op and appends its record. Callers do not coordinate
+ * journal and model state through separate services.
+ */
+
+import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
+import type { Hooks } from '#/hooks';
+
+import type { DeepReadonly, ModelDef } from './model';
+import type { Op } from './op';
+
+export type WireHooks = {
+  readonly onDidRestore: Record<string, never>;
+};
+
+export interface IWireService {
+  readonly _serviceBrand: undefined;
+
+  readonly hooks: Hooks<WireHooks>;
+
+  dispatch(...ops: Op[]): void;
+  seal(): Promise<void>;
+  restore(): Promise<void>;
+  flush(): Promise<void>;
+
+  getModel<S>(model: ModelDef<S>): DeepReadonly<S>;
+}
+
+export const IWireService: ServiceIdentifier<IWireService> =
+  createDecorator<IWireService>('wireService');
diff --git a/packages/agent-core-v2/src/wire/wireService.ts b/packages/agent-core-v2/src/wire/wireService.ts
index c6f54c9a2..a02a8441b 100644
--- a/packages/agent-core-v2/src/wire/wireService.ts
+++ b/packages/agent-core-v2/src/wire/wireService.ts
@@ -1,67 +1,335 @@
 /**
- * `wire` domain (L2) — `IWireService` contract and its supporting types
- * (`PersistedRecord`, `OpGroup`, `ModelChange`).
+ * `wire` domain (L2) — `IWireService` implementation.
  *
- * The scope-agnostic state-machine engine: `dispatch` persists + applies +
- * notifies (OpGroup `{ silent: false }`), `replay` (async — rehydrates blob
- * references via `ModelDef.blobs` first) applies only (`{ silent: true }`);
- * `flush` drains the serialized persist queue. Reads go through `getModel` /
- * `subscribe`; the live append-log record stream streams via `onEmission`,
- * restore completion via `onRestored`, and Op-derived facts flow out through
- * `IEventBus` (see `op.ts` `toEvent`). A single implementation serves every
- * scope — instances are isolated per scope through the distinct DI tokens in
- * `tokens`, each seeded with its own persistence key. `PersistedRecord` is the
- * on-the-wire append-log shape (`wire.jsonl`): intentionally flat
- * (`{ type, ...payload }`, optional `time`) so it stays byte-compatible with the
- * existing wire journal (`{ type, time?, ...fields }`) — payload fields
- * sit at the top level next to `type`, never nested under a `payload` key; the
- * index signature keeps it scope-agnostic and domains narrow via their Op
- * payload types. Scope-agnostic.
+ * `WireService` is the sole runtime owner of an Agent wire aggregate. It
+ * combines the model reducer engine with the `wire.jsonl` journal protocol,
+ * including creation-time sealing, metadata, migrations, atomic healing
+ * rewrites, blob dehydration and rehydration plus an ordered post-restore hook.
+ * It is bound at Agent scope because the aggregate identity is the Agent
+ * identity.
  */
 
-import type { IDisposable } from '#/_base/di/lifecycle';
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
-import type { DeepReadonly, DerivedModelDef, ModelDef } from './model';
+import { InstantiationType } from '#/_base/di/extensions';
+import { BugIndicatingError } from '#/_base/errors/errors';
+import { onUnexpectedError } from '#/_base/errors/unexpectedError';
+import { Disposable } from '#/_base/di/lifecycle';
+import { LifecycleScope, registerScopedService } from '#/_base/di/scope';
+import { IAgentBlobService } from '#/agent/blob/agentBlobService';
+import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
+import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
+import type { ContentPart } from '#/app/llmProtocol/message';
+import { OrderedHookSlot } from '#/hooks';
+import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
+import { StorageError, StorageErrors } from '#/persistence/interface/storage';
+
+import { IWireService } from './wire';
+import { WireError, WireErrors } from './errors';
+import {
+  WIRE_PROTOCOL_VERSION,
+  isNewerWireVersion,
+  migrateV1_4ToV1_5,
+  migrateWireRecord,
+  resolveWireMigrations,
+  type WireMigration,
+} from './migration/migration';
+import type { DeepReadonly, ModelDef, PartsTransformer } from './model';
+import { MODEL_CROSS_REDUCERS } from './model';
 import type { Op } from './op';
+import { OP_REGISTRY } from './op';
+import {
+  AGENT_WIRE_RECORD_KEY,
+  createWireMetadataRecord,
+  isWireRecord,
+  isWireMetadataRecord,
+  opToWireRecord,
+  wireRecordToPayload,
+  type WireRecord,
+} from './record';
 
-export interface PersistedRecord {
-  readonly type: string;
-  readonly time?: number;
-  readonly [key: string]: unknown;
+const MAX_DRAIN = 100;
+
+export class CycleError extends WireError {
+  constructor(readonly depth: number, readonly opTypes: readonly string[]) {
+    super(
+      WireErrors.codes.WIRE_CYCLE,
+      `Wire dispatch cascade exceeded MAX_DRAIN (${depth}); possible op cycle`,
+      { details: { depth, opTypes: opTypes.slice(0, 20) } },
+    );
+    this.name = 'CycleError';
+  }
 }
 
-export interface OpGroup {
+interface ModelInstance {
+  state: any;
+}
+
+interface OpGroup {
   readonly ops: readonly Op[];
   readonly silent: boolean;
 }
 
-export interface ModelChange<S> {
-  readonly state: S;
-  readonly prev: S;
+type RestorePhase = 'new' | 'restoring' | 'ready' | 'failed';
+
+export class WireService extends Disposable implements IWireService {
+  declare readonly _serviceBrand: undefined;
+
+  readonly hooks: IWireService['hooks'] = {
+    onDidRestore: new OrderedHookSlot(),
+  };
+
+  private readonly models = new Map<ModelDef<any>, ModelInstance>();
+  private readonly wireScope: string;
+
+  private restorePhase: RestorePhase = 'new';
+  private dispatching = false;
+  private queue: Op[] = [];
+  private drainDepth = 0;
+  private persistQueue: Promise<void> | undefined;
+
+  constructor(
+    @IAgentScopeContext scopeContext: IAgentScopeContext,
+    @IAppendLogStore private readonly log: IAppendLogStore,
+    @IAgentBlobService private readonly blobService: IAgentBlobService,
+    @IEventBus private readonly eventBus: IEventBus,
+  ) {
+    super();
+    this.wireScope = scopeContext.scope();
+    this._register(this.log.acquire(this.wireScope, AGENT_WIRE_RECORD_KEY));
+  }
+
+  getModel<S>(model: ModelDef<S>): DeepReadonly<S> {
+    return this.ensureModel(model).state as DeepReadonly<S>;
+  }
+
+  dispatch(...ops: Op[]): void {
+    if (ops.length === 0) return;
+    if (this.dispatching) {
+      this.queue.push(...ops);
+      return;
+    }
+    this.dispatching = true;
+    try {
+      this.execute({ ops, silent: false });
+      while (this.queue.length > 0) {
+        if (++this.drainDepth > MAX_DRAIN) {
+          throw new CycleError(this.drainDepth, this.queue.map((op) => op.type));
+        }
+        this.execute({ ops: this.queue.splice(0), silent: false });
+      }
+    } finally {
+      this.queue.length = 0;
+      this.dispatching = false;
+      this.drainDepth = 0;
+    }
+  }
+
+  async seal(): Promise<void> {
+    for await (const record of this.log.read(this.wireScope, AGENT_WIRE_RECORD_KEY)) {
+      void record;
+      return;
+    }
+    this.appendRecord(createWireMetadataRecord());
+  }
+
+  async restore(): Promise<void> {
+    if (
+      this.restorePhase === 'restoring' ||
+      this.restorePhase === 'failed' ||
+      this.restorePhase === 'ready'
+    ) {
+      throw new BugIndicatingError(`Agent wire restore called while phase is ${this.restorePhase}`);
+    }
+    this.restorePhase = 'restoring';
+    try {
+      const source = this.log.read<WireRecord>(this.wireScope, AGENT_WIRE_RECORD_KEY);
+      let migrations: readonly WireMigration[] = [];
+      let rewrittenRecords: WireRecord[] | undefined;
+      let newerWireVersion = false;
+      let recordIndex = 0;
+      let hasRecords = false;
+
+      for await (const candidate of source) {
+        const sourceRecord: unknown = candidate;
+        if (!isWireRecord(sourceRecord)) {
+          this.reportSkippedRecord(undefined, recordIndex, true);
+          recordIndex++;
+          continue;
+        }
+        if (!hasRecords) {
+          hasRecords = true;
+          if (sourceRecord.type !== 'metadata') {
+            rewrittenRecords = [createWireMetadataRecord()];
+            migrations = [migrateV1_4ToV1_5];
+          } else if (!isWireMetadataRecord(sourceRecord)) {
+            throw new StorageError(
+              StorageErrors.codes.STORAGE_CORRUPTED,
+              'Agent wire metadata is malformed',
+              { details: { scope: this.wireScope, key: AGENT_WIRE_RECORD_KEY } },
+            );
+          } else if (isNewerWireVersion(sourceRecord.protocol_version)) {
+            newerWireVersion = true;
+          } else {
+            migrations = resolveWireMigrations(sourceRecord.protocol_version);
+            if (sourceRecord.protocol_version !== WIRE_PROTOCOL_VERSION) {
+              rewrittenRecords = [];
+            }
+          }
+        }
+
+        const migratedRecord = migrateWireRecord(sourceRecord, migrations);
+        const record =
+          !newerWireVersion && migratedRecord.type === 'metadata'
+            ? { ...migratedRecord, protocol_version: WIRE_PROTOCOL_VERSION }
+            : migratedRecord;
+        rewrittenRecords?.push(record);
+        if (record.type === 'metadata') continue;
+
+        this.replayRecord(record, recordIndex);
+        recordIndex++;
+      }
+
+      if (!hasRecords) {
+        rewrittenRecords = [createWireMetadataRecord()];
+      }
+      if (rewrittenRecords !== undefined) {
+        await this.log.rewrite(this.wireScope, AGENT_WIRE_RECORD_KEY, rewrittenRecords);
+      }
+
+      await this.rehydrateModels();
+      this.restorePhase = 'ready';
+      await this.hooks.onDidRestore.run({});
+    } catch (error) {
+      this.restorePhase = 'failed';
+      throw error;
+    }
+  }
+
+  async flush(): Promise<void> {
+    await this.persistQueue;
+    await this.log.flush();
+  }
+
+  private replayRecord(record: WireRecord, index: number): void {
+    const descriptor = OP_REGISTRY.get(record.type);
+    if (descriptor === undefined) {
+      this.reportSkippedRecord(record.type, index);
+      return;
+    }
+    const payload = descriptor.schema.safeParse(wireRecordToPayload(record));
+    if (!payload.success) {
+      this.reportSkippedRecord(record.type, index, true);
+      return;
+    }
+    this.execute({
+      ops: [{ type: record.type, payload: payload.data, descriptor }],
+      silent: true,
+    });
+  }
+
+  private reportSkippedRecord(type: string | undefined, index: number, malformed = false): void {
+    onUnexpectedError(
+      new WireError(
+        WireErrors.codes.WIRE_UNKNOWN_RECORD,
+        type === undefined
+          ? 'Malformed wire record skipped during restore'
+          : malformed
+            ? `Malformed wire record type '${type}' skipped during restore`
+            : `Unknown wire record type '${type}' skipped during restore`,
+        { details: { type, index } },
+      ),
+    );
+  }
+
+  private execute(group: OpGroup): void {
+    for (const op of group.ops) {
+      const inst = this.ensureModel(op.descriptor.model);
+      const prev = inst.state;
+      inst.state = Object.freeze(op.descriptor.apply(prev, op.payload));
+      if (!group.silent) {
+        if (op.descriptor.persist !== false) {
+          const record = opToWireRecord(op);
+          this.appendToJournal(record, op.descriptor.model);
+        }
+        const event = op.descriptor.toEvent?.(op.payload, inst.state);
+        if (event !== undefined) {
+          this.eventBus.publish(event as DomainEvent);
+        }
+      }
+      const crossReducers = MODEL_CROSS_REDUCERS.get(op.type);
+      if (crossReducers !== undefined) {
+        for (const entry of crossReducers) {
+          if (entry.model === op.descriptor.model) continue;
+          const crossInst = this.ensureModel(entry.model);
+          crossInst.state = Object.freeze(entry.reducer(crossInst.state, op.payload));
+        }
+      }
+    }
+  }
+
+  private ensureModel<S>(def: ModelDef<S>): ModelInstance {
+    let inst = this.models.get(def);
+    if (inst === undefined) {
+      inst = { state: Object.freeze(def.initial()) };
+      this.models.set(def, inst);
+    }
+    return inst;
+  }
+
+  private appendToJournal(record: WireRecord, model: ModelDef<any>): void {
+    const dehydrate = model.blobs?.dehydrate?.bind(model.blobs);
+    if (dehydrate === undefined && this.persistQueue === undefined) {
+      try {
+        this.appendRecord(record);
+      } catch (error) {
+        onUnexpectedError(error);
+      }
+      return;
+    }
+    const transform: PartsTransformer = (parts) =>
+      this.blobService.offloadParts(
+        parts as readonly ContentPart[],
+      ) as Promise<readonly unknown[]>;
+    const queued = (this.persistQueue ?? Promise.resolve())
+      .then(async () => {
+        let output = record;
+        if (dehydrate !== undefined) {
+          const prepared = dehydrate(record, transform);
+          output = await prepared;
+        }
+        this.appendRecord(output);
+      })
+      .catch((error: unknown) => onUnexpectedError(error));
+    this.persistQueue = queued;
+    void queued.then(() => {
+      if (this.persistQueue === queued) this.persistQueue = undefined;
+    });
+  }
+
+  private appendRecord(record: WireRecord): void {
+    this.log.append(this.wireScope, AGENT_WIRE_RECORD_KEY, record, {
+      onError: onUnexpectedError,
+    });
+  }
+
+  private async rehydrateModels(): Promise<void> {
+    const transform: PartsTransformer = (parts) =>
+      this.blobService.loadParts(
+        parts as readonly ContentPart[],
+      ) as Promise<readonly unknown[]>;
+    for (const [def, inst] of this.models) {
+      if (def.blobs?.rehydrate === undefined) continue;
+      const result = def.blobs.rehydrate(inst.state, transform);
+      inst.state = Object.freeze(await result);
+    }
+  }
 }
 
-export interface ReplayResult {
-  readonly unknownRecords: number;
-}
-
-export interface WireEmission {
-  readonly type: 'record';
-  readonly record: PersistedRecord;
-}
-
-export interface IWireService {
-  readonly _serviceBrand: undefined;
-
-  dispatch(...ops: Op[]): void;
-  replay(...records: PersistedRecord[]): Promise<ReplayResult>;
-  flush(): Promise<void>;
-
-  attach<S>(model: DerivedModelDef<S>): IDisposable;
-  getModel<S>(model: ModelDef<S> | DerivedModelDef<S>): DeepReadonly<S>;
-  subscribe<S>(
-    model: ModelDef<S> | DerivedModelDef<S>,
-    handler: (state: DeepReadonly<S>, prev: DeepReadonly<S>) => void,
-  ): IDisposable;
-  onEmission(handler: (emission: WireEmission) => void): IDisposable;
-  onRestored(handler: () => void | Promise<void>): IDisposable;
-}
+registerScopedService(
+  LifecycleScope.Agent,
+  IWireService,
+  WireService,
+  InstantiationType.Eager,
+  'wire',
+);
diff --git a/packages/agent-core-v2/src/wire/wireServiceImpl.ts b/packages/agent-core-v2/src/wire/wireServiceImpl.ts
deleted file mode 100644
index fe13b1e8d..000000000
--- a/packages/agent-core-v2/src/wire/wireServiceImpl.ts
+++ /dev/null
@@ -1,403 +0,0 @@
-/**
- * `wire` domain (L2) — `WireService`, the single scope-agnostic implementation
- * of `IWireService`, plus its construction options (`WireServiceOptions`)
- * and the coded `CycleError`.
- *
- * One class serves every scope: per-scope isolation comes from the distinct DI
- * tokens in `tokens`, each seeded with its own `WireServiceOptions`
- * (`logScope` / `logKey`) as the leading (non-service) constructor argument
- * through a `SyncDescriptor`, mirroring `WireRecordServiceOptions`. `dispatch`
- * and `replay` both lower to one primitive, `execute(OpGroup)` — apply-all THEN
- * onChange-all, so a subscriber never observes a partially-applied group — with
- * `dispatch` adding persistence + emission + Op-derived `IEventBus` events
- * (`silent: false`) and `replay` staying silent (apply only, skipping
- * unknown record types, then `onRestored`). A reentrancy guard (`dispatching` +
- * `queue` + `drain`, capped by `MAX_DRAIN = 100`) lets onChange handlers enqueue
- * further ops without reentering `execute`; a cascade past the cap throws
- * `CycleError` (`wire.cycle`), co-located here like `DuplicateOpError`
- * (`wire.duplicate_op` in `op.ts`) — both extend `WireError` from
- * `wire/errors.ts`. After every
- * `apply` the new state is `Object.freeze`d — the runtime half of the
- * immutability guarantee whose compile-time half is `DeepReadonly`. Internally
- * each per-model instance is erased to `any` (the same localized erasure as
- * `OP_REGISTRY`) and restored at the public boundary; an Op's optional `toEvent`
- * derives an `IEventBus` fact on `dispatch` (never on `replay`).
- *
- * Persists each dispatched op through `persistence` (`IAppendLogStore`) as a
- * flat `{ type, ...payload }` record — scalar / array payloads nested so a
- * JSONL line stays an object, stamped with `time` unless the op opts out
- * (`stamp: false`, only the `metadata` envelope), with `type` / `time`
- * stripped back out on replay. Ops declared `persist: false` apply and notify
- * like any other but never reach the emission stream or the log — the on-disk
- * record vocabulary stays exactly v1's. After each op, cross-model reducers
- * registered via `defineModel(..., { reducers })` (`MODEL_CROSS_REDUCERS`)
- * fold the op into foreign primary models on both dispatch and replay.
- *
- * Blob handling is driven by each `ModelDef`'s optional `blobs` codec
- * (`ModelBlobCodec`), which declares two symmetric directions:
- *
- * - **Dehydrate (dispatch → persist)**: `model.blobs.dehydrate(record, transform)`
- *   lets the model traverse its own record structure, pass each `ContentPart[]`
- *   through `transform` (which offloads oversized inline data to blob storage),
- *   and return the transformed record. `apply` and the live emission still see
- *   the original inline payload. Records whose model has no `blobs` codec
- *   short-circuit synchronously (no queue, no microtask).
- *
- * - **Rehydrate (replay → model)**: after all records are applied,
- *   `rehydrateModels` calls `model.blobs.rehydrate(state, transform)` on each
- *   model that declares a `blobs` codec, replacing blobref URLs with inline data
- *   *only* in the surviving final state — skipping I/O for data later removed by
- *   compaction (a 20×+ speedup for long sessions with many images).
- *
- * Scope-agnostic.
- */
-
-import { Disposable, toDisposable, type IDisposable } from '#/_base/di/lifecycle';
-import { onUnexpectedError } from '#/_base/errors/unexpectedError';
-import { Emitter } from '#/_base/event';
-import { IAgentBlobService } from '#/agent/blob/agentBlobService';
-import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
-import type { ContentPart } from '#/app/llmProtocol/message';
-import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
-
-import { WireError, WireErrors } from './errors';
-import type { DeepReadonly, DerivedModelDef, ModelDef, PartsTransformer } from './model';
-import { MODEL_CROSS_REDUCERS } from './model';
-import type { Op } from './op';
-import { OP_REGISTRY } from './op';
-import type {
-  IWireService,
-  ModelChange,
-  OpGroup,
-  PersistedRecord,
-  ReplayResult,
-  WireEmission,
-} from './wireService';
-
-const MAX_DRAIN = 100;
-
-export class CycleError extends WireError {
-  constructor(readonly depth: number, readonly opTypes: readonly string[]) {
-    super(
-      WireErrors.codes.WIRE_CYCLE,
-      `Wire dispatch cascade exceeded MAX_DRAIN (${depth}); possible op cycle`,
-      {
-        details: { depth, opTypes: opTypes.slice(0, 20) },
-      },
-    );
-    this.name = 'CycleError';
-  }
-}
-
-export interface WireServiceOptions {
-  readonly logScope: string;
-  readonly logKey: string;
-}
-
-interface ModelInstance {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  state: any;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  emitter: Emitter<ModelChange<any>>;
-}
-
-interface ReducerEntry {
-  readonly inst: ModelInstance;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  readonly reducer: (state: any, payload: any) => any;
-}
-
-export class WireService extends Disposable implements IWireService {
-  declare readonly _serviceBrand: undefined;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly models = new Map<ModelDef<any>, ModelInstance>();
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly derivedModels = new Map<DerivedModelDef<any>, ModelInstance>();
-  private readonly reducerIndex = new Map<string, ReducerEntry[]>();
-  private readonly emissionEmitter = this._register(new Emitter<WireEmission>());
-  private readonly restoredHandlers = new Set<() => void | Promise<void>>();
-
-  private dispatching = false;
-  private queue: Op[] = [];
-  private drainDepth = 0;
-  private persistQueue: Promise<void> = Promise.resolve();
-
-  constructor(
-    private readonly options: WireServiceOptions,
-    @IAppendLogStore private readonly log?: IAppendLogStore,
-    @IAgentBlobService private readonly blobService?: IAgentBlobService,
-    @IEventBus private readonly eventBus?: IEventBus,
-  ) {
-    super();
-    if (this.log !== undefined) {
-      this._register(this.log.acquire(this.options.logScope, this.options.logKey));
-    }
-  }
-
-  getModel<S>(model: ModelDef<S> | DerivedModelDef<S>): DeepReadonly<S> {
-    if ('reducers' in model) {
-      const inst = this.derivedModels.get(model);
-      return (inst?.state ?? Object.freeze(model.initial())) as DeepReadonly<S>;
-    }
-    return this.ensureModel(model).state as DeepReadonly<S>;
-  }
-
-  subscribe<S>(
-    model: ModelDef<S> | DerivedModelDef<S>,
-    handler: (state: DeepReadonly<S>, prev: DeepReadonly<S>) => void,
-  ): IDisposable {
-    const inst = 'reducers' in model
-      ? this.derivedModels.get(model)
-      : this.ensureModel(model);
-    if (inst === undefined) return { dispose: () => {} };
-    return inst.emitter.event((change) =>
-      handler(change.state as DeepReadonly<S>, change.prev as DeepReadonly<S>),
-    );
-  }
-
-  onEmission(handler: (emission: WireEmission) => void): IDisposable {
-    return this.emissionEmitter.event(handler);
-  }
-
-  onRestored(handler: () => void | Promise<void>): IDisposable {
-    this.restoredHandlers.add(handler);
-    return toDisposable(() => this.restoredHandlers.delete(handler));
-  }
-
-  attach<S>(model: DerivedModelDef<S>): IDisposable {
-    const inst: ModelInstance = {
-      state: Object.freeze(model.initial()),
-      emitter: new Emitter<ModelChange<unknown>>(),
-    };
-    this._register(inst.emitter);
-    this.derivedModels.set(model, inst);
-
-    for (const [opType, reducer] of Object.entries(model.reducers)) {
-      if (reducer === undefined) continue;
-      let list = this.reducerIndex.get(opType);
-      if (list === undefined) {
-        list = [];
-        this.reducerIndex.set(opType, list);
-      }
-      list.push({ inst, reducer });
-    }
-
-    return {
-      dispose: () => {
-        this.derivedModels.delete(model);
-        for (const [opType, list] of this.reducerIndex) {
-          const filtered = list.filter((e) => e.inst !== inst);
-          if (filtered.length === 0) {
-            this.reducerIndex.delete(opType);
-          } else if (filtered.length !== list.length) {
-            this.reducerIndex.set(opType, filtered);
-          }
-        }
-      },
-    };
-  }
-
-  dispatch(...ops: Op[]): void {
-    if (ops.length === 0) return;
-    if (this.dispatching) {
-      this.queue.push(...ops);
-      return;
-    }
-    this.dispatching = true;
-    try {
-      this.execute({ ops, silent: false });
-      while (this.queue.length > 0) {
-        if (++this.drainDepth > MAX_DRAIN) {
-          throw new CycleError(this.drainDepth, this.queue.map((op) => op.type));
-        }
-        this.execute({ ops: this.queue.splice(0), silent: false });
-      }
-    } finally {
-      this.queue.length = 0;
-      this.dispatching = false;
-      this.drainDepth = 0;
-    }
-  }
-
-  async replay(...records: PersistedRecord[]): Promise<ReplayResult> {
-    const ops: Op[] = [];
-    let unknownRecords = 0;
-    for (let index = 0; index < records.length; index++) {
-      const record = records[index]!;
-      const descriptor = OP_REGISTRY.get(record.type);
-      if (descriptor === undefined) {
-        unknownRecords++;
-        onUnexpectedError(
-          new WireError(
-            WireErrors.codes.WIRE_UNKNOWN_RECORD,
-            `Unknown wire record type '${record.type}' skipped during replay`,
-            { details: { type: record.type, index } },
-          ),
-        );
-        continue;
-      }
-      ops.push({ type: record.type, payload: recordToPayload(record), descriptor });
-    }
-    this.execute({ ops, silent: true });
-    await this.rehydrateModels();
-    await this.fireRestored();
-    return { unknownRecords };
-  }
-
-  async flush(): Promise<void> {
-    await this.persistQueue;
-    await this.log?.flush();
-  }
-
-  private execute(group: OpGroup): void {
-    const changes: { inst: ModelInstance; change: ModelChange<unknown> }[] = [];
-
-    for (const op of group.ops) {
-      const inst = this.ensureModel(op.descriptor.model);
-      const prev = inst.state;
-      inst.state = Object.freeze(op.descriptor.apply(prev, op.payload));
-      if (!group.silent) {
-        if (op.descriptor.persist !== false) {
-          const record = this.toRecord(op);
-          this.emissionEmitter.fire({ type: 'record', record });
-          this.appendToWireLog(record, op.descriptor.model);
-        }
-        const event = op.descriptor.toEvent?.(op.payload, inst.state);
-        if (event !== undefined && this.eventBus !== undefined) {
-          this.eventBus.publish(event as DomainEvent);
-        }
-      }
-      if (inst.state !== prev) {
-        changes.push({ inst, change: { state: inst.state, prev } });
-      }
-
-      const entries = this.reducerIndex.get(op.type);
-      if (entries !== undefined) {
-        for (const entry of entries) {
-          const dPrev = entry.inst.state;
-          entry.inst.state = Object.freeze(entry.reducer(dPrev, op.payload));
-          if (entry.inst.state !== dPrev) {
-            changes.push({ inst: entry.inst, change: { state: entry.inst.state, prev: dPrev } });
-          }
-        }
-      }
-
-      const crossReducers = MODEL_CROSS_REDUCERS.get(op.type);
-      if (crossReducers !== undefined) {
-        for (const entry of crossReducers) {
-          if (entry.model === op.descriptor.model) continue;
-          const crossInst = this.ensureModel(entry.model);
-          const crossPrev = crossInst.state;
-          crossInst.state = Object.freeze(entry.reducer(crossPrev, op.payload));
-          if (crossInst.state !== crossPrev) {
-            changes.push({
-              inst: crossInst,
-              change: { state: crossInst.state, prev: crossPrev },
-            });
-          }
-        }
-      }
-    }
-
-    if (!group.silent) {
-      for (const { inst, change } of changes) {
-        inst.emitter.fire(change);
-      }
-    }
-  }
-
-  private ensureModel<S>(def: ModelDef<S>): ModelInstance {
-    let inst = this.models.get(def);
-    if (inst === undefined) {
-      inst = {
-        state: Object.freeze(def.initial()),
-        emitter: new Emitter<ModelChange<unknown>>(),
-      };
-      this._register(inst.emitter);
-      this.models.set(def, inst);
-    }
-    return inst;
-  }
-
-  private toRecord(op: Op): PersistedRecord {
-    const payload = op.payload;
-    const record: Record<string, unknown> =
-      payload !== null && typeof payload === 'object' && !Array.isArray(payload)
-        ? { type: op.type, ...(payload as Record<string, unknown>) }
-        : { type: op.type, payload };
-    if (op.descriptor.stamp !== false && record['time'] === undefined) {
-      record['time'] = Date.now();
-    }
-    return record as PersistedRecord;
-  }
-
-  private async fireRestored(): Promise<void> {
-    for (const handler of Array.from(this.restoredHandlers)) {
-      try {
-        await handler();
-      } catch (error) {
-        onUnexpectedError(error);
-      }
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private appendToWireLog(record: PersistedRecord, model: ModelDef<any>): void {
-    if (this.log === undefined) return;
-    if (this.blobService === undefined) {
-      this.log.append(this.options.logScope, this.options.logKey, record, {
-        onError: onUnexpectedError,
-      });
-      return;
-    }
-    const dehydrate = model.blobs?.dehydrate?.bind(model.blobs);
-    const transform: PartsTransformer = (parts) =>
-      this.blobService!.offloadParts(
-        parts as readonly ContentPart[],
-      ) as Promise<readonly unknown[]>;
-    this.persistQueue = this.persistQueue
-      .then(async () => {
-        let out = record;
-        if (dehydrate !== undefined) {
-          const prepared = dehydrate(record, transform);
-          out = isPromise(prepared) ? await prepared : prepared;
-        }
-        this.log?.append(this.options.logScope, this.options.logKey, out, {
-          onError: onUnexpectedError,
-        });
-      })
-      .catch((error: unknown) => onUnexpectedError(error));
-  }
-
-  private async rehydrateModels(): Promise<void> {
-    if (this.blobService === undefined) return;
-    const transform: PartsTransformer = (parts) =>
-      this.blobService!.loadParts(
-        parts as readonly ContentPart[],
-      ) as Promise<readonly unknown[]>;
-    for (const [def, inst] of this.models) {
-      if (def.blobs?.rehydrate === undefined) continue;
-      const result = def.blobs.rehydrate(inst.state, transform);
-      inst.state = Object.freeze(isPromise(result) ? await result : result);
-    }
-    for (const [def, inst] of this.derivedModels) {
-      if (def.blobs?.rehydrate === undefined) continue;
-      const result = def.blobs.rehydrate(inst.state, transform);
-      inst.state = Object.freeze(isPromise(result) ? await result : result);
-    }
-  }
-}
-
-function recordToPayload(record: PersistedRecord): unknown {
-  const payload: Record<string, unknown> = {};
-  for (const key of Object.keys(record)) {
-    if (key === 'type' || key === 'time') continue;
-    payload[key] = record[key];
-  }
-  return payload;
-}
-
-function isPromise<T>(value: T | Promise<T>): value is Promise<T> {
-  return value !== null && typeof (value as Promise<T>).then === 'function';
-}
diff --git a/packages/agent-core-v2/test/_base/utils/tokens.test.ts b/packages/agent-core-v2/test/_base/utils/tokens.test.ts
index a633022e7..f18bac364 100644
--- a/packages/agent-core-v2/test/_base/utils/tokens.test.ts
+++ b/packages/agent-core-v2/test/_base/utils/tokens.test.ts
@@ -86,10 +86,12 @@ describe('estimateTokens character-class calibration', () => {
 
   const legacyEstimate = (text: string): number => {
     let ascii = 0;
+    let total = 0;
     for (const char of text) {
+      total += 1;
       if (char.codePointAt(0)! <= 127) ascii += 1;
     }
-    return Math.ceil(ascii / 4) + ([...text].length - ascii);
+    return Math.ceil(ascii / 4) + (total - ascii);
   };
 
   it('returns zero for empty text and at least one token for non-empty text', () => {
diff --git a/packages/agent-core-v2/test/activity/activity.test.ts b/packages/agent-core-v2/test/activity/activity.test.ts
deleted file mode 100644
index 7b42328bc..000000000
--- a/packages/agent-core-v2/test/activity/activity.test.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-/**
- * `activity` kernel unit tests — drives the real `AgentActivityService` with a
- * stub Session kernel and an in-memory wire service.
- *
- * Asserts the PR1 turn-lane contract: `begin` admits a turn and rejects a
- * concurrent one with `activity.agent_busy`, `cancel` moves the lane to
- * `turn(ending)` and aborts the lease signal, and `lease.end` returns the lane
- * to `idle` (idempotently). Run:
- * `pnpm test -- test/activity/activity.test.ts`
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { DisposableStore } from '#/_base/di/lifecycle';
-import { LifecycleScope } from '#/_base/di/scope';
-import { createScopedTestHost, createServices, TestInstantiationService } from '#/_base/di/test';
-import { IAgentActivityService, ISessionActivityKernel } from '#/activity/activity';
-import type { ActivityLease } from '#/activity/activity';
-import { AgentActivityService } from '#/activity/agentActivityService';
-import { SessionActivityKernel } from '#/activity/sessionActivityKernel';
-import { IAgentScopeContext, makeAgentScopeContext } from '#/agent/scopeContext/scopeContext';
-import { ErrorCodes } from '#/errors';
-import { IAgentWireService, ISessionWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
-
-import { stubSessionActivityKernel } from './stubs';
-
-describe('AgentActivityService (turn lane)', () => {
-  let disposables: DisposableStore;
-  let ix: TestInstantiationService;
-  let activity: IAgentActivityService;
-
-  beforeEach(() => {
-    disposables = new DisposableStore();
-    ix = createServices(disposables, {
-      additionalServices: (reg) => {
-        reg.defineInstance(
-          IAgentWireService,
-          disposables.add(new WireService({ logScope: 'wire', logKey: 'activity' })),
-        );
-        reg.defineInstance(ISessionActivityKernel, stubSessionActivityKernel());
-        reg.defineInstance(
-          IAgentScopeContext,
-          makeAgentScopeContext({ agentId: 'agent', agentScope: 'agent' }),
-        );
-        reg.define(IAgentActivityService, AgentActivityService);
-      },
-    });
-    activity = ix.get(IAgentActivityService);
-  });
-
-  afterEach(() => {
-    disposables.dispose();
-  });
-
-  it('starts initializing and admits a turn only after markReady', () => {
-    expect(activity.lane()).toBe('initializing');
-    expect(() => activity.begin('turn')).toThrowError(
-      expect.objectContaining({ code: ErrorCodes.ACTIVITY_INITIALIZING }),
-    );
-    activity.markReady();
-    expect(activity.lane()).toBe('idle');
-    const lease: ActivityLease = activity.begin('turn');
-    expect(lease.kind).toBe('turn');
-    expect(lease.signal.aborted).toBe(false);
-    expect(activity.lane()).toBe('turn');
-    lease.end('completed');
-    expect(activity.lane()).toBe('idle');
-  });
-
-  it('rejects a concurrent begin with activity.agent_busy', () => {
-    activity.markReady();
-    const lease = activity.begin('turn');
-    expect(() => activity.begin('turn')).toThrowError(
-      expect.objectContaining({ code: ErrorCodes.ACTIVITY_AGENT_BUSY }),
-    );
-    lease.end('completed');
-  });
-
-  it('tryBegin returns undefined when busy', () => {
-    activity.markReady();
-    const lease = activity.begin('turn');
-    expect(activity.tryBegin('turn')).toBeUndefined();
-    lease.end('completed');
-  });
-
-  it('cancel aborts the lease signal and keeps the lane until end', () => {
-    activity.markReady();
-    const lease = activity.begin('turn');
-    expect(activity.cancel('stop')).toBe(true);
-    expect(lease.signal.aborted).toBe(true);
-    expect(lease.ending).toBe(true);
-    expect(activity.lane()).toBe('turn');
-    lease.end('cancelled');
-    expect(activity.lane()).toBe('idle');
-  });
-
-  it('cancel is a no-op when idle', () => {
-    activity.markReady();
-    expect(activity.cancel()).toBe(false);
-  });
-
-  it('lease.end is idempotent', () => {
-    activity.markReady();
-    const lease = activity.begin('turn');
-    lease.end('completed');
-    expect(() => lease.end('completed')).not.toThrow();
-    expect(activity.lane()).toBe('idle');
-  });
-
-  it('beginDisposal aborts the in-flight lease and settles after end', async () => {
-    activity.markReady();
-    const lease = activity.begin('turn');
-    activity.beginDisposal();
-    expect(lease.signal.aborted).toBe(true);
-    expect(activity.lane()).toBe('disposing');
-    const settled = activity.settled();
-    lease.end('cancelled');
-    await settled;
-    expect(activity.lane()).toBe('disposed');
-  });
-});
-
-describe('SessionActivityKernel (session lane)', () => {
-  let host: ReturnType<typeof createScopedTestHost>;
-  let kernel: ISessionActivityKernel;
-
-  function stubWire(): IWireService {
-    return {
-      _serviceBrand: undefined,
-      dispatch: () => undefined,
-      replay: () => Promise.resolve(),
-      flush: () => Promise.resolve(),
-      attach: () => ({ dispose: () => undefined }),
-      getModel: (model: { initial: () => unknown }) => model.initial(),
-      subscribe: () => ({ dispose: () => undefined }),
-      onEmission: () => ({ dispose: () => undefined }),
-      onRestored: () => ({ dispose: () => undefined }),
-    } as unknown as IWireService;
-  }
-
-  beforeEach(() => {
-    host = createScopedTestHost();
-    const session = host.child(LifecycleScope.Session, 'session', [
-      [ISessionWireService, stubWire()],
-    ]);
-    kernel = session.accessor.get(ISessionActivityKernel);
-  });
-
-  afterEach(() => {
-    host.dispose();
-  });
-
-  function fakeLease(turnId: number): ActivityLease {
-    return {
-      kind: 'turn',
-      turnId,
-      origin: { kind: 'user' },
-      signal: new AbortController().signal,
-      ending: false,
-      end: () => undefined,
-    };
-  }
-
-  it('starts restoring and only admits agent.create until active', () => {
-    expect(kernel.lane()).toBe('restoring');
-    expect(kernel.canAccept('agent.create')).toBe(true);
-    expect(kernel.canAccept('turn.begin')).toBe(false);
-    expect(kernel.canAccept('session.fork')).toBe(false);
-    kernel.markActive();
-    expect(kernel.lane()).toBe('active');
-    expect(kernel.canAccept('turn.begin')).toBe(true);
-  });
-
-  it('admitTurn rejects while restoring and registers while active', () => {
-    expect(() => kernel.admitTurn('agent', fakeLease(1))).toThrowError(
-      expect.objectContaining({ code: ErrorCodes.ACTIVITY_SESSION_REJECTED }),
-    );
-    kernel.markActive();
-    const reg = kernel.admitTurn('agent', fakeLease(1));
-    reg.dispose();
-  });
-
-  it('quiesce flips to quiescing and restores to active on dispose', async () => {
-    kernel.markActive();
-    const lease = await kernel.quiesce('fork');
-    expect(kernel.lane()).toBe('quiescing');
-    expect(kernel.canAccept('turn.begin')).toBe(false);
-    lease.dispose();
-    expect(kernel.lane()).toBe('active');
-  });
-
-  it('quiesce waits for in-flight leases to drain', async () => {
-    kernel.markActive();
-    const reg = kernel.admitTurn('agent', fakeLease(1));
-    let resolved = false;
-    const pending = kernel.quiesce('fork').then((lease) => {
-      resolved = true;
-      return lease;
-    });
-    await Promise.resolve();
-    expect(resolved).toBe(false);
-    reg.dispose();
-    const lease = await pending;
-    expect(resolved).toBe(true);
-    expect(kernel.lane()).toBe('quiescing');
-    lease.dispose();
-  });
-});
diff --git a/packages/agent-core-v2/test/activity/stubs.ts b/packages/agent-core-v2/test/activity/stubs.ts
deleted file mode 100644
index 81de9bfd5..000000000
--- a/packages/agent-core-v2/test/activity/stubs.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * `activity` test stubs — shared `ISessionActivityKernel` stubs for unit tests.
- *
- * Lives under `test/` (not `src/`) so test-support code stays out of the
- * production tree. Import from a relative path. The default stub admits every
- * turn (`active` lane), mirroring the PR1 placeholder Session kernel so
- * Agent-scope unit tests can construct the real `AgentActivityService` without
- * a Session scope tree.
- */
-
-import type { IDisposable } from '#/_base/di/lifecycle';
-import type {
-  ActivityLease,
-  ISessionActivityKernel,
-  SessionCommand,
-  SessionLane,
-  SessionQuiesceLease,
-} from '#/activity/activity';
-
-export function stubSessionActivityKernel(
-  lane: SessionLane = 'active',
-): ISessionActivityKernel {
-  let currentLane: SessionLane = lane;
-  const leases = new Set<ActivityLease>();
-  return {
-    _serviceBrand: undefined,
-    lane: () => currentLane,
-    canAccept: (_command: SessionCommand) => currentLane === 'active',
-    admitTurn(_agentId: string, lease: ActivityLease): IDisposable {
-      leases.add(lease);
-      return { dispose: () => leases.delete(lease) };
-    },
-    quiesce: (reason: string): Promise<SessionQuiesceLease> =>
-      Promise.resolve({ reason, dispose: () => undefined }),
-    beginClosing: () => {
-      currentLane = 'closing';
-    },
-    settled: () => Promise.resolve(),
-    markActive: () => {
-      if (currentLane === 'restoring') currentLane = 'active';
-    },
-  };
-}
diff --git a/packages/agent-core-v2/test/agent/activityView/activityView.test.ts b/packages/agent-core-v2/test/agent/activityView/activityView.test.ts
new file mode 100644
index 000000000..11d2cc0a2
--- /dev/null
+++ b/packages/agent-core-v2/test/agent/activityView/activityView.test.ts
@@ -0,0 +1,172 @@
+/**
+ * `AgentActivityView` — the folded read model: turn slice, lastTurn memory,
+ * and the background-work busy layer (seeded from task and compaction owners,
+ * folded from their lifecycle events).
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { SyncDescriptor } from '#/_base/di/descriptors';
+import { DisposableStore, type IDisposable } from '#/_base/di/lifecycle';
+import { TestInstantiationService } from '#/_base/di/test';
+import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
+import { IAgentLoopService } from '#/agent/loop/loop';
+import { IAgentTaskService } from '#/agent/task/task';
+import type { AgentTaskInfo } from '#/agent/task/types';
+import { AgentActivityView } from '#/agent/activityView/activityViewService';
+import { IAgentActivityView, type AgentActivityState } from '#/agent/activityView/activityView';
+import {
+  IAgentFullCompactionService,
+  type FullCompactionTask,
+} from '#/agent/fullCompaction/fullCompaction';
+
+class FakeBus {
+  private readonly byType = new Map<string, Array<(e: DomainEvent) => void>>();
+  private readonly all: Array<(e: DomainEvent) => void> = [];
+  readonly published: DomainEvent[] = [];
+
+  publish(event: DomainEvent): void {
+    this.published.push(event);
+    for (const h of this.all) h(event);
+    for (const h of this.byType.get(event.type) ?? []) h(event);
+  }
+
+  subscribe(type: unknown, handler?: unknown): IDisposable {
+    if (typeof type === 'function') {
+      this.all.push(type as (e: DomainEvent) => void);
+      return { dispose: () => {} };
+    }
+    const list = this.byType.get(type as string) ?? [];
+    list.push(handler as (e: DomainEvent) => void);
+    this.byType.set(type as string, list);
+    return { dispose: () => {} };
+  }
+}
+
+function makeTaskInfo(taskId: string): AgentTaskInfo {
+  return {
+    taskId,
+    kind: 'process',
+    description: 'sleep 60',
+    status: 'running',
+    startedAt: 100,
+    endedAt: null,
+    command: 'sleep 60',
+    pid: 4242,
+    exitCode: null,
+  };
+}
+
+let disposables: DisposableStore;
+
+function harness(
+  seedTasks: readonly AgentTaskInfo[] = [],
+  compacting: FullCompactionTask | null = null,
+) {
+  const bus = new FakeBus();
+  const loop = {
+    status: () => ({ state: 'idle', pendingTurnIds: [], hasPendingRequests: false }),
+  } as unknown as IAgentLoopService;
+  const tasks = { list: () => seedTasks } as unknown as IAgentTaskService;
+  const ix = disposables.add(new TestInstantiationService());
+  ix.stub(IEventBus, bus as unknown as IEventBus);
+  ix.stub(IAgentLoopService, loop);
+  ix.stub(IAgentTaskService, tasks);
+  ix.stub(IAgentFullCompactionService, {
+    _serviceBrand: undefined,
+    compacting,
+  } as unknown as IAgentFullCompactionService);
+  ix.set(IAgentActivityView, new SyncDescriptor(AgentActivityView));
+  const view = ix.get(IAgentActivityView);
+  const updates = (): AgentActivityState[] =>
+    bus.published
+      .filter((e) => e.type === 'agent.activity.updated')
+      .map((e) => e as unknown as AgentActivityState);
+  return { bus, view, updates };
+}
+
+describe('AgentActivityView', () => {
+  beforeEach(() => {
+    disposables = new DisposableStore();
+  });
+
+  afterEach(() => {
+    disposables.dispose();
+  });
+
+  it('starts with an empty, not-busy snapshot', () => {
+    const { view } = harness();
+    expect(view.state()).toEqual({ lifecycle: 'ready', background: [] });
+  });
+
+  it('folds task.started / task.terminated into the background slice', () => {
+    const { bus, view, updates } = harness();
+
+    bus.publish({ type: 'task.started', info: makeTaskInfo('bash-1') });
+    expect(view.state().background).toEqual([{ kind: 'process', id: 'bash-1', since: 100 }]);
+    expect(updates().at(-1)?.background).toHaveLength(1);
+
+    bus.publish({ type: 'task.terminated', info: makeTaskInfo('bash-1') });
+    expect(view.state().background).toEqual([]);
+    expect(updates().at(-1)?.background).toHaveLength(0);
+  });
+
+  it('seeds the background slice from the task registry on creation', () => {
+    const { view } = harness([makeTaskInfo('bash-9')]);
+    expect(view.state().background).toEqual([{ kind: 'process', id: 'bash-9', since: 100 }]);
+  });
+
+  it('folds full compaction into the background slice', () => {
+    const { bus, view } = harness();
+
+    bus.publish({ type: 'compaction.started', trigger: 'manual' });
+    expect(view.state().background).toEqual([
+      expect.objectContaining({ kind: 'compaction', id: 'full-compaction' }),
+    ]);
+
+    bus.publish({ type: 'compaction.cancelled' });
+    expect(view.state().background).toEqual([]);
+  });
+
+  it('seeds an in-flight full compaction on creation', () => {
+    const compacting: FullCompactionTask = {
+      abortController: new AbortController(),
+      promise: new Promise(() => {}),
+      trigger: 'manual',
+      tokenCount: 100,
+    };
+
+    const { view } = harness([], compacting);
+
+    expect(view.state().background).toEqual([
+      expect.objectContaining({ kind: 'compaction', id: 'full-compaction' }),
+    ]);
+  });
+
+  it('folds turn boundaries into turn / lastTurn', () => {
+    const { bus, view } = harness();
+
+    bus.publish({ type: 'turn.started', turnId: 1, origin: { kind: 'user' } });
+    expect(view.state().turn?.turnId).toBe(1);
+
+    bus.publish({ type: 'turn.ended', turnId: 1, reason: 'completed' });
+    expect(view.state().turn).toBeUndefined();
+    expect(view.state().lastTurn).toMatchObject({ turnId: 1, reason: 'completed' });
+  });
+
+  it('clears the previous outcome when a new turn starts', () => {
+    const { bus, view } = harness();
+
+    bus.publish({ type: 'turn.started', turnId: 1, origin: { kind: 'user' } });
+    bus.publish({ type: 'turn.ended', turnId: 1, reason: 'cancelled' });
+    expect(view.state().lastTurn).toMatchObject({ turnId: 1, reason: 'cancelled' });
+
+    // While the next turn runs there is no current outcome; turn.ended
+    // publishes the fresh one.
+    bus.publish({ type: 'turn.started', turnId: 2, origin: { kind: 'user' } });
+    expect(view.state().lastTurn).toBeUndefined();
+
+    bus.publish({ type: 'turn.ended', turnId: 2, reason: 'completed' });
+    expect(view.state().lastTurn).toMatchObject({ turnId: 2, reason: 'completed' });
+  });
+});
diff --git a/packages/agent-core-v2/test/agent/contextInjector/contextInjector.test.ts b/packages/agent-core-v2/test/agent/contextInjector/contextInjector.test.ts
index fbe474552..eb748ba94 100644
--- a/packages/agent-core-v2/test/agent/contextInjector/contextInjector.test.ts
+++ b/packages/agent-core-v2/test/agent/contextInjector/contextInjector.test.ts
@@ -23,7 +23,7 @@ import { IAgentProfileService } from '#/agent/profile/profile';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
 import { AgentSystemReminderService } from '#/agent/systemReminder/systemReminderService';
 import { IEventBus } from '#/app/event/eventBus';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 import { registerContextMemoryServices, type StubContextMemory } from '../contextMemory/stubs';
 import { stubLoopWithHooks, stubWire } from '../loop/stubs';
 
@@ -71,7 +71,7 @@ describe('AgentContextInjectorService', () => {
       strict: true,
       additionalServices: (reg) => {
         reg.defineInstance(IAgentLoopService, stubLoopWithHooks());
-        reg.defineInstance(IAgentWireService, stubWire());
+        reg.defineInstance(IWireService, stubWire());
         reg.define(IAgentSystemReminderService, AgentSystemReminderService);
         reg.define(IAgentContextInjectorService, AgentContextInjectorService);
       },
diff --git a/packages/agent-core-v2/test/agent/contextMemory/context.test.ts b/packages/agent-core-v2/test/agent/contextMemory/context.test.ts
index 604cd8b21..a7e67bb44 100644
--- a/packages/agent-core-v2/test/agent/contextMemory/context.test.ts
+++ b/packages/agent-core-v2/test/agent/contextMemory/context.test.ts
@@ -3,8 +3,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { estimateTokensForMessages } from '#/_base/utils/tokens';
 import type { ContextMessage } from '#/agent/contextMemory/types';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { IWireService } from '#/wire/wire';
 import {
   IAgentContextMemoryService,
   IAgentContextSizeService,
@@ -25,7 +24,7 @@ describe('Agent context', () => {
     context = ctx.get(IAgentContextMemoryService);
     contextSize = ctx.get(IAgentContextSizeService);
     profile = ctx.get(IAgentProfileService);
-    wire = ctx.get(IAgentWireService);
+    wire = ctx.get(IWireService);
   });
 
   afterEach(async () => {
diff --git a/packages/agent-core-v2/test/agent/contextMemory/contextTranscript.test.ts b/packages/agent-core-v2/test/agent/contextMemory/contextTranscript.test.ts
index 4cc538b2c..d6e2170d7 100644
--- a/packages/agent-core-v2/test/agent/contextMemory/contextTranscript.test.ts
+++ b/packages/agent-core-v2/test/agent/contextMemory/contextTranscript.test.ts
@@ -14,7 +14,7 @@ import {
 } from '#/agent/contextMemory/contextTranscript';
 import type { LoopRecordedEvent } from '#/agent/contextMemory/loopEventFold';
 import type { ContextMessage, PromptOrigin } from '#/agent/contextMemory/types';
-import type { PersistedRecord } from '#/wire/wireService';
+import type { WireRecord } from '#/wire/record';
 
 function userMessage(text: string, origin?: PromptOrigin): ContextMessage {
   return {
@@ -29,15 +29,15 @@ function assistantMessage(text: string): ContextMessage {
   return { role: 'assistant', content: [{ type: 'text', text }], toolCalls: [] };
 }
 
-function appendMessage(message: ContextMessage): PersistedRecord {
+function appendMessage(message: ContextMessage): WireRecord {
   return { type: 'context.append_message', message };
 }
 
-function loopEvent(event: LoopRecordedEvent): PersistedRecord {
+function loopEvent(event: LoopRecordedEvent): WireRecord {
   return { type: 'context.append_loop_event', event };
 }
 
-function assistantStep(uuid: string, text: string): PersistedRecord[] {
+function assistantStep(uuid: string, text: string): WireRecord[] {
   return [
     loopEvent({ type: 'step.begin', uuid }),
     loopEvent({ type: 'content.part', stepUuid: uuid, part: { type: 'text', text } }),
@@ -50,7 +50,7 @@ function compaction(
   compactedCount: number,
   keptUserMessageCount?: number,
   keptHeadUserMessageCount?: number,
-): PersistedRecord {
+): WireRecord {
   return {
     type: 'context.apply_compaction',
     summary,
@@ -63,7 +63,7 @@ function compaction(
   };
 }
 
-function undo(count: number): PersistedRecord {
+function undo(count: number): WireRecord {
   return { type: 'context.undo', count };
 }
 
diff --git a/packages/agent-core-v2/test/agent/contextMemory/message-history.test.ts b/packages/agent-core-v2/test/agent/contextMemory/message-history.test.ts
index 7add9daff..80f4ba41b 100644
--- a/packages/agent-core-v2/test/agent/contextMemory/message-history.test.ts
+++ b/packages/agent-core-v2/test/agent/contextMemory/message-history.test.ts
@@ -6,12 +6,10 @@ import { TestInstantiationService } from '#/_base/di/test';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import type { ContextMessage } from '#/agent/contextMemory/types';
 import { AgentContextMemoryService } from '#/agent/contextMemory/contextMemoryService';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
 import { IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
-import { IAgentWireService } from '#/wire/tokens';
-import { WireService } from '#/wire/wireServiceImpl';
-import { stubWireRecord } from './stubs';
+
+import { registerTestAgentWire } from '../../wire/stubs';
 
 function textMessage(role: ContextMessage['role'], text: string): ContextMessage {
   return {
@@ -35,9 +33,8 @@ describe('message history (IAgentContextMemoryService)', () => {
   beforeEach(() => {
     disposables = new DisposableStore();
     ix = disposables.add(new TestInstantiationService());
-    ix.stub(IAgentWireRecordService, stubWireRecord());
-    ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: 'wire', logKey: 'message' }]));
     ix.set(IEventBus, new SyncDescriptor(EventBusService));
+    registerTestAgentWire(ix, 'wire/message-history', { eventBus: ix.get(IEventBus) });
     ix.set(IAgentContextMemoryService, new SyncDescriptor(AgentContextMemoryService));
   });
   afterEach(() => disposables.dispose());
diff --git a/packages/agent-core-v2/test/agent/contextMemory/splice-replay.test.ts b/packages/agent-core-v2/test/agent/contextMemory/splice-replay.test.ts
index d28f96552..676c58c5b 100644
--- a/packages/agent-core-v2/test/agent/contextMemory/splice-replay.test.ts
+++ b/packages/agent-core-v2/test/agent/contextMemory/splice-replay.test.ts
@@ -32,9 +32,10 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'ctx-live';
@@ -152,26 +153,25 @@ function buildHost(key: string): Host {
   const ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(
-    IAgentWireService,
-    new SyncDescriptor(WireService, [
-      { logScope: SCOPE, logKey: key },
-    ]),
-  );
   ix.stub(IAgentBlobService, blob);
   ix.set(IEventBus, new SyncDescriptor(EventBusService));
   ix.set(IAgentContextMemoryService, new SyncDescriptor(AgentContextMemoryService));
+  const wire = registerTestAgentWire(ix, testWireScope(SCOPE, key), {
+    log: ix.get(IAppendLogStore),
+    blob,
+    eventBus: ix.get(IEventBus),
+  });
   return {
-    wire: ix.get(IAgentWireService),
+    wire,
     svc: ix.get(IAgentContextMemoryService),
     log: ix.get(IAppendLogStore),
     eventBus: ix.get(IEventBus),
   };
 }
 
-async function readRecords(log: IAppendLogStore, key = KEY): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, key)) {
+async function readRecords(log: IAppendLogStore, key = KEY): Promise<WireRecord[]> {
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -236,7 +236,7 @@ describe('AgentContextMemoryService (wire-backed)', () => {
   });
 
   it('folds v1 context.append_loop_event records into the ContextModel on replay', async () => {
-    const records: PersistedRecord[] = [
+    const records: WireRecord[] = [
       { type: 'context.append_message', message: userMessage('q') },
       { type: 'context.append_loop_event', event: { type: 'step.begin', uuid: 's1', turnId: '0', step: 1 } },
       {
@@ -276,7 +276,12 @@ describe('AgentContextMemoryService (wire-backed)', () => {
     ];
 
     const replay = buildHost(REPLAY_KEY);
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, REPLAY_KEY),
+      records,
+    );
 
     const model = replay.wire.getModel(ContextModel) as readonly ContextMessage[];
     expect(model.map((message) => message.role)).toEqual(['user', 'assistant', 'tool']);
@@ -290,7 +295,7 @@ describe('AgentContextMemoryService (wire-backed)', () => {
   });
 
   it('replays v1 context.apply_compaction records with contextSummary as the model summary', async () => {
-    const records: PersistedRecord[] = [
+    const records: WireRecord[] = [
       { type: 'context.append_message', message: userMessage('old') },
       { type: 'context.append_message', message: userMessage('tail') },
       {
@@ -304,7 +309,12 @@ describe('AgentContextMemoryService (wire-backed)', () => {
     ];
 
     const replay = buildHost(REPLAY_KEY);
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, REPLAY_KEY),
+      records,
+    );
 
     const model = replay.wire.getModel(ContextModel) as readonly ContextMessage[];
     expect(model.map(textOf)).toEqual(['model-facing summary', 'tail']);
@@ -315,7 +325,7 @@ describe('AgentContextMemoryService (wire-backed)', () => {
   });
 
   it('replays new context.apply_compaction records with kept user messages before contextSummary', async () => {
-    const records: PersistedRecord[] = [
+    const records: WireRecord[] = [
       { type: 'context.append_message', message: userMessage('old user') },
       {
         type: 'context.append_message',
@@ -338,7 +348,12 @@ describe('AgentContextMemoryService (wire-backed)', () => {
     ];
 
     const replay = buildHost(REPLAY_KEY);
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, REPLAY_KEY),
+      records,
+    );
 
     const model = replay.wire.getModel(ContextModel) as readonly ContextMessage[];
     expect(model.map((message) => message.role)).toEqual(['user', 'user', 'user']);
@@ -349,7 +364,7 @@ describe('AgentContextMemoryService (wire-backed)', () => {
   });
 
   it('replays pre-contextSummary kept-user records without adding a new prefix', async () => {
-    const records: PersistedRecord[] = [
+    const records: WireRecord[] = [
       { type: 'context.append_message', message: userMessage('old user') },
       { type: 'context.append_message', message: userMessage('recent user') },
       {
@@ -363,7 +378,12 @@ describe('AgentContextMemoryService (wire-backed)', () => {
     ];
 
     const replay = buildHost(REPLAY_KEY);
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, REPLAY_KEY),
+      records,
+    );
 
     const model = replay.wire.getModel(ContextModel) as readonly ContextMessage[];
     expect(model.map(textOf)).toEqual(['old user', 'recent user', 'OLD SUMMARY']);
@@ -380,7 +400,7 @@ describe('AgentContextMemoryService (wire-backed)', () => {
       toolCalls: [],
       origin: { kind: 'compaction_summary' },
     };
-    const records: PersistedRecord[] = [
+    const records: WireRecord[] = [
       { type: 'context.append_message', message: userMessage('old') },
       { type: 'context.append_message', message: userMessage('tail') },
       {
@@ -391,7 +411,12 @@ describe('AgentContextMemoryService (wire-backed)', () => {
     ];
 
     const replay = buildHost(REPLAY_KEY);
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, REPLAY_KEY),
+      records,
+    );
 
     const model = replay.wire.getModel(ContextModel) as readonly ContextMessage[];
     expect(model).toHaveLength(2);
@@ -420,7 +445,12 @@ describe('AgentContextMemoryService (wire-backed)', () => {
     expect(mediaUrl(persisted)).not.toContain(big);
 
     const replay = buildHost(REPLAY_KEY);
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, REPLAY_KEY),
+      records,
+    );
     expect(blob.loadCalls).toBeGreaterThanOrEqual(1);
 
     const rebuilt = replay.wire.getModel(ContextModel) as readonly ContextMessage[];
@@ -446,7 +476,12 @@ describe('AgentContextMemoryService (wire-backed)', () => {
     disposables.add(replay.eventBus.subscribe('context.spliced', (event) => {
       replayed.push({ start: event.start, deleteCount: event.deleteCount });
     }));
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, REPLAY_KEY),
+      records,
+    );
     expect(replayed).toHaveLength(0);
     expect(replay.wire.getModel(ContextModel) as readonly ContextMessage[]).toHaveLength(2);
   });
diff --git a/packages/agent-core-v2/test/agent/contextMemory/stubs.ts b/packages/agent-core-v2/test/agent/contextMemory/stubs.ts
index 178b2f24e..ba6aef562 100644
--- a/packages/agent-core-v2/test/agent/contextMemory/stubs.ts
+++ b/packages/agent-core-v2/test/agent/contextMemory/stubs.ts
@@ -1,6 +1,6 @@
 /**
  * `contextMemory` test stubs — shared doubles for `IAgentContextMemoryService` and its
- * collaborator (`IAgentWireRecordService`).
+ * collaborator (`IWireService`).
  *
  * Lives under `test/` (not `src/`) so test-support code stays out of the
  * production tree. Import from a relative path (`./stubs` or
@@ -19,17 +19,9 @@ import type { LoopRecordedEvent } from '#/agent/contextMemory/loopEventFold';
 import type { ContextMessage } from '#/agent/contextMemory/types';
 import { IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { IWireService } from '#/wire/wire';
 
-export function stubWireRecord(): IAgentWireRecordService {
-  return {
-    _serviceBrand: undefined,
-    restore: () => Promise.resolve({}),
-    flush: () => Promise.resolve(),
-    close: () => Promise.resolve(),
-    getRecords: () => [],
-  };
-}
+import { stubAgentWire } from '../../wire/stubs';
 
 export interface StubContextMemory extends IAgentContextMemoryService {
   readonly messages: readonly ContextMessage[];
@@ -123,7 +115,7 @@ class StubContextMemoryService implements IAgentContextMemoryService {
 }
 
 export function registerContextMemoryServices(reg: ServiceRegistration): void {
-  reg.defineInstance(IAgentWireRecordService, stubWireRecord());
+  reg.defineInstance(IWireService, stubAgentWire());
   reg.define(IEventBus, EventBusService);
   reg.define(IAgentContextMemoryService, StubContextMemoryService);
 }
diff --git a/packages/agent-core-v2/test/agent/contextSize/contextSize.test.ts b/packages/agent-core-v2/test/agent/contextSize/contextSize.test.ts
index db54eb807..3d1f76be7 100644
--- a/packages/agent-core-v2/test/agent/contextSize/contextSize.test.ts
+++ b/packages/agent-core-v2/test/agent/contextSize/contextSize.test.ts
@@ -1,23 +1,35 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { estimateTokensForMessages } from '#/_base/utils/tokens';
+import { IAgentContextSizeService } from '#/agent/contextSize/contextSize';
+import { ContextSizeModel, contextSizeMeasured } from '#/agent/contextSize/contextSizeOps';
 import { IEventBus } from '#/app/event/eventBus';
 import type { Message } from '#/app/llmProtocol/message';
 import type { TokenUsage } from '#/app/llmProtocol/usage';
+import { IAgentUsageService } from '#/agent/usage/usage';
+import { IWireService } from '#/wire/wire';
 import {
   IAgentContextMemoryService,
   IAgentContextProjectorService,
-  IAgentContextSizeService,
+  IAgentProfileService,
 } from '#/index';
 
 import { createTestAgent, type TestAgentContext } from '../../harness';
 
+function totalOf(usage: TokenUsage | undefined): number {
+  if (usage === undefined) return 0;
+  return usage.inputOther + usage.output + usage.inputCacheRead + usage.inputCacheCreation;
+}
+
 describe('Agent context size', () => {
   let ctx: TestAgentContext;
   let context: IAgentContextMemoryService;
   let contextSize: IAgentContextSizeService;
   let projector: IAgentContextProjectorService;
   let eventBus: IEventBus;
+  let profile: IAgentProfileService;
+  let usage: IAgentUsageService;
+  let wire: IWireService;
   let raws: number[];
 
   /** The unfolded-request cost the status line should show, computed independently. */
@@ -34,6 +46,9 @@ describe('Agent context size', () => {
     contextSize = ctx.get(IAgentContextSizeService);
     projector = ctx.get(IAgentContextProjectorService);
     eventBus = ctx.get(IEventBus);
+    profile = ctx.get(IAgentProfileService);
+    usage = ctx.get(IAgentUsageService);
+    wire = ctx.get(IWireService);
     raws = [];
     eventBus.subscribe((event) => {
       const e = event as { type?: string; rawContextTokens?: number };
@@ -44,7 +59,11 @@ describe('Agent context size', () => {
   });
 
   afterEach(async () => {
-    await ctx.dispose();
+    try {
+      await ctx.expectResumeMatches();
+    } finally {
+      await ctx.dispose();
+    }
   });
 
   it('publishes the raw (unfolded) cost on every context mutation', () => {
@@ -81,17 +100,17 @@ describe('Agent context size', () => {
 
   it('keeps the measured prefix aligned with settled storage across a streamed step', () => {
     // The loop opens a partial assistant at `step.begin` and settles it with
-    // the response content after the request returns, so the trailing partial
-    // in the measured input and the output message are the same stored
-    // message. Counting it twice would park the measured prefix one past the
-    // stored context: the whole-context read would fall off the exact
-    // measured aggregate onto a per-message estimate until the next append
-    // caught the length up, and the footer gauge would swing between estimate
-    // and request caliber at every turn boundary.
+    // the response content after the request returns, so the live input array
+    // already includes the folded output when `measured()` runs. Counting the
+    // folded output again would park the measured prefix one past the stored
+    // context: the whole-context read would fall off the exact measured
+    // aggregate onto a per-message estimate until the next append caught the
+    // length up, and the footer gauge would swing between estimate and
+    // request caliber at every turn boundary.
     ctx.appendUserMessage([{ type: 'text', text: 'hello world '.repeat(20) }]);
     context.appendLoopEvent({ type: 'step.begin', uuid: 'step-1' });
 
-    const usage: TokenUsage = {
+    const tokenUsage: TokenUsage = {
       inputCacheRead: 0,
       inputCacheCreation: 0,
       inputOther: 20_000,
@@ -102,7 +121,9 @@ describe('Agent context size', () => {
       content: [{ type: 'text', text: 'answer '.repeat(40) }],
       toolCalls: [],
     };
-    contextSize.measured(context.get(), [response], usage);
+    // Mirrors the llmRequester call site: `input` is the live request array
+    // (already holding the fold-opened assistant), `output` is informational.
+    contextSize.measured(context.get(), [response], tokenUsage);
     context.appendLoopEvent({
       type: 'content.part',
       stepUuid: 'step-1',
@@ -124,4 +145,73 @@ describe('Agent context size', () => {
     expect(after.estimated).toBeGreaterThan(0);
     expect(after.size).toBe(after.measured + after.estimated);
   });
+
+  it('adopts the exchange totals as the measured context size after a turn', async () => {
+    profile.update({ activeToolNames: [] });
+
+    ctx.mockNextResponse({ type: 'text', text: 'Hi there!' });
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'hi' }] });
+    await ctx.untilTurnEnd();
+
+    const exchangeTotal = totalOf(usage.status().total);
+    expect(exchangeTotal).toBeGreaterThan(0);
+    expect(context.get()).toHaveLength(2);
+
+    // The assistant message is folded into the context before the exchange
+    // finishes, so the measured prefix must match the live history — an
+    // inflated length silently knocks `get()` off the measured path onto the
+    // per-message estimate branch (found as `tokenCount` reading ~50 while
+    // the provider reported ~29k for a system-prompt-heavy "hi").
+    expect(wire.getModel(ContextSizeModel)).toMatchObject({
+      length: context.get().length,
+      tokens: exchangeTotal,
+    });
+
+    const size = contextSize.get();
+    expect(size.measured).toBe(exchangeTotal);
+    expect(size.estimated).toBe(0);
+    expect(size.size).toBe(exchangeTotal);
+    expect((await ctx.rpc.getContext({})).tokenCount).toBe(exchangeTotal);
+  });
+
+  it('repoints the measured size at the last exchange across turns', async () => {
+    profile.update({ activeToolNames: [] });
+
+    ctx.mockNextResponse({ type: 'text', text: 'first' });
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'hi' }] });
+    await ctx.untilTurnEnd();
+
+    ctx.mockNextResponse({ type: 'text', text: 'second reply, a longer one' });
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'again' }] });
+    await ctx.untilTurnEnd();
+
+    const lastExchangeTotal = totalOf(usage.status().currentTurn);
+    expect(lastExchangeTotal).toBeGreaterThan(0);
+    expect(context.get()).toHaveLength(4);
+
+    expect(wire.getModel(ContextSizeModel)).toMatchObject({
+      length: context.get().length,
+      tokens: lastExchangeTotal,
+    });
+    expect(contextSize.get().measured).toBe(lastExchangeTotal);
+    expect((await ctx.rpc.getContext({})).tokenCount).toBe(lastExchangeTotal);
+  });
+
+  it('estimates the not-yet-measured tail instead of dropping it', () => {
+    ctx.appendUserMessage([{ type: 'text', text: 'hello world, not measured yet' }]);
+
+    const size = contextSize.get();
+    expect(size.measured).toBe(0);
+    expect(size.estimated).toBeGreaterThan(0);
+    expect(size.size).toBe(size.estimated);
+  });
+
+  it('tolerates a stored measured prefix longer than the live context', () => {
+    ctx.appendUserMessage([{ type: 'text', text: 'only one message' }]);
+
+    // A corrupt/overshooting record must not push reads onto the estimate
+    // branch; the measured total is clamped to the live context instead.
+    wire.dispatch(contextSizeMeasured({ length: 5, tokens: 1234 }));
+    expect(contextSize.get().measured).toBe(1234);
+  });
 });
diff --git a/packages/agent-core-v2/test/agent/fullCompaction/compactionOps.test.ts b/packages/agent-core-v2/test/agent/fullCompaction/compactionOps.test.ts
index f36d05d5b..167d5d656 100644
--- a/packages/agent-core-v2/test/agent/fullCompaction/compactionOps.test.ts
+++ b/packages/agent-core-v2/test/agent/fullCompaction/compactionOps.test.ts
@@ -15,9 +15,10 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'full-compaction-test';
@@ -30,9 +31,12 @@ function buildHost(key: string): { wire: IWireService; log: IAppendLogStore; eve
   const ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: key }]));
   ix.set(IEventBus, new SyncDescriptor(EventBusService));
-  return { wire: ix.get(IAgentWireService), log: ix.get(IAppendLogStore), eventBus: ix.get(IEventBus) };
+  const wire = registerTestAgentWire(ix, testWireScope(SCOPE, key), {
+    log: ix.get(IAppendLogStore),
+    eventBus: ix.get(IEventBus),
+  });
+  return { wire, log: ix.get(IAppendLogStore), eventBus: ix.get(IEventBus) };
 }
 
 beforeEach(() => {
@@ -44,9 +48,10 @@ beforeEach(() => {
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(key = KEY): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, key)) {
+async function readRecords(key = KEY): Promise<WireRecord[]> {
+  await wire.flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -97,7 +102,7 @@ describe('fullCompaction ops (wire-backed)', () => {
     expect(wire.getModel(CompactionModel)).toBe(running);
   });
 
-  it('replay rebuilds the phase silently (no emissions, no subscriber notifications)', async () => {
+  it('replay rebuilds the phase silently', async () => {
     wire.dispatch(fullCompactionBegin({ source: 'manual' }));
     wire.dispatch(fullCompactionComplete({}));
     const records = await readRecords();
@@ -107,27 +112,36 @@ describe('fullCompaction ops (wire-backed)', () => {
     host.eventBus.subscribe((e) => {
       emissions.push(e.type);
     });
-    let modelChanges = 0;
-    host.wire.subscribe(CompactionModel, () => {
-      modelChanges += 1;
-    });
-
-    await host.wire.replay(...records);
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'full-compaction-replay'),
+      records,
+    );
     expect(host.wire.getModel(CompactionModel).phase).toBe('idle');
     expect(emissions).toEqual([]);
-    expect(modelChanges).toBe(0);
 
     const stranded = buildHost('full-compaction-stranded');
-    await stranded.wire.replay({ type: 'full_compaction.begin', source: 'auto' });
+    await restoreTestAgentWire(
+      stranded.wire,
+      stranded.log,
+      testWireScope(SCOPE, 'full-compaction-stranded'),
+      [{ type: 'full_compaction.begin', source: 'auto' }],
+    );
     expect(stranded.wire.getModel(CompactionModel).phase).toBe('running');
   });
 
   it('replays legacy complete payloads that carried accounting numbers', async () => {
     const host = buildHost('full-compaction-legacy-complete-replay');
 
-    await host.wire.replay(
-      { type: 'full_compaction.begin', source: 'manual' },
-      { type: 'full_compaction.complete', compactedCount: 1, tokensBefore: 50, tokensAfter: 10 },
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'full-compaction-legacy-complete-replay'),
+      [
+        { type: 'full_compaction.begin', source: 'manual' },
+        { type: 'full_compaction.complete', compactedCount: 1, tokensBefore: 50, tokensAfter: 10 },
+      ],
     );
 
     expect(host.wire.getModel(CompactionModel).phase).toBe('idle');
diff --git a/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts b/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts
index c3389357b..05e362d0a 100644
--- a/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts
+++ b/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts
@@ -53,8 +53,8 @@ import { IAgentLoopService } from '#/agent/loop/loop';
 import { IAgentContextSizeService } from '#/agent/contextSize/contextSize';
 import type { ContextMessage } from '#/agent/contextMemory/types';
 import { ACCEPTED_OUTPUT } from '#/agent/spine/tools/controlResult';
-import { IAgentWireService } from '#/wire/tokens';
 import { IAgentGoalService } from '#/agent/goal/goal';
+import { IAgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContext';
 import { HostFileSystem } from '#/os/backends/node-local/hostFsService';
 
 type GenerateFn = NonNullable<TestAgentOptions['generate']>;
@@ -634,7 +634,7 @@ describe('FullCompaction', () => {
       if (attempts === 1) {
         throw new APIConnectionError('socket hang up');
       }
-      return textResult('Recovered compacted summary.');
+      return textResult('Recovered compacted summary.', 'trace-compact-1');
     };
     const ctx = testAgent({ generate, telemetry: recordingTelemetry(records) });
     ctx.configure({
@@ -657,6 +657,7 @@ describe('FullCompaction', () => {
         source: 'manual',
         tokens_before: 28,
         retry_count: 1,
+        trace_id: 'trace-compact-1',
       }),
     });
     await ctx.expectResumeMatches();
@@ -954,8 +955,9 @@ describe('FullCompaction', () => {
     await ctx.expectResumeMatches();
   });
 
-  it('cancels retry backoff without issuing another compaction request', async () => {
+  it('cancels retry backoff with the failed compaction request trace', async () => {
     vi.useFakeTimers();
+    const records: TelemetryRecord[] = [];
     const firstAttemptFailed = deferred<void>();
     let attempts = 0;
     const generate: GenerateFn = async () => {
@@ -963,9 +965,9 @@ describe('FullCompaction', () => {
       if (attempts === 1) {
         firstAttemptFailed.resolve();
       }
-      throw new APIConnectionError('socket hang up');
+      throw new APIStatusError(429, 'rate limited', null, null, 'trace-compact-retry');
     };
-    const ctx = testAgent({ generate });
+    const ctx = testAgent({ generate, telemetry: recordingTelemetry(records) });
     ctx.configure({
       provider: CATALOGUED_PROVIDER,
       modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
@@ -976,12 +978,24 @@ describe('FullCompaction', () => {
 
     await ctx.rpc.beginCompaction({});
     await firstAttemptFailed.promise;
+    const fullCompaction = ctx.get(IAgentFullCompactionService);
+    for (let i = 0; i < 10 && fullCompaction.compacting?.traceId === undefined; i += 1) {
+      await Promise.resolve();
+    }
+    expect(fullCompaction.compacting?.traceId).toBe('trace-compact-retry');
 
     void ctx.rpc.cancelCompaction({});
     await cancelled;
     await vi.advanceTimersByTimeAsync(10_000);
 
     expect(attempts).toBe(1);
+    expect(records).toContainEqual({
+      event: 'cancel',
+      properties: {
+        from: 'compacting',
+        trace_id: 'trace-compact-retry',
+      },
+    });
     vi.useRealTimers();
     await ctx.expectResumeMatches();
   });
@@ -1035,6 +1049,75 @@ describe('FullCompaction', () => {
     await ctx.expectResumeMatches();
   });
 
+  it('attaches the failed request trace id to compaction_failed', async () => {
+    const records: TelemetryRecord[] = [];
+    const generate: GenerateFn = async () => {
+      throw new APIStatusError(400, 'Bad request', null, null, 'trace-compact-fail');
+    };
+    const ctx = testAgent({ generate, telemetry: recordingTelemetry(records) });
+    ctx.configure({
+      provider: CATALOGUED_PROVIDER,
+      modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
+    });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
+    ctx.appendExchange(2, 'recent user two', 'recent assistant two', 80);
+    const failed = ctx.once('error');
+
+    await ctx.rpc.beginCompaction({});
+    await failed;
+
+    expect(records).toContainEqual({
+      event: 'compaction_failed',
+      properties: expect.objectContaining({
+        source: 'manual',
+        error_type: 'APIStatusError',
+        trace_id: 'trace-compact-fail',
+      }),
+    });
+    await ctx.expectResumeMatches();
+  });
+
+  it('attributes compaction_failed to the in-flight request trace on a mid-stream failure', async () => {
+    const records: TelemetryRecord[] = [];
+    // The stream delivers response headers (trace id) and one part, then fails
+    // — the error itself carries no trace, so attribution must come from the
+    // trace captured when the headers arrived.
+    const generate = realKosongGenerate(() => {
+      const base = mockStreamedMessage([], 'trace-mid-stream');
+      return {
+        ...base,
+        async *[Symbol.asyncIterator]() {
+          yield { type: 'text', text: 'partial summary' } as StreamedMessagePart;
+          throw new Error('stream reset');
+        },
+      };
+    });
+    const ctx = testAgent({ generate, telemetry: recordingTelemetry(records) });
+    ctx.configure({
+      provider: CATALOGUED_PROVIDER,
+      modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
+    });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
+    ctx.appendExchange(2, 'recent user two', 'recent assistant two', 80);
+    ctx.get(IAgentTelemetryContextService).set({ trace_id: 'trace-turn-1' });
+    const failed = ctx.once('error');
+
+    await ctx.rpc.beginCompaction({});
+    await failed;
+
+    const apiError = records.find((record) => record.event === 'api_error');
+    expect(apiError?.properties?.['trace_id']).toBe('trace-mid-stream');
+    expect(records).toContainEqual({
+      event: 'compaction_failed',
+      properties: expect.objectContaining({
+        source: 'manual',
+        trace_id: 'trace-mid-stream',
+      }),
+    });
+    expect(ctx.get(IAgentTelemetryContextService).get().trace_id).toBe('trace-turn-1');
+    await ctx.expectResumeMatches();
+  });
+
   it('fails a blocked turn when auto compaction generation fails', async () => {
     let attempts = 0;
     const generate: GenerateFn = async () => {
@@ -1066,7 +1149,9 @@ describe('FullCompaction', () => {
         },
       }),
     );
-    const errorEvents = ctx.newEvents();
+    const errorEvents = (ctx.newEvents() as readonly { event?: string }[]).filter(
+      (entry) => entry.event === 'error',
+    );
     expect(errorEvents).toHaveLength(1);
     expect(errorEvents[0]).toMatchObject({
       event: 'error',
@@ -1078,6 +1163,31 @@ describe('FullCompaction', () => {
     await ctx.expectResumeMatches();
   });
 
+  it('aborts an in-flight compaction when the agent is disposed', async () => {
+    const started = deferred<void>();
+    let signal: AbortSignal | undefined;
+    const generate: GenerateFn = async (_chat, _systemPrompt, _tools, _history, _callbacks, options) => {
+      signal = options?.signal;
+      started.resolve();
+      // Never settles — the compaction stays in flight until disposed.
+      return new Promise(() => {});
+    };
+    const ctx = testAgent({ generate });
+    ctx.configure({
+      provider: CATALOGUED_PROVIDER,
+      modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
+    });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
+    ctx.appendExchange(2, 'recent user two', 'recent assistant two', 80);
+
+    const pending = ctx.rpc.beginCompaction({}).catch(() => {});
+    await started.promise;
+    await ctx.dispose();
+
+    expect(signal?.aborted).toBe(true);
+    await pending;
+  });
+
   it('names truncated compaction responses when retries are exhausted', async () => {
     vi.useFakeTimers();
     const firstAttemptFinished = deferred<void>();
@@ -1821,7 +1931,7 @@ describe('FullCompaction', () => {
       modelCapabilities: {
         ...CATALOGUED_MODEL_CAPABILITIES,
         max_context_tokens: 2_000,
-        select_tools: true,
+        dynamically_loaded_tools: true,
       },
       tools: [LARGE_MCP_TOOL],
     });
@@ -1970,7 +2080,7 @@ describe('FullCompaction', () => {
     ctx.mockNextResponse({ type: 'text', text: 'Downshift summary.' });
     await ctx.get(IAgentProfileService).setModel('small-model');
 
-    const records = ctx.recordHistory;
+    const records = await ctx.wireHistory();
     const beginIndex = records.findIndex((record) => record.type === 'full_compaction.begin');
     const completeIndex = records.findIndex((record) => record.type === 'full_compaction.complete');
     // findLastIndex: the setup configure() also writes a small-model alias;
@@ -2005,7 +2115,7 @@ describe('FullCompaction', () => {
 
     await ctx.get(IAgentProfileService).setModel('big-model');
 
-    expect(ctx.recordHistory.some((record) => record.type === 'full_compaction.begin')).toBe(false);
+    expect((await ctx.wireHistory()).some((record) => record.type === 'full_compaction.begin')).toBe(false);
     expect(ctx.llmCalls).toHaveLength(0);
   });
 
@@ -2030,7 +2140,7 @@ describe('FullCompaction', () => {
 
     await ctx.get(IAgentProfileService).setModel('small-model');
 
-    expect(ctx.recordHistory.some((record) => record.type === 'full_compaction.begin')).toBe(false);
+    expect((await ctx.wireHistory()).some((record) => record.type === 'full_compaction.begin')).toBe(false);
     expect(ctx.llmCalls).toHaveLength(0);
   });
 
@@ -2713,6 +2823,23 @@ describe('FullCompaction', () => {
         }),
       }),
     );
+    type WireRequestEvent = {
+      type: '[wire]';
+      event: 'llm.request';
+      args: Record<string, unknown>;
+    };
+    const requestEvents = events.filter((event): event is WireRequestEvent => {
+      if (event === null || typeof event !== 'object') return false;
+      const candidate = event as { type?: unknown; event?: unknown };
+      return candidate.type === '[wire]' && candidate.event === 'llm.request';
+    });
+    expect(
+      requestEvents.map((event) => [event.args['kind'], event.args['droppedCount']]),
+    ).toEqual([
+      ['compaction', 0],
+      ['compaction', 2],
+      ['loop', undefined],
+    ]);
     expect(events).toContainEqual(
       expect.objectContaining({
         event: 'turn.ended',
@@ -2853,7 +2980,7 @@ describe('FullCompaction', () => {
       await ctx.untilTurnEnd();
     }
 
-    const begins = ctx.recordHistory.filter((record) => record.type === 'full_compaction.begin');
+    const begins = (await ctx.wireHistory()).filter((record) => record.type === 'full_compaction.begin');
     expect(begins).toHaveLength(1);
   });
 
@@ -2915,9 +3042,9 @@ describe('FullCompaction', () => {
     }
     await ctx.rpc.prompt({ input: [{ type: 'text', text: 'turn 0' }] });
     await ctx.untilTurnEnd();
-    const begins = () =>
-      ctx.recordHistory.filter((record) => record.type === 'full_compaction.begin').length;
-    expect(begins()).toBe(1);
+    const begins = async () =>
+      (await ctx.wireHistory()).filter((record) => record.type === 'full_compaction.begin').length;
+    expect(await begins()).toBe(1);
 
     // The 6k window still cannot fit the ~15k kept shape, but the futile
     // pause measured at 4k must not carry over.
@@ -2925,7 +3052,7 @@ describe('FullCompaction', () => {
     await ctx.rpc.prompt({ input: [{ type: 'text', text: 'turn 1' }] });
     await ctx.untilTurnEnd();
 
-    expect(begins()).toBe(2);
+    expect(await begins()).toBe(2);
   });
 
   describe('spine-mode gauge caliber', () => {    beforeEach(() => {
@@ -2978,7 +3105,7 @@ describe('FullCompaction', () => {
       await ctx.untilTurnEnd();
 
       expect(
-        ctx.recordHistory.filter((record) => record.type === 'full_compaction.begin'),
+        (await ctx.wireHistory()).filter((record) => record.type === 'full_compaction.begin'),
       ).toHaveLength(0);
     });
 
@@ -3119,7 +3246,7 @@ function providerMaxCompletionTokens(provider: Parameters<GenerateFn>[0]): unkno
   ).modelParameters?.['max_completion_tokens'];
 }
 
-function textResult(text: string): Awaited<ReturnType<GenerateFn>> {
+function textResult(text: string, traceId: string | null = null): Awaited<ReturnType<GenerateFn>> {
   return {
     id: 'mock-compaction-oauth-retry',
     message: {
@@ -3135,10 +3262,14 @@ function textResult(text: string): Awaited<ReturnType<GenerateFn>> {
     },
     finishReason: 'completed',
     rawFinishReason: 'stop',
+    traceId,
   };
 }
 
-function mockStreamedMessage(parts: readonly StreamedMessagePart[]): StreamedMessage {
+function mockStreamedMessage(
+  parts: readonly StreamedMessagePart[],
+  traceId: string | null = null,
+): StreamedMessage {
   return {
     get id(): string | null {
       return 'mock-stream';
@@ -3148,6 +3279,7 @@ function mockStreamedMessage(parts: readonly StreamedMessagePart[]): StreamedMes
     },
     finishReason: null,
     rawFinishReason: null,
+    traceId,
     async *[Symbol.asyncIterator](): AsyncIterator<StreamedMessagePart> {
       for (const part of parts) {
         yield part;
diff --git a/packages/agent-core-v2/test/agent/goal/goal.test.ts b/packages/agent-core-v2/test/agent/goal/goal.test.ts
index daeb86616..4978f056a 100644
--- a/packages/agent-core-v2/test/agent/goal/goal.test.ts
+++ b/packages/agent-core-v2/test/agent/goal/goal.test.ts
@@ -6,28 +6,39 @@
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import type { TurnEndedEvent } from '@moonshot-ai/protocol';
+import type { TurnEndedEvent } from '#/agent/loop/turnEvents';
 
+import type { IDisposable } from '#/_base/di/lifecycle';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import { USER_PROMPT_ORIGIN } from '#/agent/contextMemory/types';
 import { IAgentGoalService } from '#/agent/goal/goal';
+import { IGoalDeadlineScheduler } from '#/agent/goal/goalDeadlineScheduler';
 import { type AgentGoalService } from '#/agent/goal/goalService';
 import { UpdateGoalTool, UpdateGoalToolInputSchema } from '#/agent/goal/tools/update-goal';
 import { IAgentLoopService, type AfterStepContext, type EnqueueReceipt, type Step, type Turn } from '#/agent/loop/loop';
 import { MessageStepRequest } from '#/agent/loop/stepRequest';
-import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
+import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
+import {
+  IAgentToolExecutorService,
+  type ToolExecutionResult,
+} from '#/agent/toolExecutor/toolExecutor';
+import type { ToolBeforeExecuteContext } from '#/agent/toolExecutor/toolHooks';
+import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentUsageService } from '#/agent/usage/usage';
-import type { PersistedWireRecord } from '#/agent/wireRecord/wireRecord';
+import type { WireRecord } from '#/wire/record';
 import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
 import { APIConnectionError, APIStatusError } from '#/app/llmProtocol/errors';
 import type { ToolCall } from '#/app/llmProtocol/message';
 import type { TokenUsage } from '#/app/llmProtocol/usage';
 import { ErrorCodes, Error2, errorInfo, toKimiErrorPayload } from '#/errors';
+import type { ExecutableTool } from '#/tool/toolContract';
 
 import {
   InMemoryWireRecordPersistence,
+  appService,
   agentService,
   createTestAgent,
+  permissionModeServices,
   telemetryServices,
   testAgent,
   wireRecordPersistenceServices,
@@ -38,7 +49,7 @@ import { recordingTelemetry, type TelemetryRecord } from '../../app/telemetry/st
 import { stubLoopWithHooks, type StubLoop } from '../loop/stubs';
 
 type GoalServiceTestManager = IAgentGoalService & AgentGoalService;
-type GoalRecord = PersistedWireRecord & { type: `goal.${string}` };
+type GoalRecord = WireRecord & { type: `goal.${string}` };
 type AgentEvent = DomainEvent;
 type GoalUpdatedEvent = Extract<AgentEvent, { type: 'goal.updated' }>;
 type TurnEndedInput = {
@@ -46,6 +57,103 @@ type TurnEndedInput = {
   readonly error?: unknown;
 };
 
+interface ManualDeadline {
+  readonly dueAt: number;
+  readonly callback: () => void;
+  cancelled: boolean;
+}
+
+class ManualGoalDeadlineScheduler implements IGoalDeadlineScheduler {
+  declare readonly _serviceBrand: undefined;
+
+  private currentTime = 0;
+  private readonly deadlines = new Set<ManualDeadline>();
+
+  now(): number {
+    return this.currentTime;
+  }
+
+  schedule(delayMs: number, callback: () => void): IDisposable {
+    const deadline: ManualDeadline = {
+      dueAt: this.currentTime + Math.max(0, delayMs),
+      callback,
+      cancelled: false,
+    };
+    this.deadlines.add(deadline);
+    return {
+      dispose: () => {
+        deadline.cancelled = true;
+        this.deadlines.delete(deadline);
+      },
+    };
+  }
+
+  advanceBy(deltaMs: number): void {
+    this.currentTime += deltaMs;
+    while (true) {
+      const due = [...this.deadlines]
+        .filter((deadline) => !deadline.cancelled && deadline.dueAt <= this.currentTime)
+        .toSorted((left, right) => left.dueAt - right.dueAt)[0];
+      if (due === undefined) return;
+      this.deadlines.delete(due);
+      due.callback();
+    }
+  }
+}
+
+function deferred(): { readonly promise: Promise<void>; readonly resolve: () => void } {
+  let resolve!: () => void;
+  const promise = new Promise<void>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}
+
+function waitForAbort(signal: AbortSignal): Promise<never> {
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise<never>((_resolve, reject) => {
+    signal.addEventListener(
+      'abort',
+      () => {
+        reject(signal.reason);
+      },
+      { once: true },
+    );
+  });
+}
+
+function blockingGenerate(): {
+  readonly generate: NonNullable<TestAgentOptions['generate']>;
+  readonly started: Promise<void>;
+  readonly signal: () => AbortSignal;
+} {
+  const started = deferred();
+  let activeSignal: AbortSignal | undefined;
+  const generate: NonNullable<TestAgentOptions['generate']> = async (
+    _chat,
+    _systemPrompt,
+    _tools,
+    _history,
+    _callbacks,
+    options,
+  ) => {
+    const signal = options?.signal;
+    if (signal === undefined) throw new Error('Expected an LLM abort signal');
+    options?.onRequestStart?.();
+    activeSignal = signal;
+    started.resolve();
+    return waitForAbort(signal);
+  };
+  return {
+    generate,
+    started: started.promise,
+    signal: () => {
+      if (activeSignal === undefined) throw new Error('LLM request has not started');
+      return activeSignal;
+    },
+  };
+}
+
 const zeroUsage: TokenUsage = {
   inputCacheRead: 0,
   inputCacheCreation: 0,
@@ -53,17 +161,17 @@ const zeroUsage: TokenUsage = {
   output: 0,
 };
 
-function goalRecords(records: readonly PersistedWireRecord[]): readonly GoalRecord[] {
+function goalRecords(records: readonly WireRecord[]): readonly GoalRecord[] {
   return records.filter((record): record is GoalRecord => record.type.startsWith('goal.'));
 }
 
 async function restoreGoalRecords(
   ctx: TestAgentContext,
   goals: IAgentGoalService,
-  records: readonly PersistedWireRecord[],
+  records: readonly WireRecord[],
 ): Promise<void> {
   goals.getGoal();
-  await ctx.restore(records as readonly PersistedWireRecord[]);
+  await ctx.restore(records as readonly WireRecord[]);
 }
 
 function makeTurn(id: number): Turn {
@@ -127,6 +235,21 @@ async function runTerminalUpdateGoalResult(
   });
 }
 
+async function executeToolCall(
+  toolExecutor: IAgentToolExecutorService,
+  turn: Turn,
+  toolCall: ToolCall,
+): Promise<ToolExecutionResult[]> {
+  const results: ToolExecutionResult[] = [];
+  for await (const result of toolExecutor.execute([toolCall], {
+    turnId: turn.id,
+    signal: turn.signal,
+  })) {
+    results.push(result);
+  }
+  return results;
+}
+
 function endTurn(
   eventBus: IEventBus,
   turn: Turn,
@@ -146,7 +269,7 @@ describe('AgentGoalService', () => {
   let ctx: TestAgentContext;
   let context: IAgentContextMemoryService;
   let goals: GoalServiceTestManager;
-  let records: PersistedWireRecord[];
+  let records: WireRecord[];
   let events: GoalUpdatedEvent[];
   let telemetry: TelemetryRecord[];
 
@@ -241,7 +364,7 @@ describe('AgentGoalService', () => {
     it('replaces an existing goal when replace is set', async () => {
       const first = await goals.createGoal({ objective: 'first' });
       const second = await goals.createGoal({ objective: 'second', replace: true });
-      await ctx.wireRecord.flush();
+      await ctx.wire.flush();
 
       expect(second.goalId).not.toBe(first.goalId);
       expect(goals.getGoal().goal?.objective).toBe('second');
@@ -469,7 +592,7 @@ describe('AgentGoalService', () => {
       await goals.markBlocked({ reason: 'stuck' });
       await goals.resumeGoal();
       await goals.cancelGoal();
-      await ctx.wireRecord.flush();
+      await ctx.wire.flush();
 
       const recordsWithoutMetadata = goalRecords(records);
       expect(recordsWithoutMetadata).toEqual([
@@ -478,6 +601,7 @@ describe('AgentGoalService', () => {
           goalId: expect.any(String),
           objective: 'work',
           completionCriterion: 'tests pass',
+          wallClockResumedAt: expect.any(Number),
         }),
         expect.objectContaining({ type: 'goal.update', tokensUsed: 5 }),
         expect.objectContaining({ type: 'goal.update', turnsUsed: 1 }),
@@ -494,6 +618,7 @@ describe('AgentGoalService', () => {
         expect.objectContaining({
           type: 'goal.update',
           status: 'active',
+          wallClockResumedAt: expect.any(Number),
           actor: 'user',
         }),
         expect.objectContaining({ type: 'goal.clear' }),
@@ -548,7 +673,7 @@ describe('AgentGoalService', () => {
         status: 'paused',
         terminalReason: 'Paused after agent resume',
       });
-      expect(goalRecords(records)).toEqual([
+      expect(goalRecords(records).filter((record) => record.type === 'goal.update')).toEqual([
         expect.objectContaining({
           type: 'goal.update',
           status: 'paused',
@@ -567,11 +692,15 @@ describe('AgentGoalService core workflow hooks', () => {
   let toolExecutor: IAgentToolExecutorService;
   let usageService: IAgentUsageService;
   let eventBus: IEventBus;
+  let clock: ManualGoalDeadlineScheduler;
 
   beforeEach(() => {
     loopService = stubLoopWithHooks();
+    clock = new ManualGoalDeadlineScheduler();
     ctx = createTestAgent(
+      appService(IGoalDeadlineScheduler, clock),
       agentService(IAgentLoopService, loopService),
+      permissionModeServices('auto'),
     );
     context = ctx.get(IAgentContextMemoryService);
     goals = ctx.get(IAgentGoalService);
@@ -584,8 +713,10 @@ describe('AgentGoalService core workflow hooks', () => {
     await ctx?.dispose();
   });
 
-  async function startLiveContinuation(): Promise<ReturnType<typeof vi.fn<() => boolean>>> {
-    const abort = vi.fn<() => boolean>(() => true);
+  async function startLiveContinuation(
+    abortResult = true,
+  ): Promise<ReturnType<typeof vi.fn<() => boolean>>> {
+    const abort = vi.fn<() => boolean>(() => abortResult);
     const turn: Turn = { ...makeTurn(41), result: new Promise<never>(() => {}) };
     const step: Step = {
       id: 'goal-continuation',
@@ -621,6 +752,59 @@ describe('AgentGoalService core workflow hooks', () => {
     });
   });
 
+  it.each([{ status: 'paused' as const }, { status: 'blocked' as const }])(
+    'queues a continuation when a live non-goal turn resumes a $status goal',
+    async ({ status }) => {
+      await goals.createGoal({ objective: 'finish the task' });
+      if (status === 'paused') {
+        await goals.pauseGoal();
+      } else {
+        await goals.markBlocked({ reason: 'need credentials' });
+      }
+      const turn = makeTurn(49);
+      eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
+      await loopService.hooks.onWillBeginStep.run({
+        turnId: turn.id,
+        step: 1,
+        signal: turn.signal,
+      });
+
+      await goals.resumeGoal();
+      endTurn(eventBus, turn);
+
+      await vi.waitFor(() => {
+        expect(loopService.launches).toHaveLength(1);
+      });
+      expect(loopService.drainNextBatch(context)).toBeDefined();
+      expect(context.get().at(-1)?.origin).toEqual({
+        kind: 'system_trigger',
+        name: 'goal_continuation',
+      });
+    },
+  );
+
+  it('records a live non-goal turn against the paused goal it resumes', async () => {
+    await goals.createGoal({ objective: 'finish the task' });
+    await goals.pauseGoal();
+    const turn = makeTurn(50);
+    eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: turn.id,
+      step: 1,
+      signal: turn.signal,
+    });
+
+    await goals.resumeGoal();
+    recordStepUsage(usageService, goals, turn, { ...zeroUsage, output: 5 });
+    endTurn(eventBus, turn);
+
+    expect(goals.getGoal().goal).toMatchObject({
+      status: 'active',
+      turnsUsed: 1,
+      tokensUsed: 5,
+    });
+  });
+
   it('aborts a live continuation when the user pauses the goal', async () => {
     const abort = await startLiveContinuation();
 
@@ -645,43 +829,242 @@ describe('AgentGoalService core workflow hooks', () => {
     expect(abort).toHaveBeenCalledOnce();
   });
 
+  it('queues a continuation for a replacement goal created by its current goal turn', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    const turn = makeTurn(47);
+    eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: turn.id,
+      step: 1,
+      signal: turn.signal,
+    });
+    const toolCall: ToolCall = {
+      type: 'function',
+      id: 'call_replace_goal',
+      name: 'CreateGoal',
+      arguments: JSON.stringify({ objective: 'new task', replace: true }),
+    };
+    const results = await executeToolCall(toolExecutor, turn, toolCall);
+    expect(results[0]?.result.isError).not.toBe(true);
+
+    endTurn(eventBus, turn);
+
+    await vi.waitFor(() => {
+      expect(loopService.launches).toHaveLength(1);
+    });
+    expect(goals.getGoal().goal).toMatchObject({ objective: 'new task', status: 'active' });
+    expect(loopService.drainNextBatch(context)).toBeDefined();
+    expect(context.get().at(-1)?.origin).toEqual({
+      kind: 'system_trigger',
+      name: 'goal_continuation',
+    });
+  });
+
+  it('does not charge a same-turn replacement goal for usage owned by the prior goal', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    const turn = makeTurn(48);
+    eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: turn.id,
+      step: 1,
+      signal: turn.signal,
+    });
+    const toolCall: ToolCall = {
+      type: 'function',
+      id: 'call_replace_goal',
+      name: 'CreateGoal',
+      arguments: JSON.stringify({ objective: 'new task', replace: true }),
+    };
+    await executeToolCall(toolExecutor, turn, toolCall);
+
+    recordStepUsage(usageService, goals, turn, { ...zeroUsage, output: 5 });
+
+    expect(goals.getGoal().goal).toMatchObject({
+      objective: 'new task',
+      tokensUsed: 0,
+    });
+  });
+
+  it('keeps a replacement goal isolated from late user-turn accounting', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    const oldTurn = makeTurn(42);
+    eventBus.publish({ type: 'turn.started', turnId: oldTurn.id, origin: USER_PROMPT_ORIGIN });
+
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: oldTurn.id,
+      step: 1,
+      signal: oldTurn.signal,
+    });
+    recordStepUsage(usageService, goals, oldTurn, { ...zeroUsage, output: 5 });
+    endTurn(eventBus, oldTurn);
+
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      status: 'active',
+      turnsUsed: 0,
+      tokensUsed: 0,
+    });
+    expect(loopService.hasPendingRequests()).toBe(false);
+    expect(loopService.launches).toEqual([]);
+  });
+
+  it('ignores a late outcome continuation from a replaced goal user turn', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    const oldTurn = makeTurn(45);
+    eventBus.publish({ type: 'turn.started', turnId: oldTurn.id, origin: USER_PROMPT_ORIGIN });
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+
+    await runTerminalUpdateGoalResult(toolExecutor, oldTurn, 'complete', 'old outcome');
+    await loopService.hooks.onDidFinishStep.run({
+      turnId: oldTurn.id,
+      step: 1,
+      signal: oldTurn.signal,
+      usage: zeroUsage,
+      finishReason: 'completed',
+      stopTurn: false,
+    });
+
+    expect(loopService.hasPendingRequests()).toBe(false);
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      status: 'active',
+    });
+  });
+
+  it.each([
+    { name: 'CreateGoal', args: { objective: 'late task', replace: true } },
+    { name: 'UpdateGoal', args: { status: 'complete' } },
+    { name: 'SetGoalBudget', args: { value: 5, unit: 'turns' } },
+  ])('rejects a stale $name call from a replaced goal turn', async ({ name, args }) => {
+    await goals.createGoal({ objective: 'old task' });
+    const oldTurn = makeTurn(46);
+    eventBus.publish({ type: 'turn.started', turnId: oldTurn.id, origin: USER_PROMPT_ORIGIN });
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+    const toolCall: ToolCall = {
+      type: 'function',
+      id: 'call_stale_goal_tool',
+      name,
+      arguments: JSON.stringify(args),
+    };
+    const before: ToolBeforeExecuteContext = {
+      turnId: oldTurn.id,
+      signal: oldTurn.signal,
+      toolCall,
+      toolCalls: [toolCall],
+      args,
+      execution: { approvalRule: name, execute: async () => ({ output: 'executed' }) },
+    };
+
+    await toolExecutor.hooks.onBeforeExecuteTool.run(before);
+
+    expect(before.decision?.syntheticResult).toEqual({
+      output: 'Goal changed since this turn started; ignored stale goal tool call.',
+    });
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      status: 'active',
+      turnsUsed: 0,
+      tokensUsed: 0,
+    });
+  });
+
+  it.each([
+    { reason: 'cancelled' as const },
+    { reason: 'failed' as const, error: new Error('old turn failed') },
+  ])('keeps a replacement goal active after the replaced goal turn ends as $reason', async (result) => {
+    await goals.createGoal({ objective: 'old task' });
+    const oldTurn = makeTurn(43);
+    eventBus.publish({ type: 'turn.started', turnId: oldTurn.id, origin: USER_PROMPT_ORIGIN });
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+
+    endTurn(eventBus, oldTurn, result);
+
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      status: 'active',
+      turnsUsed: 0,
+      tokensUsed: 0,
+    });
+  });
+
+  it.each([
+    { reason: 'completed' as const },
+    { reason: 'failed' as const, error: new Error('old continuation failed') },
+  ])('keeps a replacement goal isolated when the replaced goal continuation settles as $reason', async (result) => {
+    await goals.createGoal({ objective: 'old task' });
+    const oldUserTurn = makeTurn(44);
+    eventBus.publish({ type: 'turn.started', turnId: oldUserTurn.id, origin: USER_PROMPT_ORIGIN });
+    await runGoalStep(loopService, oldUserTurn);
+    endTurn(eventBus, oldUserTurn);
+    await vi.waitFor(() => {
+      expect(loopService.launches).toHaveLength(1);
+    });
+
+    const continuationTurn = makeTurn(loopService.launches[0]!);
+    eventBus.publish({
+      type: 'turn.started',
+      turnId: continuationTurn.id,
+      origin: { kind: 'system_trigger', name: 'goal_continuation' },
+    });
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: continuationTurn.id,
+      step: 1,
+      signal: continuationTurn.signal,
+    });
+    recordStepUsage(usageService, goals, continuationTurn, { ...zeroUsage, output: 7 });
+    endTurn(eventBus, continuationTurn, result);
+
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      status: 'active',
+      turnsUsed: 0,
+      tokensUsed: 0,
+    });
+    expect(loopService.launches).toHaveLength(1);
+  });
+
+  it('cancels a preserved continuation turn after its original receipt settles', async () => {
+    const abort = await startLiveContinuation(false);
+    const cancel = vi.spyOn(loopService, 'cancel').mockReturnValue(true);
+    await goals.markBlocked({ reason: 'still need credentials' }, 'model');
+    await goals.cancelGoal();
+
+    expect(abort).toHaveBeenCalledOnce();
+    expect(cancel).toHaveBeenCalledWith(41);
+  });
+
   it.each(['turn', 'token', 'wall-clock'] as const)(
     'keeps a goal blocked when its %s budget is exhausted before resume',
     async (budget) => {
-      if (budget === 'wall-clock') {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
+      await goals.createGoal({ objective: 'finish the task' });
+      if (budget === 'turn') {
+        await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
+      } else if (budget === 'token') {
+        await goals.setBudgetLimits({ budgetLimits: { tokenBudget: 1 } }, 'model');
+      } else {
+        await goals.setBudgetLimits({ budgetLimits: { wallClockBudgetMs: 1 } }, 'model');
+        clock.advanceBy(1);
       }
-      try {
-        await goals.createGoal({ objective: 'finish the task' });
-        if (budget === 'turn') {
-          await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
-        } else if (budget === 'token') {
-          await goals.setBudgetLimits({ budgetLimits: { tokenBudget: 1 } }, 'model');
-        } else {
-          await goals.setBudgetLimits({ budgetLimits: { wallClockBudgetMs: 1 } }, 'model');
-          vi.advanceTimersByTime(1);
-        }
 
-        const turn = makeTurn(101);
-        eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
-        if (budget === 'token') {
-          recordStepUsage(usageService, goals, turn, { ...zeroUsage, output: 1 });
-        } else {
-          await runGoalStep(loopService, turn);
-        }
-        endTurn(eventBus, turn);
-        expect(loopService.status()).toMatchObject({ state: 'idle', hasPendingRequests: false });
-
-        const resumed = await goals.resumeGoal({ continueIfBlocked: true });
-
-        expect(resumed.status).toBe('blocked');
-        expect(resumed.budget.overBudget).toBe(true);
-        expect(resumed.terminalReason).toMatch(/^Blocked after goal budget reached:/);
-        expect(loopService.launches).toEqual([]);
-      } finally {
-        if (budget === 'wall-clock') vi.useRealTimers();
+      const turn = makeTurn(101);
+      eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
+      if (budget === 'token') {
+        recordStepUsage(usageService, goals, turn, { ...zeroUsage, output: 1 });
+      } else {
+        await runGoalStep(loopService, turn);
       }
+      endTurn(eventBus, turn);
+      expect(loopService.status()).toMatchObject({ state: 'idle', hasPendingRequests: false });
+
+      const resumed = await goals.resumeGoal({ continueIfBlocked: true });
+
+      expect(resumed.status).toBe('blocked');
+      expect(resumed.budget.overBudget).toBe(true);
+      expect(resumed.terminalReason).toMatch(/^Blocked after goal budget reached:/);
+      expect(loopService.launches).toEqual([]);
     },
   );
 
@@ -728,16 +1111,39 @@ describe('AgentGoalService core workflow hooks', () => {
     expect(loopService.launches).toHaveLength(1);
   });
 
-  it('does not launch a continuation when a paused goal resumes', async () => {
+  it('does not launch a continuation when a paused goal resumes by default', async () => {
     await goals.createGoal({ objective: 'finish the task' });
     await goals.pauseGoal();
 
-    const resumed = await goals.resumeGoal({ continueIfBlocked: true });
+    const resumed = await goals.resumeGoal();
 
     expect(resumed.status).toBe('active');
     expect(loopService.launches).toEqual([]);
   });
 
+  it('starts one continuation when a caller opts to resume a paused goal', async () => {
+    await goals.createGoal({ objective: 'finish the task' });
+    await goals.pauseGoal();
+
+    const resumed = await goals.resumeGoal({ continueIfPaused: true });
+
+    expect(resumed.status).toBe('active');
+    expect(loopService.launches).toHaveLength(1);
+  });
+
+  it('starts a continuation after an opted paused resume waits for a cancelled turn', async () => {
+    await startLiveContinuation();
+    const enqueue = vi.mocked(loopService.enqueue);
+
+    await goals.pauseGoal();
+    const resumed = await goals.resumeGoal({ continueIfPaused: true });
+    endTurn(eventBus, makeTurn(41), { reason: 'cancelled' });
+
+    await vi.waitFor(() => expect(enqueue).toHaveBeenCalledTimes(2));
+    expect(resumed.status).toBe('active');
+    expect(goals.getGoal().goal?.status).toBe('active');
+  });
+
   it('counts an active goal turn and launches the next continuation', async () => {
     await goals.createGoal({ objective: 'finish the task' });
 
@@ -759,13 +1165,36 @@ describe('AgentGoalService core workflow hooks', () => {
     expect(JSON.stringify(context.get().at(-1)?.content)).toContain('Continue working toward');
   });
 
-  it('blocks at the turn budget instead of launching a continuation', async () => {
+  it('blocks the next continuation only after the final allowed turn ends', async () => {
     await goals.createGoal({ objective: 'finish the task' });
     await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
 
     const turn = makeTurn(11);
     eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
-    await runGoalStep(loopService, turn);
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: turn.id,
+      step: 1,
+      signal: turn.signal,
+    });
+
+    expect(goals.getGoal().goal).toMatchObject({
+      status: 'active',
+      turnsUsed: 1,
+    });
+
+    const afterStep: AfterStepContext = {
+      turnId: turn.id,
+      step: 1,
+      signal: turn.signal,
+      usage: zeroUsage,
+      finishReason: 'completed',
+      stopTurn: false,
+    };
+    await loopService.hooks.onDidFinishStep.run(afterStep);
+
+    expect(afterStep.stopTurn).toBe(false);
+    expect(goals.getGoal().goal?.status).toBe('active');
+
     endTurn(eventBus, turn);
 
     expect(goals.getGoal().goal).toMatchObject({
@@ -776,6 +1205,64 @@ describe('AgentGoalService core workflow hooks', () => {
     expect(loopService.launches).toEqual([]);
   });
 
+  it('completes on the final allowed continuation without applying the turn budget block', async () => {
+    await goals.createGoal({ objective: 'finish the task' });
+    await goals.setBudgetLimits({ budgetLimits: { turnBudget: 2 } }, 'model');
+
+    const firstTurn = makeTurn(14);
+    eventBus.publish({ type: 'turn.started', turnId: firstTurn.id, origin: USER_PROMPT_ORIGIN });
+    await runGoalStep(loopService, firstTurn);
+    endTurn(eventBus, firstTurn);
+
+    await vi.waitFor(() => expect(loopService.launches).toHaveLength(1));
+    const continuation = makeTurn(loopService.launches[0]!);
+    eventBus.publish({
+      type: 'turn.started',
+      turnId: continuation.id,
+      origin: { kind: 'system_trigger', name: 'goal_continuation' },
+    });
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: continuation.id,
+      step: 1,
+      signal: continuation.signal,
+    });
+
+    const completed = await goals.markComplete({ reason: 'done' }, 'model');
+    endTurn(eventBus, continuation);
+
+    expect(completed).toMatchObject({ status: 'complete', turnsUsed: 2 });
+    expect(goals.getGoal().goal).toBeNull();
+    expect(loopService.launches).toHaveLength(1);
+  });
+
+  it('requests a blocked outcome step when the final allowed turn blocks the goal', async () => {
+    await goals.createGoal({ objective: 'finish the task' });
+    await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
+
+    const turn = makeTurn(15);
+    eventBus.publish({ type: 'turn.started', turnId: turn.id, origin: USER_PROMPT_ORIGIN });
+    await loopService.hooks.onWillBeginStep.run({
+      turnId: turn.id,
+      step: 1,
+      signal: turn.signal,
+    });
+    await goals.markBlocked({}, 'model');
+    await runTerminalUpdateGoalResult(toolExecutor, turn, 'blocked', 'outcome prompt');
+
+    const afterStep: AfterStepContext = {
+      turnId: turn.id,
+      step: 1,
+      signal: turn.signal,
+      usage: zeroUsage,
+      finishReason: 'completed',
+      stopTurn: false,
+    };
+    await loopService.hooks.onDidFinishStep.run(afterStep);
+
+    expect(loopService.hasPendingRequests()).toBe(true);
+    expect(goals.getGoal().goal).toMatchObject({ status: 'blocked', turnsUsed: 1 });
+  });
+
   it('accounts recorded turn usage for active goal turns', async () => {
     await goals.createGoal({ objective: 'finish the task' });
     await goals.setBudgetLimits({ budgetLimits: { tokenBudget: 7 } }, 'model');
@@ -850,6 +1337,7 @@ describe('AgentGoalService core workflow hooks', () => {
     await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
     endTurn(eventBus, turn);
 
+    await vi.waitFor(() => expect(goals.getGoal().goal?.status).toBe('blocked'));
     expect(goals.getGoal().goal).toMatchObject({
       status: 'blocked',
       turnsUsed: 1,
@@ -1017,7 +1505,7 @@ describe('goal error catalog metadata', () => {
       title: 'Invalid goal status transition',
       retryable: false,
       public: true,
-      action: 'Use a status allowed for this actor (complete, blocked, or impossible).',
+      action: 'Only an active goal can be paused; resume a blocked goal with `/goal resume`.',
     });
     expect(errorInfo('goal.metadata_reserved')).toEqual({
       title: 'Goal metadata is reserved',
@@ -1029,8 +1517,85 @@ describe('goal error catalog metadata', () => {
       title: 'Goal is not resumable',
       retryable: false,
       public: true,
-      action: 'Only paused goals can be resumed.',
+      action: 'Only paused or blocked goals can be resumed.',
     });
+    expect(errorInfo('goal.unsupported_agent')).toEqual({
+      title: 'Goals are unavailable for subagents',
+      retryable: false,
+      public: true,
+      action: 'Run goal lifecycle commands on the main agent.',
+    });
+  });
+});
+
+describe('AgentGoalService agent eligibility', () => {
+  let ctx: TestAgentContext;
+
+  beforeEach(() => {
+    ctx = createTestAgent(
+      agentService(IAgentScopeContext, {
+        _serviceBrand: undefined,
+        agentId: 'sub-1',
+        scope: (subKey?: string) =>
+          subKey === undefined ? 'test/agents/sub-1' : `test/agents/sub-1/${subKey}`,
+      }),
+    );
+  });
+
+  afterEach(async () => {
+    await ctx.dispose();
+  });
+
+  it.each([
+    ['getGoal', (goals: IAgentGoalService) => goals.getGoal()],
+    ['isGoalToolTarget', (goals: IAgentGoalService) => goals.isGoalToolTarget(1, 'goal-1')],
+    ['createGoal', (goals: IAgentGoalService) => goals.createGoal({ objective: 'work' })],
+    ['pauseGoal', (goals: IAgentGoalService) => goals.pauseGoal()],
+    ['resumeGoal', (goals: IAgentGoalService) => goals.resumeGoal()],
+    ['setBudgetLimits', (goals: IAgentGoalService) =>
+      goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } })],
+    ['cancelGoal', (goals: IAgentGoalService) => goals.cancelGoal()],
+    ['markBlocked', (goals: IAgentGoalService) => goals.markBlocked()],
+    ['markComplete', (goals: IAgentGoalService) => goals.markComplete()],
+  ] as const)(
+    '%s rejects direct goal service access when the agent is a subagent',
+    async (_name, call) => {
+      const goals = ctx.get(IAgentGoalService);
+      await expect(Promise.resolve().then<unknown>(() => call(goals))).rejects.toMatchObject({
+        code: 'goal.unsupported_agent',
+        details: { agentId: 'sub-1' },
+      });
+    },
+  );
+
+  it.each([
+    ['createGoal', () => ctx.rpc.createGoal({ objective: 'work' })],
+    ['getGoal', () => ctx.rpc.getGoal({})],
+    ['pauseGoal', () => ctx.rpc.pauseGoal({})],
+    ['resumeGoal', () => ctx.rpc.resumeGoal({})],
+    ['cancelGoal', () => ctx.rpc.cancelGoal({})],
+  ] as const)(
+    '%s rejects subagent goal RPC access with the stable goal error',
+    async (_name, call) => {
+      await expect(call()).rejects.toMatchObject({
+        code: 'goal.unsupported_agent',
+        details: { agentId: 'sub-1' },
+      });
+    },
+  );
+
+  it('does not continue a previously persisted goal when the agent is a subagent', async () => {
+    await ctx.restore([
+      { type: 'goal.create', goalId: 'legacy-subagent-goal', objective: 'work' },
+    ]);
+    ctx.mockNextResponse({ type: 'text', text: 'Handled as one normal subagent turn.' });
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'continue' }] });
+    await ctx.untilTurnEnd();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(ctx.llmCalls).toHaveLength(1);
   });
 });
 
@@ -1122,6 +1687,130 @@ describe('goal pause classification on provider errors', () => {
   });
 });
 
+describe('AgentGoalService hard wall-clock deadline', () => {
+  it('aborts an in-flight LLM request when the wall-clock budget expires', async () => {
+    const clock = new ManualGoalDeadlineScheduler();
+    const llm = blockingGenerate();
+    const ctx = createTestAgent(appService(IGoalDeadlineScheduler, clock), {
+      generate: llm.generate,
+    });
+    try {
+      ctx.configure();
+      await ctx.rpc.createGoal({ objective: 'finish bounded work' });
+      await ctx
+        .get(IAgentGoalService)
+        .setBudgetLimits({ budgetLimits: { wallClockBudgetMs: 1_000 } }, 'user');
+
+      await ctx.rpc.prompt({ input: [{ type: 'text', text: 'start work' }] });
+      await llm.started;
+      clock.advanceBy(1_000);
+
+      expect(llm.signal().aborted).toBe(true);
+      const events = await ctx.untilTurnEnd();
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          event: 'turn.ended',
+          args: expect.objectContaining({ reason: 'cancelled' }),
+        }),
+      );
+      expect((await ctx.rpc.getGoal({})).goal).toMatchObject({
+        status: 'blocked',
+        wallClockMs: 1_000,
+        budget: { wallClockBudgetReached: true },
+        terminalReason: 'Blocked after goal budget reached: wall-clock budget 1000ms',
+      });
+    } finally {
+      await ctx.dispose();
+    }
+  });
+
+  it('aborts an in-flight tool execution when the wall-clock budget expires', async () => {
+    const clock = new ManualGoalDeadlineScheduler();
+    const toolStarted = deferred();
+    let toolSignal: AbortSignal | undefined;
+    const tool: ExecutableTool = {
+      name: 'SlowWork',
+      description: 'Wait for cancellation.',
+      parameters: { type: 'object', properties: {}, additionalProperties: false },
+      resolveExecution: () => ({
+        approvalRule: 'SlowWork',
+        accesses: [],
+        execute: async ({ signal }) => {
+          toolSignal = signal;
+          toolStarted.resolve();
+          return waitForAbort(signal);
+        },
+      }),
+    };
+    const ctx = createTestAgent(
+      appService(IGoalDeadlineScheduler, clock),
+      permissionModeServices('yolo'),
+    );
+    try {
+      ctx.get(IAgentToolRegistryService).register(tool);
+      ctx.configure({ tools: ['SlowWork'] });
+      await ctx.rpc.createGoal({ objective: 'finish bounded work' });
+      await ctx
+        .get(IAgentGoalService)
+        .setBudgetLimits({ budgetLimits: { wallClockBudgetMs: 1_000 } }, 'user');
+      ctx.mockNextResponse({
+        type: 'function',
+        id: 'slow_work',
+        name: 'SlowWork',
+        arguments: '{}',
+      });
+
+      await ctx.rpc.prompt({ input: [{ type: 'text', text: 'start work' }] });
+      await toolStarted.promise;
+      clock.advanceBy(1_000);
+
+      expect(toolSignal?.aborted).toBe(true);
+      const events = await ctx.untilTurnEnd();
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          event: 'turn.ended',
+          args: expect.objectContaining({ reason: 'cancelled' }),
+        }),
+      );
+      expect((await ctx.rpc.getGoal({})).goal).toMatchObject({
+        status: 'blocked',
+        budget: { wallClockBudgetReached: true },
+      });
+    } finally {
+      await ctx.dispose();
+    }
+  });
+
+  it('keeps user cancellation authoritative when it precedes the wall-clock deadline', async () => {
+    const clock = new ManualGoalDeadlineScheduler();
+    const llm = blockingGenerate();
+    const ctx = createTestAgent(appService(IGoalDeadlineScheduler, clock), {
+      generate: llm.generate,
+    });
+    try {
+      ctx.configure();
+      await ctx.rpc.createGoal({ objective: 'finish bounded work' });
+      await ctx
+        .get(IAgentGoalService)
+        .setBudgetLimits({ budgetLimits: { wallClockBudgetMs: 1_000 } }, 'user');
+      await ctx.rpc.prompt({ input: [{ type: 'text', text: 'start work' }] });
+      await llm.started;
+
+      await ctx.rpc.cancelGoal({});
+      expect(llm.signal()).toMatchObject({
+        aborted: true,
+        reason: expect.objectContaining({ userCancelled: true }),
+      });
+      clock.advanceBy(1_000);
+
+      await ctx.untilTurnEnd();
+      expect((await ctx.rpc.getGoal({})).goal).toBeNull();
+    } finally {
+      await ctx.dispose();
+    }
+  });
+});
+
 describe('AgentGoalService mid-turn budget stop', () => {
   it('grants one tool-free grace step when a token budget is reached mid-turn', async () => {
     const ctx = createTestAgent();
@@ -1177,6 +1866,54 @@ describe('AgentGoalService mid-turn budget stop', () => {
     }
   });
 
+  it('lets an automatic continuation report final status after crossing its token budget', async () => {
+    const ctx = createTestAgent();
+    try {
+      ctx.configure({ tools: ['GetGoal'] });
+      const goals = ctx.get(IAgentGoalService);
+      await goals.createGoal({ objective: 'work' });
+      await goals.markBlocked({ reason: 'ready for a fresh continuation' });
+      await goals.setBudgetLimits({ budgetLimits: { tokenBudget: 1 } }, 'model');
+
+      ctx.mockNextResponse({
+        type: 'function',
+        id: 'g1',
+        name: 'GetGoal',
+        arguments: JSON.stringify({}),
+      });
+      ctx.mockNextResponse({ type: 'text', text: 'Final status: budget exhausted.' });
+      ctx.mockNextResponse({ type: 'text', text: 'This step should never run.' });
+
+      const turnEnd = ctx.untilTurnEnd();
+      await goals.resumeGoal({ continueIfBlocked: true });
+      const events = await turnEnd;
+
+      expect(ctx.llmCalls).toHaveLength(2);
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          event: 'turn.ended',
+          args: expect.objectContaining({ reason: 'completed' }),
+        }),
+      );
+      expect(events).not.toContainEqual(
+        expect.objectContaining({
+          event: 'turn.ended',
+          args: expect.objectContaining({ reason: 'cancelled' }),
+        }),
+      );
+
+      const history = ctx.get(IAgentContextMemoryService).get();
+      expect(JSON.stringify(history)).toContain('Final status: budget exhausted.');
+      expect(JSON.stringify(history)).not.toContain('This step should never run.');
+      expect(goals.getGoal().goal).toMatchObject({
+        status: 'blocked',
+        budget: { tokenBudgetReached: true },
+      });
+    } finally {
+      await ctx.dispose();
+    }
+  });
+
   it('rejects tool calls made during the budget grace step without executing them', async () => {
     const ctx = createTestAgent();
     try {
@@ -1226,7 +1963,47 @@ describe('AgentGoalService mid-turn budget stop', () => {
     }
   });
 
-  it('blocks an over-budget goal at turn launch and runs the prompt as a normal turn', async () => {
+  it('rejects goal tool calls when an exhausted turn budget is resumed during a prompt', async () => {
+    const ctx = createTestAgent();
+    try {
+      ctx.configure({ tools: ['UpdateGoal', 'SetGoalBudget'] });
+      const goals = ctx.get(IAgentGoalService) as GoalServiceTestManager;
+      await goals.createGoal({ objective: 'work' });
+      await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
+      await goals.incrementTurn();
+      await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
+
+      ctx.mockNextResponse({
+        type: 'function',
+        id: 'resume',
+        name: 'UpdateGoal',
+        arguments: JSON.stringify({ status: 'active' }),
+      });
+      ctx.mockNextResponse({
+        type: 'function',
+        id: 'raise-budget',
+        name: 'SetGoalBudget',
+        arguments: JSON.stringify({ value: 5, unit: 'turns' }),
+      });
+      ctx.mockNextResponse({ type: 'text', text: 'This step should never run.' });
+
+      await ctx.rpc.prompt({ input: [{ type: 'text', text: 'resume the goal' }] });
+      await ctx.untilTurnEnd();
+
+      expect(ctx.llmCalls).toHaveLength(2);
+      const history = ctx.get(IAgentContextMemoryService).get();
+      expect(JSON.stringify(history)).toContain(
+        'Goal budget exhausted; tool calls are rejected. Write your final message.',
+      );
+      expect(JSON.stringify(history)).not.toContain('This step should never run.');
+      await vi.waitFor(() => expect(goals.getGoal().goal?.status).toBe('blocked'));
+      expect(goals.getGoal().goal?.budget.turnBudget).toBe(1);
+    } finally {
+      await ctx.dispose();
+    }
+  });
+
+  it("runs the prompt as a normal turn when the goal's turn budget was reached at launch", async () => {
     const telemetry: TelemetryRecord[] = [];
     const ctx = createTestAgent(telemetryServices(recordingTelemetry(telemetry)));
     try {
@@ -1235,10 +2012,7 @@ describe('AgentGoalService mid-turn budget stop', () => {
       await goals.createGoal({ objective: 'work' });
       await goals.setBudgetLimits({ budgetLimits: { turnBudget: 1 } }, 'model');
       await goals.incrementTurn();
-      expect(goals.getGoal().goal?.status).toBe('blocked');
-
-      const resumed = await goals.resumeGoal();
-      expect(resumed.status).toBe('active');
+      expect(goals.getGoal().goal?.status).toBe('active');
       const telemetryAfterResume = telemetry.length;
 
       ctx.mockNextResponse({ type: 'text', text: 'Answering the prompt normally.' });
@@ -1273,6 +2047,42 @@ describe('AgentGoalService mid-turn budget stop', () => {
 });
 
 describe('AgentGoalService goal outcome tool result flow', () => {
+  it('lets an automatic continuation explain the blocker after UpdateGoal blocks the goal', async () => {
+    const ctx = createTestAgent();
+    try {
+      ctx.configure({ tools: ['UpdateGoal'] });
+      const goals = ctx.get(IAgentGoalService);
+      await goals.createGoal({ objective: 'work' });
+      await goals.markBlocked({ reason: 'ready for a fresh continuation' });
+
+      ctx.mockNextResponse({
+        type: 'function',
+        id: 'blocked',
+        name: 'UpdateGoal',
+        arguments: JSON.stringify({ status: 'blocked' }),
+      });
+      ctx.mockNextResponse({ type: 'text', text: 'Blocked because credentials are unavailable.' });
+
+      const turnEnd = ctx.untilTurnEnd();
+      await goals.resumeGoal({ continueIfBlocked: true });
+      const events = await turnEnd;
+
+      expect(ctx.llmCalls).toHaveLength(2);
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          event: 'turn.ended',
+          args: expect.objectContaining({ reason: 'completed' }),
+        }),
+      );
+      const history = ctx.get(IAgentContextMemoryService).get();
+      expect(JSON.stringify(history)).toContain('Blocked because credentials are unavailable.');
+      expect(history.at(-1)?.role).toBe('assistant');
+      expect(goals.getGoal().goal?.status).toBe('blocked');
+    } finally {
+      await ctx.dispose();
+    }
+  });
+
   it('does not force a goal outcome summary after maxStepsPerTurn is exhausted', async () => {
     const ctx = createTestAgent({
       initialConfig: { providers: {}, loopControl: { maxStepsPerTurn: 1 } },
diff --git a/packages/agent-core-v2/test/agent/goal/goalOps.test.ts b/packages/agent-core-v2/test/agent/goal/goalOps.test.ts
index 62f70affb..f5f6192ea 100644
--- a/packages/agent-core-v2/test/agent/goal/goalOps.test.ts
+++ b/packages/agent-core-v2/test/agent/goal/goalOps.test.ts
@@ -1,8 +1,15 @@
+/**
+ * Scenario: wire-backed goal lifecycle persistence and replay.
+ * Responsibilities: verify goal Ops, live events, and replay normalization through the service contract.
+ * Wiring: real goal/wire/event/deadline services with non-persistence collaborators stubbed.
+ * Run: `pnpm --filter @moonshot-ai/agent-core-v2 exec vitest run test/agent/goal/goalOps.test.ts`.
+ */
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { SyncDescriptor } from '#/_base/di/descriptors';
 import { DisposableStore } from '#/_base/di/lifecycle';
 import { TestInstantiationService } from '#/_base/di/test';
+import { resetUnexpectedErrorHandler, setUnexpectedErrorHandler } from '#/_base/errors/unexpectedError';
 import { Event } from '#/_base/event';
 import { IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
@@ -10,9 +17,12 @@ import { IConfigService } from '#/app/config/config';
 import { IAgentContextInjectorService } from '#/agent/contextInjector/contextInjector';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import { IAgentGoalService } from '#/agent/goal/goal';
+import { IGoalDeadlineScheduler } from '#/agent/goal/goalDeadlineScheduler';
+import { GoalDeadlineSchedulerService } from '#/agent/goal/goalDeadlineSchedulerService';
 import { AgentGoalService } from '#/agent/goal/goalService';
 import { GoalModel } from '#/agent/goal/goalOps';
 import { IAgentLoopService } from '#/agent/loop/loop';
+import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
 import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
 import { IAgentUsageService } from '#/agent/usage/usage';
@@ -21,9 +31,10 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'goal-test';
@@ -102,7 +113,6 @@ function buildHost(key: string): {
   const ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: key }]));
   ix.set(IEventBus, new SyncDescriptor(EventBusService));
   ix.stub(IAgentLoopService, createLoopStub());
   ix.stub(IAgentUsageService, {
@@ -114,9 +124,19 @@ function buildHost(key: string): {
   ix.stub(ITelemetryService, createTelemetryStub());
   ix.stub(IAgentToolExecutorService, createToolExecutorStub());
   ix.stub(IConfigService, createConfigStub());
-  ix.set(IAgentGoalService, new SyncDescriptor(AgentGoalService, [{}]));
+  ix.set(IGoalDeadlineScheduler, new SyncDescriptor(GoalDeadlineSchedulerService));
+  const wire = registerTestAgentWire(ix, testWireScope(SCOPE, key), {
+    log: ix.get(IAppendLogStore),
+    eventBus: ix.get(IEventBus),
+  });
+  ix.stub(IAgentScopeContext, {
+    _serviceBrand: undefined,
+    agentId: 'main',
+    scope: () => 'wire/agents/main',
+  });
+  ix.set(IAgentGoalService, new SyncDescriptor(AgentGoalService));
   return {
-    wire: ix.get(IAgentWireService),
+    wire,
     svc: ix.get(IAgentGoalService),
     log: ix.get(IAppendLogStore),
     eventBus: ix.get(IEventBus),
@@ -134,9 +154,10 @@ beforeEach(() => {
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(key = KEY): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, key)) {
+async function readRecords(key = KEY): Promise<WireRecord[]> {
+  await wire.flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -179,24 +200,17 @@ describe('AgentGoalService (wire-backed)', () => {
     expect(records.map((record) => record.type)).toEqual(['goal.create', 'goal.clear']);
   });
 
-  it('goal.updated signal and model subscription are live-only and silent on replay', async () => {
+  it('goal.updated is live-only and silent on replay', async () => {
     const signals: string[] = [];
     const sub = eventBus.subscribe((e) => {
       if (e.type === 'goal.updated') {
         signals.push(e.type);
       }
     });
-    let modelChanges = 0;
-    const modelSub = wire.subscribe(GoalModel, () => {
-      modelChanges += 1;
-    });
-
     await svc.createGoal({ objective: 'work' });
     await svc.pauseGoal();
     expect(signals.length).toBeGreaterThanOrEqual(2);
-    expect(modelChanges).toBeGreaterThanOrEqual(2);
     sub.dispose();
-    modelSub.dispose();
 
     const records = await readRecords();
     const host = buildHost('goal-replay');
@@ -206,37 +220,44 @@ describe('AgentGoalService (wire-backed)', () => {
         replaySignals.push(e.type);
       }
     });
-    let replayModelChanges = 0;
-    host.wire.subscribe(GoalModel, () => {
-      replayModelChanges += 1;
-    });
-
-    await host.wire.replay(...records);
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'goal-replay'),
+      records,
+    );
     expect(modelOf(host.wire)?.status).toBe('paused');
     expect(replaySignals).toEqual([]);
-    expect(replayModelChanges).toBe(0);
   });
 
-  it('onRestored forces a replayed active goal to paused after replay', async () => {
+  it('onDidRestore forces a replayed active goal to paused after replay', async () => {
     const created = await svc.createGoal({ objective: 'resume me' });
     const records = await readRecords();
 
     const host = buildHost('goal-restore');
     void host.svc;
 
-    await host.wire.replay(...records);
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'goal-restore'),
+      records,
+    );
     expect(modelOf(host.wire)?.status).toBe('paused');
     expect(modelOf(host.wire)?.terminalReason).toBe('Paused after agent resume');
     expect(modelOf(host.wire)?.goalId).toBe(created.goalId);
 
     const written = await (async () => {
-      const out: PersistedRecord[] = [];
-      for await (const record of host.log.read<PersistedRecord>(SCOPE, 'goal-restore')) {
+      const out: WireRecord[] = [];
+      for await (const record of host.log.read<WireRecord>(
+        testWireScope(SCOPE, 'goal-restore'),
+        AGENT_WIRE_RECORD_KEY,
+      )) {
         out.push(record);
       }
       return out;
     })();
-    expect(written).toEqual([
+    expect(written.filter((record) => record.type === 'goal.update')).toEqual([
       expect.objectContaining({
         type: 'goal.update',
         status: 'paused',
@@ -244,4 +265,152 @@ describe('AgentGoalService (wire-backed)', () => {
       }),
     ]);
   });
+
+  it('restores goal records with omitted optional fields from older journals', async () => {
+    await restoreTestAgentWire(wire, log, testWireScope(SCOPE, KEY), [
+      { type: 'goal.create', goalId: 'goal-1', objective: 'work' },
+      { type: 'goal.update' },
+    ]);
+
+    expect(modelOf(wire)).toMatchObject({
+      goalId: 'goal-1',
+      status: 'paused',
+      budgetLimits: {},
+    });
+  });
+
+  it('restores legacy goal create audit fields without changing normalized state', async () => {
+    await restoreTestAgentWire(wire, log, testWireScope(SCOPE, KEY), [
+      {
+        type: 'goal.create',
+        goalId: 'goal-1',
+        objective: 'work',
+        status: 'active',
+        actor: 'user',
+        budgetLimits: {},
+      },
+    ]);
+
+    expect(modelOf(wire)).toMatchObject({
+      goalId: 'goal-1',
+      status: 'paused',
+      budgetLimits: {},
+    });
+  });
+
+  it('restores a legacy goal update identity without changing state selection', async () => {
+    await restoreTestAgentWire(wire, log, testWireScope(SCOPE, KEY), [
+      { type: 'goal.create', goalId: 'goal-1', objective: 'work' },
+      { type: 'goal.update', goalId: 'goal-1', status: 'blocked', reason: 'waiting' },
+    ]);
+
+    expect(modelOf(wire)).toMatchObject({
+      goalId: 'goal-1',
+      status: 'blocked',
+      terminalReason: 'waiting',
+    });
+  });
+
+  it('strips forward-compatible goal fields during restore', async () => {
+    await restoreTestAgentWire(wire, log, testWireScope(SCOPE, KEY), [
+      {
+        type: 'goal.create',
+        goalId: 'goal-1',
+        objective: 'work',
+        futureField: true,
+      },
+    ]);
+
+    expect(modelOf(wire)).toMatchObject({ goalId: 'goal-1', objective: 'work' });
+  });
+
+  it('skips a goal update with an invalid status during restore', async () => {
+    const unexpected: unknown[] = [];
+    setUnexpectedErrorHandler((error) => unexpected.push(error));
+    try {
+      await restoreTestAgentWire(wire, log, testWireScope(SCOPE, KEY), [
+        { type: 'goal.create', goalId: 'goal-1', objective: 'work' },
+        { type: 'goal.update', status: 'cancelled' },
+      ]);
+
+      expect(modelOf(wire)).toMatchObject({ status: 'paused' });
+      expect(unexpected).toContainEqual(
+        expect.objectContaining({ code: 'wire.unknown_record', details: { type: 'goal.update', index: 1 } }),
+      );
+    } finally {
+      resetUnexpectedErrorHandler();
+    }
+  });
+
+  it('skips a goal update with an invalid actor during restore', async () => {
+    const unexpected: unknown[] = [];
+    setUnexpectedErrorHandler((error) => unexpected.push(error));
+    try {
+      await restoreTestAgentWire(wire, log, testWireScope(SCOPE, KEY), [
+        { type: 'goal.create', goalId: 'goal-1', objective: 'work' },
+        { type: 'goal.update', actor: 'assistant' },
+      ]);
+
+      expect(modelOf(wire)).toMatchObject({ status: 'paused' });
+      expect(unexpected).toContainEqual(
+        expect.objectContaining({ code: 'wire.unknown_record', details: { type: 'goal.update', index: 1 } }),
+      );
+    } finally {
+      resetUnexpectedErrorHandler();
+    }
+  });
+
+  it('skips negative and non-finite goal counters and budgets during restore', async () => {
+    const unexpected: unknown[] = [];
+    setUnexpectedErrorHandler((error) => unexpected.push(error));
+    try {
+      await restoreTestAgentWire(wire, log, testWireScope(SCOPE, KEY), [
+        { type: 'goal.create', goalId: 'goal-1', objective: 'work' },
+        { type: 'goal.update', turnsUsed: -1 },
+        { type: 'goal.update', tokensUsed: Number.POSITIVE_INFINITY },
+        { type: 'goal.update', wallClockMs: Number.NaN },
+        { type: 'goal.update', wallClockResumedAt: Number.NaN },
+        { type: 'goal.update', budgetLimits: { turnBudget: -1 } },
+        { type: 'goal.update', budgetLimits: { tokenBudget: Number.POSITIVE_INFINITY } },
+        { type: 'goal.update', budgetLimits: { wallClockBudgetMs: Number.NaN } },
+      ]);
+
+      expect(modelOf(wire)).toMatchObject({
+        turnsUsed: 0,
+        tokensUsed: 0,
+        wallClockMs: 0,
+        budgetLimits: {},
+      });
+      expect(unexpected).toHaveLength(7);
+    } finally {
+      resetUnexpectedErrorHandler();
+    }
+  });
+
+  it('skips null, arrays, and malformed nested goal records during restore', async () => {
+    const unexpected: unknown[] = [];
+    setUnexpectedErrorHandler((error) => unexpected.push(error));
+    try {
+      await restoreTestAgentWire(
+        wire,
+        log,
+        testWireScope(SCOPE, KEY),
+        [
+          null,
+          [],
+          {
+            type: 'goal.create',
+            goalId: 'goal-1',
+            objective: 'work',
+            budgetLimits: { unexpected: true },
+          },
+        ] as unknown as WireRecord[],
+      );
+
+      expect(modelOf(wire)).toBeNull();
+      expect(unexpected).toHaveLength(3);
+    } finally {
+      resetUnexpectedErrorHandler();
+    }
+  });
 });
diff --git a/packages/agent-core-v2/test/agent/goal/injection/goalInjection.test.ts b/packages/agent-core-v2/test/agent/goal/injection/goalInjection.test.ts
index 3938878b8..436362c92 100644
--- a/packages/agent-core-v2/test/agent/goal/injection/goalInjection.test.ts
+++ b/packages/agent-core-v2/test/agent/goal/injection/goalInjection.test.ts
@@ -178,6 +178,7 @@ describe('GoalInjection content', () => {
       await goals.setBudgetLimits({ budgetLimits: { turnBudget: 2 } }, 'model');
       await goals.incrementTurn();
       await goals.incrementTurn();
+      await goals.setBudgetLimits({ budgetLimits: { turnBudget: 2 } }, 'model');
     }))!;
     expect(text).toContain('currently blocked');
     expect(text).toContain('Blocked after goal budget reached: turn budget 2');
@@ -246,7 +247,7 @@ async function flushedGoalReminderRecords(
   ctx: TestAgentContext,
   persistence: InMemoryWireRecordPersistence,
 ) {
-  await ctx.wireRecord.flush();
+  await ctx.wire.flush();
   return goalReminderRecords(persistence);
 }
 
diff --git a/packages/agent-core-v2/test/agent/goal/tools/goal-tools.test.ts b/packages/agent-core-v2/test/agent/goal/tools/goal-tools.test.ts
index 0f99599a4..f2b6c00d1 100644
--- a/packages/agent-core-v2/test/agent/goal/tools/goal-tools.test.ts
+++ b/packages/agent-core-v2/test/agent/goal/tools/goal-tools.test.ts
@@ -1,6 +1,13 @@
+/**
+ * Scenario: model-facing goal tool validation and delayed execution.
+ * Responsibilities: verify goal commands target the goal selected when execution is resolved.
+ * Wiring: real goal service; loop is stubbed at the agent boundary.
+ * Run: `pnpm --filter @moonshot-ai/agent-core-v2 exec vitest run test/agent/goal/tools/goal-tools.test.ts`.
+ */
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import type { ServicesAccessor } from '#/_base/di/instantiation';
+import type { ToolCall } from '#/app/llmProtocol/message';
 import {
   compileToolArgsValidator,
   validateToolArgs,
@@ -16,10 +23,20 @@ import {
 } from '#/agent/goal/tools/update-goal';
 import { IAgentLoopService } from '#/agent/loop/loop';
 import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
+import {
+  IAgentToolExecutorService,
+  type ToolExecutionResult,
+} from '#/agent/toolExecutor/toolExecutor';
 import { getToolContributions } from '#/agent/toolRegistry/toolContribution';
+import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IEventBus } from '#/app/event/eventBus';
 
-import { agentService, createTestAgent, type TestAgentContext } from '../../../harness';
+import {
+  agentService,
+  createTestAgent,
+  permissionModeServices,
+  type TestAgentContext,
+} from '../../../harness';
 import { stubLoopWithHooks } from '../../loop/stubs';
 
 const signal = new AbortController().signal;
@@ -29,14 +46,19 @@ describe('goal tools', () => {
   let goals: IAgentGoalService;
   let loopService: IAgentLoopService;
   let eventBus: IEventBus;
+  let toolExecutor: IAgentToolExecutorService;
   let setGoalBudgetTool: SetGoalBudgetTool;
   let updateGoalTool: UpdateGoalTool;
 
   beforeEach(() => {
     loopService = stubLoopWithHooks({ hasActiveTurn: true });
-    ctx = createTestAgent(agentService(IAgentLoopService, loopService));
+    ctx = createTestAgent(
+      agentService(IAgentLoopService, loopService),
+      permissionModeServices('auto'),
+    );
     goals = ctx.get(IAgentGoalService);
     eventBus = ctx.get(IEventBus);
+    toolExecutor = ctx.get(IAgentToolExecutorService);
     setGoalBudgetTool = new SetGoalBudgetTool(goals);
     updateGoalTool = new UpdateGoalTool(goals);
   });
@@ -45,6 +67,49 @@ describe('goal tools', () => {
     await ctx.dispose();
   });
 
+  it('CreateGoal does not apply a delayed execution to a replacement goal', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    eventBus.publish({ type: 'turn.started', turnId: 6, origin: USER_PROMPT_ORIGIN });
+    const tool = ctx.get(IAgentToolRegistryService).resolve('CreateGoal');
+    if (tool === undefined) throw new Error('CreateGoal should be registered');
+    const execution = await tool.resolveExecution({ objective: 'stale task', replace: true });
+    if (execution.isError === true) throw new Error('execution should not be an error');
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+
+    const result = await execution.execute({
+      turnId: 6,
+      toolCallId: 'call_old_create',
+      signal,
+    });
+
+    expect(result.output).toBe('Goal not created: the current goal changed.');
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      objective: 'new task',
+    });
+  });
+
+  it('CreateGoal does not apply a no-goal execution to an externally created goal', async () => {
+    eventBus.publish({ type: 'turn.started', turnId: 7, origin: USER_PROMPT_ORIGIN });
+    const tool = ctx.get(IAgentToolRegistryService).resolve('CreateGoal');
+    if (tool === undefined) throw new Error('CreateGoal should be registered');
+    const execution = await tool.resolveExecution({ objective: 'stale task', replace: true });
+    if (execution.isError === true) throw new Error('execution should not be an error');
+    const created = await goals.createGoal({ objective: 'external task' });
+
+    const result = await execution.execute({
+      turnId: 7,
+      toolCallId: 'call_old_create',
+      signal,
+    });
+
+    expect(result.output).toBe('Goal not created: the current goal changed.');
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: created.goalId,
+      objective: 'external task',
+    });
+  });
+
   it('SetGoalBudget reports no current goal without failing', async () => {
     const execution = setGoalBudgetTool.resolveExecution({ value: 20, unit: 'turns' });
     if (execution.isError === true) throw new Error('execution should not be an error');
@@ -92,6 +157,95 @@ describe('goal tools', () => {
     });
   });
 
+  it('SetGoalBudget does not apply a delayed execution to a replacement goal', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    const execution = setGoalBudgetTool.resolveExecution({ value: 5, unit: 'turns' });
+    if (execution.isError === true) throw new Error('execution should not be an error');
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+
+    const result = await execution.execute({ turnId: 0, toolCallId: 'call_old_budget', signal });
+
+    expect(result.output).toBe('Goal budget not set: the current goal changed.');
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      budget: { turnBudget: null },
+    });
+  });
+
+  it('SetGoalBudget does not apply a no-goal execution to an externally created goal', async () => {
+    const execution = setGoalBudgetTool.resolveExecution({ value: 5, unit: 'turns' });
+    if (execution.isError === true) throw new Error('execution should not be an error');
+    const created = await goals.createGoal({ objective: 'external task' });
+
+    const result = await execution.execute({ turnId: 0, toolCallId: 'call_old_budget', signal });
+
+    expect(result.output).toBe('Goal budget not set: the current goal changed.');
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: created.goalId,
+      budget: { turnBudget: null },
+    });
+  });
+
+  it('SetGoalBudget ignores a stale call from a replaced goal turn', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    eventBus.publish({ type: 'turn.started', turnId: 1, origin: USER_PROMPT_ORIGIN });
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+
+    const results = await executeGoalCalls(
+      [goalToolCall('call_old_budget', 'SetGoalBudget', { value: 5, unit: 'turns' })],
+      1,
+    );
+
+    expect(results[0]?.result.output).toBe(
+      'Goal changed since this turn started; ignored stale goal tool call.',
+    );
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      budget: { turnBudget: null },
+    });
+  });
+
+  it('SetGoalBudget applies a delayed execution to a goal created earlier in the same batch', async () => {
+    eventBus.publish({ type: 'turn.started', turnId: 2, origin: USER_PROMPT_ORIGIN });
+
+    const results = await executeGoalCalls(
+      [
+        goalToolCall('call_create', 'CreateGoal', { objective: 'new task' }),
+        goalToolCall('call_budget', 'SetGoalBudget', { value: 5, unit: 'turns' }),
+      ],
+      2,
+    );
+
+    expect(results.find((result) => result.toolName === 'SetGoalBudget')?.result.output).toBe(
+      'Goal budget set: 5 turns.',
+    );
+    expect(goals.getGoal().goal).toMatchObject({
+      objective: 'new task',
+      budget: { turnBudget: 5 },
+    });
+  });
+
+  it('SetGoalBudget applies a same-batch budget to the replacement goal', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    eventBus.publish({ type: 'turn.started', turnId: 3, origin: USER_PROMPT_ORIGIN });
+
+    const results = await executeGoalCalls(
+      [
+        goalToolCall('call_replace', 'CreateGoal', { objective: 'new task', replace: true }),
+        goalToolCall('call_budget', 'SetGoalBudget', { value: 5, unit: 'turns' }),
+      ],
+      3,
+    );
+
+    expect(results.find((result) => result.toolName === 'SetGoalBudget')?.result.output).toBe(
+      'Goal budget set: 5 turns.',
+    );
+    expect(goals.getGoal().goal).toMatchObject({
+      objective: 'new task',
+      budget: { turnBudget: 5 },
+    });
+  });
+
   it('UpdateGoal accepts only active / complete / blocked statuses', () => {
     for (const status of ['active', 'complete', 'blocked']) {
       expect(UpdateGoalToolInputSchema.safeParse({ status }).success).toBe(true);
@@ -142,6 +296,88 @@ describe('goal tools', () => {
     expect(result.output).toContain('concrete blocker');
   });
 
+  it('UpdateGoal does not apply a delayed outcome to a replacement goal', async () => {
+    await goals.createGoal({ objective: 'old task' });
+    const execution = updateGoalTool.resolveExecution({ status: 'complete' });
+    if (execution.isError === true) throw new Error('execution should not be an error');
+    const replacement = await goals.createGoal({ objective: 'new task', replace: true });
+
+    const result = await execution.execute({ turnId: 0, toolCallId: 'call_old_outcome', signal });
+
+    expect(result.output).toBe('Goal not completed: the current goal changed.');
+    expect(result.stopTurn).toBeFalsy();
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: replacement.goalId,
+      status: 'active',
+    });
+  });
+
+  it('UpdateGoal does not apply a no-goal outcome to an externally created goal', async () => {
+    const execution = updateGoalTool.resolveExecution({ status: 'complete' });
+    if (execution.isError === true) throw new Error('execution should not be an error');
+    const created = await goals.createGoal({ objective: 'external task' });
+
+    const result = await execution.execute({
+      turnId: 0,
+      toolCallId: 'call_old_outcome',
+      signal,
+    });
+
+    expect(result.output).toBe('Goal not completed: the current goal changed.');
+    expect(result.stopTurn).toBeFalsy();
+    expect(goals.getGoal().goal).toMatchObject({
+      goalId: created.goalId,
+      status: 'active',
+    });
+  });
+
+  it.each([
+    ['complete', null, 'Goal completed successfully'],
+    ['blocked', 'blocked', 'Goal blocked.'],
+  ] as const)(
+    'UpdateGoal applies %s to a goal replaced earlier in the same batch',
+    async (updateStatus, expectedCurrentStatus, expectedOutput) => {
+      await goals.createGoal({ objective: 'old task' });
+      eventBus.publish({ type: 'turn.started', turnId: 4, origin: USER_PROMPT_ORIGIN });
+
+      const results = await executeGoalCalls(
+        [
+          goalToolCall('call_replace', 'CreateGoal', { objective: 'new task', replace: true }),
+          goalToolCall('call_outcome', 'UpdateGoal', { status: updateStatus }),
+        ],
+        4,
+      );
+
+      const outcome = results.find((result) => result.toolName === 'UpdateGoal')?.result;
+      expect(outcome?.output).toContain(expectedOutput);
+      expect(outcome?.stopTurn).toBe(true);
+      expect(goals.getGoal().goal?.status ?? null).toBe(expectedCurrentStatus);
+    },
+  );
+
+  it.each([
+    ['complete', null, 'Goal completed successfully'],
+    ['blocked', 'blocked', 'Goal blocked.'],
+  ] as const)(
+    'UpdateGoal applies %s when the goal was created earlier in the same batch',
+    async (updateStatus, expectedCurrentStatus, expectedOutput) => {
+      eventBus.publish({ type: 'turn.started', turnId: 5, origin: USER_PROMPT_ORIGIN });
+
+      const results = await executeGoalCalls(
+        [
+          goalToolCall('call_create', 'CreateGoal', { objective: 'new task', replace: true }),
+          goalToolCall('call_outcome', 'UpdateGoal', { status: updateStatus }),
+        ],
+        5,
+      );
+
+      const outcome = results.find((result) => result.toolName === 'UpdateGoal')?.result;
+      expect(outcome?.output).toContain(expectedOutput);
+      expect(outcome?.stopTurn).toBe(true);
+      expect(goals.getGoal().goal?.status ?? null).toBe(expectedCurrentStatus);
+    },
+  );
+
   it('UpdateGoal reports no active goal when completing/blocking/resuming without one', async () => {
     const done = updateGoalTool.resolveExecution({ status: 'complete' });
     if (done.isError === true) throw new Error('execution should not be an error');
@@ -168,6 +404,25 @@ describe('goal tools', () => {
       signal: abortController.signal,
     });
   }
+
+  async function executeGoalCalls(
+    calls: ToolCall[],
+    turnId: number,
+  ): Promise<ToolExecutionResult[]> {
+    const results: ToolExecutionResult[] = [];
+    for await (const result of toolExecutor.execute(calls, { turnId, signal })) {
+      results.push(result);
+    }
+    return results;
+  }
+
+  function goalToolCall(
+    id: string,
+    name: 'CreateGoal' | 'GetGoal' | 'SetGoalBudget' | 'UpdateGoal',
+    args: Record<string, unknown>,
+  ): ToolCall {
+    return { type: 'function', id, name, arguments: JSON.stringify(args) };
+  }
 });
 
 describe('goal tool main-agent gating', () => {
diff --git a/packages/agent-core-v2/test/agent/llmRequester/llmRequester.test.ts b/packages/agent-core-v2/test/agent/llmRequester/llmRequester.test.ts
index d54766760..5317c96eb 100644
--- a/packages/agent-core-v2/test/agent/llmRequester/llmRequester.test.ts
+++ b/packages/agent-core-v2/test/agent/llmRequester/llmRequester.test.ts
@@ -96,7 +96,7 @@ describe('LLMRequester service migration coverage', () => {
           thinking: false,
           tool_use: true,
           max_context_tokens: 128_000,
-          select_tools: true,
+          dynamically_loaded_tools: true,
         },
       });
       ctx.mockNextResponse({ type: 'text', text: 'first response' });
diff --git a/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts b/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
index e9432681f..69f1e37d4 100644
--- a/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
+++ b/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
@@ -11,8 +11,11 @@
  * pnpm test -- test/agent/llmRequester/llmRequesterService.test.ts
  */
 
+import { createControlledPromise } from '@antfu/utils';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
 import { SyncDescriptor } from '#/_base/di/descriptors';
-import { DisposableStore } from '#/_base/di/lifecycle';
+import { DisposableStore, toDisposable } from '#/_base/di/lifecycle';
 import { TestInstantiationService } from '#/_base/di/test';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import type { ContextMessage } from '#/agent/contextMemory/types';
@@ -33,21 +36,29 @@ import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentToolSelectService } from '#/agent/toolSelect/toolSelect';
 import { IAgentUsageService } from '#/agent/usage/usage';
 import { IConfigService } from '#/app/config/config';
+import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
 import { IFlagService } from '#/app/flag/flag';
-import { APIRequestTooLargeError, APIStatusError } from '#/app/llmProtocol/errors';
+import {
+  APIConnectionError,
+  APIEmptyResponseError,
+  APIRequestTooLargeError,
+  APIStatusError,
+} from '#/app/llmProtocol/errors';
 import type { MaxCompletionTokensOptions } from '#/app/llmProtocol/provider';
 import type { Tool } from '#/app/llmProtocol/tool';
 import { emptyUsage } from '#/app/llmProtocol/usage';
 import type { Message } from '#/app/llmProtocol/message';
+import type { ThinkingEffort } from '#/app/llmProtocol/thinkingEffort';
 import type { ModelCapability } from '#/app/llmProtocol/capability';
 import type { LLMEvent, LLMRequestInput, Model } from '#/app/model/modelInstance';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { ILogService } from '#/_base/log/log';
 import { Error2, ErrorCodes } from '#/errors';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { IWireService } from '#/wire/wire';
+import type { WireRecord } from '#/wire/record';
+import { recordingTelemetry, type TelemetryRecord } from '../../app/telemetry/stubs';
+
+import { recordingWireLog, registerTestAgentWire } from '../../wire/stubs';
 
 const capabilities: ModelCapability = {
   image_in: false,
@@ -139,16 +150,20 @@ function createService(
     measured: () => undefined,
   },
   toolEntries: readonly ToolInfo[] = [],
-  options: { readonly flagEnabled?: boolean } = {},
+  options: {
+    readonly flagEnabled?: boolean;
+    readonly thinkingLevel?: ThinkingEffort;
+  } = {},
 ) {
   const ix = disposables.add(new TestInstantiationService());
+  const thinkingLevel = options.thinkingLevel ?? 'off';
   const profile: Partial<IAgentProfileService> = {
     resolveModelContext: () => ({
       modelAlias: 'm',
       modelCapabilities: capabilities,
       maxOutputSize: undefined,
       alwaysThinking: undefined,
-      thinkingLevel: 'off',
+      thinkingLevel,
       reservedContextSize: undefined,
       compactionTriggerRatio: undefined,
     }),
@@ -158,7 +173,7 @@ function createService(
       cwd: '',
       modelAlias: 'm',
       modelCapabilities: capabilities,
-      thinkingLevel: 'off',
+      thinkingLevel,
       systemPrompt: 'system',
     }),
     isToolActive: () => true,
@@ -170,7 +185,8 @@ function createService(
     get: (() => undefined) as IConfigService['get'],
   };
   const log = { info: () => undefined, warn: () => undefined };
-  const telemetry = { track: () => undefined, track2: () => undefined };
+  const telemetryRecords: TelemetryRecord[] = [];
+  const telemetry = recordingTelemetry(telemetryRecords);
   const toolSelect: Partial<IAgentToolSelectService> = {
     enabled: () => false,
     shapeTools: (entries) => entries,
@@ -178,6 +194,12 @@ function createService(
   };
   const flagEnabled = options.flagEnabled ?? true;
   const testSnapshot = Object.freeze({}) as MediaStripSnapshot;
+  const events: DomainEvent[] = [];
+  const eventBus: IEventBus = {
+    _serviceBrand: undefined,
+    publish: (event) => events.push(event),
+    subscribe: () => toDisposable(() => {}),
+  };
 
   ix.stub(IAgentContextMemoryService, context);
   ix.stub(IAgentToolSelectService, toolSelect);
@@ -202,25 +224,49 @@ function createService(
   ix.stub(IConfigService, config);
   ix.stub(ILogService, log);
   ix.stub(ITelemetryService, telemetry);
-  ix.set(
-    IAgentWireService,
-    new SyncDescriptor(WireService, [{ logScope: 'wire', logKey: 'strict-resend' }]),
-  );
+  const records: WireRecord[] = [];
+  registerTestAgentWire(ix, 'wire/llm-requester', {
+    log: recordingWireLog(records),
+    eventBus,
+  });
   ix.set(IFaultInjectionService, new SyncDescriptor(FaultInjectionService));
   ix.set(IAgentLLMRequesterService, new SyncDescriptor(AgentLLMRequesterService));
 
-  const records: PersistedRecord[] = [];
-  disposables.add(
-    ix.get(IAgentWireService).onEmission((emission) => records.push(emission.record)),
-  );
-
   return {
     service: ix.get(IAgentLLMRequesterService),
     faultInjection: ix.get(IFaultInjectionService),
+    wire: ix.get(IWireService),
     records,
+    events,
+    telemetryRecords,
   };
 }
 
+describe('AgentLLMRequesterService Anthropic effort diagnostics', () => {
+  it('warns and sends when the effort is not listed by the model', async () => {
+    const calls = { value: 0 };
+    const model = createModel(calls, null);
+    Object.defineProperty(model, 'supportEfforts', { value: ['max'] });
+    Object.defineProperty(model, 'withMaxCompletionTokens', { value: () => model });
+    const { service, events } = createService(model, undefined, undefined, undefined, {
+      thinkingLevel: 'high',
+    });
+
+    const result = await service.request();
+
+    expect(result.message.content).toEqual([{ type: 'text', text: 'ok' }]);
+    expect(calls.value).toBe(1);
+    expect(events.filter((event) => event.type === 'warning')).toEqual([
+      {
+        type: 'warning',
+        code: 'anthropic-thinking-effort-not-listed',
+        message:
+          'Thinking effort "high" is not listed for model "wire-model" (known: max). The configured value will be sent unchanged to the Anthropic-compatible backend.',
+      },
+    ]);
+  });
+});
+
 describe('AgentLLMRequesterService strict resend', () => {
   it('resends once with strict projection after a recoverable structural 400', async () => {
     const calls = { value: 0 };
@@ -604,7 +650,7 @@ describe('AgentLLMRequesterService media-degraded resend', () => {
 
   it('records repeated-413 recovery projections on the sticky later request', async () => {
     const calls = { value: 0 };
-    const { service, records } = createService(
+    const { service, wire, records } = createService(
       createModel(calls, BODY_TOO_LARGE_413, [BODY_TOO_LARGE_413]),
       {
         project: (messages: readonly ContextMessage[]) => messages,
@@ -616,6 +662,7 @@ describe('AgentLLMRequesterService media-degraded resend', () => {
 
     await service.request({ source: { type: 'turn', turnId: 1, step: 1 } });
     await service.request({ source: { type: 'turn', turnId: 1, step: 2 } });
+    await wire.flush();
 
     expect(
       records
@@ -817,3 +864,179 @@ describe('AgentLLMRequesterService fault injection (experimental)', () => {
     expect(faultInjection.status()).toEqual({ armed: undefined, fired: [] });
   });
 });
+
+describe('AgentLLMRequesterService trace id', () => {
+  const passthroughProjector = {
+    project: (messages: readonly ContextMessage[]) => messages,
+    projectStrict: (messages: readonly ContextMessage[]) => messages,
+  };
+
+  function createTracedModel(traceId: string | null): Model {
+    const build = (): Model => ({
+      id: 'm',
+      name: 'wire-model',
+      aliases: [],
+      protocol: 'kimi',
+      baseUrl: 'https://example.test',
+      headers: {},
+      capabilities,
+      maxContextSize: 1000,
+      thinkingEffort: null,
+      alwaysThinking: false,
+      providerName: 'p',
+      authProvider: { getAuth: async () => undefined },
+      withThinking: () => build(),
+      withMaxCompletionTokens: () => build(),
+      withGenerationKwargs: () => build(),
+      withProviderOptions: () => build(),
+      withThinkingKeep: () => build(),
+      request: async function* (_input, _signal, requestOptions) {
+        requestOptions?.onTraceId?.(traceId);
+        yield {
+          type: 'finish',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], toolCalls: [] },
+          providerFinishReason: 'completed',
+          rawFinishReason: 'stop',
+          id: 'resp-1',
+          traceId: traceId ?? undefined,
+        };
+      },
+    });
+    return build();
+  }
+
+  it('exposes the request trace and returns it on finish', async () => {
+    const model = createTracedModel('trace-req-1');
+    const headersArrived = createControlledPromise<void>();
+    const releaseStream = createControlledPromise<void>();
+    Object.defineProperty(model, 'request', {
+      value: async function* (_input: unknown, _signal: unknown, requestOptions: {
+        onTraceId?: (traceId: string | null) => void;
+      }) {
+        requestOptions.onTraceId?.('trace-req-1');
+        headersArrived.resolve();
+        await releaseStream;
+        yield {
+          type: 'finish',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], toolCalls: [] },
+          providerFinishReason: 'completed',
+          rawFinishReason: 'stop',
+          id: 'resp-1',
+          traceId: 'trace-req-1',
+        } satisfies LLMEvent;
+      },
+    });
+    Object.defineProperty(model, 'withMaxCompletionTokens', {
+      value: () => model,
+    });
+    const { service } = createService(model, passthroughProjector);
+    const request = service.start({ source: { type: 'turn', turnId: 1, step: 1 } });
+    await headersArrived;
+    expect(request.trace.traceId).toBe('trace-req-1');
+    releaseStream.resolve();
+    const finish = await request.result;
+
+    expect(finish.traceId).toBe('trace-req-1');
+    expect(request.trace.traceId).toBe('trace-req-1');
+  });
+
+  it('reports an absent trace before a request that returns none', async () => {
+    const { service } = createService(createTracedModel(null), passthroughProjector);
+    const request = service.start();
+    const finish = await request.result;
+
+    expect(finish.traceId).toBeUndefined();
+    expect(request.trace.traceId).toBeUndefined();
+  });
+
+  it('attaches trace_id, turn_id and step_no to api_error from the failed request', async () => {
+    const model = createTracedModel(null);
+    Object.defineProperty(model, 'request', {
+      value: async function* () {
+        const events: LLMEvent[] = [];
+        for (const event of events) yield event;
+        throw new APIStatusError(500, 'boom', 'req-1', null, 'trace-fail-1');
+      },
+    });
+    Object.defineProperty(model, 'withMaxCompletionTokens', {
+      value: () => model,
+    });
+    const { service, telemetryRecords } = createService(model, passthroughProjector);
+    const request = service.start({ source: { type: 'turn', turnId: 3, step: 2 } });
+    await expect(request.result).rejects.toMatchObject({ statusCode: 500 });
+
+    expect(telemetryRecords).toContainEqual({
+      event: 'api_error',
+      properties: expect.objectContaining({
+        error_type: '5xx_server',
+        trace_id: 'trace-fail-1',
+        turn_id: 3,
+        step_no: 2,
+      }),
+    });
+    expect(request.trace.traceId).toBe('trace-fail-1');
+  });
+
+  it('keeps the header-captured trace when the request fails after headers arrived', async () => {
+    // A failure after the response headers arrived (empty response, mid-stream
+    // decode error) carries no trace on the error itself; the trace captured
+    // through the provider callback must remain on the request trace.
+    const model = createTracedModel(null);
+    Object.defineProperty(model, 'request', {
+      value: async function* (...args: unknown[]) {
+        const requestOptions = args[2] as
+          | { onTraceId?: (traceId: string | null) => void }
+          | undefined;
+        requestOptions?.onTraceId?.('trace-mid-stream');
+        const events: LLMEvent[] = [];
+        for (const event of events) yield event;
+        throw new APIEmptyResponseError('no content, no tool calls');
+      },
+    });
+    Object.defineProperty(model, 'withMaxCompletionTokens', {
+      value: () => model,
+    });
+    const { service, telemetryRecords } = createService(model, passthroughProjector);
+    const request = service.start({ source: { type: 'turn', turnId: 4, step: 1 } });
+    await expect(request.result).rejects.toThrow();
+
+    const apiError = telemetryRecords.find((record) => record.event === 'api_error');
+    expect(apiError?.properties?.['trace_id']).toBe('trace-mid-stream');
+    expect(request.trace.traceId).toBe('trace-mid-stream');
+  });
+
+  it('clears the previous physical request trace before a projection retry', async () => {
+    const model = createTracedModel(null);
+    let attempts = 0;
+    Object.defineProperty(model, 'request', {
+      value: async function* (...args: unknown[]) {
+        const events: LLMEvent[] = [];
+        for (const event of events) yield event;
+        attempts += 1;
+        const requestOptions = args[2] as
+          | { onTraceId?: (traceId: string | null) => void }
+          | undefined;
+        if (attempts === 1) {
+          requestOptions?.onTraceId?.('trace-first-projection');
+          throw new APIRequestTooLargeError(413, 'retry with degraded media');
+        }
+        throw new APIConnectionError('socket hang up');
+      },
+    });
+    Object.defineProperty(model, 'withMaxCompletionTokens', {
+      value: () => model,
+    });
+    const { service, telemetryRecords } = createService(model, passthroughProjector);
+    // Bound the error retry to a single loop attempt so the count pins the
+    // projection retry: physical request 1 (413) -> degraded resend 2 (socket
+    // hang up) -> terminal failure, no further error retries.
+    const request = service.start({ retry: { maxAttempts: 1 } });
+    await expect(request.result).rejects.toThrow('socket hang up');
+
+    expect(attempts).toBe(2);
+    expect(request.trace.traceId).toBeUndefined();
+    expect(
+      telemetryRecords.find((record) => record.event === 'api_error')?.properties?.['trace_id'],
+    ).toBeUndefined();
+  });
+});
diff --git a/packages/agent-core-v2/test/agent/loop/loop.test.ts b/packages/agent-core-v2/test/agent/loop/loop.test.ts
index 4ce9ee8c5..4be97f436 100644
--- a/packages/agent-core-v2/test/agent/loop/loop.test.ts
+++ b/packages/agent-core-v2/test/agent/loop/loop.test.ts
@@ -57,26 +57,27 @@ describe('Agent loop', () => {
       [wire] tools.set_active_tools      { "names": [], "time": "<time>" }
       [wire] turn.prompt                 { "input": [ { "type": "text", "text": "Hello" } ], "origin": { "kind": "user" }, "time": "<time>" }
       [emit] turn.started                { "turnId": 0, "origin": { "kind": "user" } }
-      [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Hello" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 3, "rawContextTokens": 3 }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] context.spliced             { "start": 0, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Hello" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" } ] }
+      [emit] agent.status.updated        { "contextTokens": 3, "rawContextTokens": 3 }
+      [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Hello" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
       [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 3, "rawContextTokens": 6 }
       [wire] llm.tools_snapshot          { "hash": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", "tools": [], "time": "<time>" }
       [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999997, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", "messageCount": 1, "turnStep": "0.1", "time": "<time>" }
       [emit] thinking.delta              { "turnId": 0, "delta": "<think-1>" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "thinking", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] assistant.delta             { "turnId": 0, "delta": "<text-1>" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 3, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
       [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 3, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 3, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 3, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] agent.status.updated        { "contextTokens": 13, "rawContextTokens": 16 }
-      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "think", "think": "<think-1>" } }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 13, "rawContextTokens": 20 }
-      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "<text-1>" } }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 13, "rawContextTokens": 23 }
-      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "end_turn", "usage": { "inputOther": 3, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 13, "rawContextTokens": 13 }
       [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 3, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "think", "think": "<think-1>" } }, "time": "<time>" }
+      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "<text-1>" } }, "time": "<time>" }
+      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "end_turn", "usage": { "inputOther": 3, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
       [emit] turn.ended                  { "turnId": 0, "reason": "completed" }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -97,23 +98,24 @@ describe('Agent loop', () => {
     expect(await ctx.untilTurnEnd()).toMatchInlineSnapshot(`
       [wire] turn.prompt                 { "input": [ { "type": "text", "text": "Hello" } ], "origin": { "kind": "user" }, "time": "<time>" }
       [emit] turn.started                { "turnId": 0, "origin": { "kind": "user" } }
-      [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Hello" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 3, "rawContextTokens": 3 }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] context.spliced             { "start": 0, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Hello" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" } ] }
+      [emit] agent.status.updated        { "contextTokens": 3, "rawContextTokens": 3 }
+      [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Hello" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
       [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 3, "rawContextTokens": 6 }
-      [wire] llm.tools_snapshot          { "hash": "e1c03bebb1298f76f76913ceac4f165154dcac73691b41c958927104c5a87dbf", "tools": [ { "name": "Agent", "description": "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\\n\\nWriting the prompt:\\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\\n\\nUsage notes:\\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its \`resume\` id) over spawning a fresh instance — the resumed agent keeps its prior context.\\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\\n- Subagents use a fixed 30-minute timeout. If one times out, resume the same agent instead of starting over.\\n\\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\\n\\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\\n\\n\\nWhen \`run_in_background=true\`, the subagent runs detached from this turn. The completion arrives in a later turn as a synthetic user-role message containing its result — you do not need to poll, sleep, or check on its progress. Continue with other work or respond to the user. Never fabricate or predict what the result will say.\\n\\nDefault to a foreground subagent (omit \`run_in_background\`) when your next step needs its result — foreground hands the result straight back. Reach for \`run_in_background=true\` only when you have other work to do while it runs and do not need its result to proceed. Never launch in the background and then immediately wait on it (with \`TaskOutput block=true\`, sleeping, or otherwise): that just blocks the turn for no benefit — run it in the foreground instead.\\n\\n\\nAvailable agent types (pass via subagent_type):\\n- plan: Read-only implementation planning and architecture design. Use this agent when the parent agent needs a step-by-step implementation plan, key file identification, and architectural trade-off analysis before code changes are made.\\n  Tools: Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL\\n- agent: Default Kimi Code agent\\n  Tools: Read, Write, Edit, Grep, Glob, Bash, TaskList, TaskOutput, TaskStop, CronCreate, CronList, CronDelete, ReadMediaFile, TodoList, Skill, WebSearch, Agent, AgentSwarm, FetchURL, AskUserQuestion, EnterPlanMode, ExitPlanMode, CreateGoal, GetGoal, SetGoalBudget, UpdateGoal, mcp__*, spine_open, spine_close, spine_next, spine_tree\\n- coder: General software engineering agent — the only subagent type with file-editing tools; use it for any delegated task that must modify code. Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.\\n  Tools: Agent, AgentSwarm, Bash, CronCreate, CronDelete, CronList, Edit, EnterPlanMode, ExitPlanMode, Glob, Grep, Read, ReadMediaFile, Skill, TaskList, TaskOutput, TaskStop, TodoList, WebSearch, FetchURL, Write, mcp__*\\n- explore: Fast codebase exploration with prompt-enforced read-only behavior. Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (e.g. \\"src/**/*.yaml\\"), search code for keywords (e.g. \\"database connection\\"), or answer questions about the codebase (e.g. \\"how does the auth module work?\\"). When calling this agent, specify the desired thoroughness level: \\"quick\\" for basic searches, \\"medium\\" for moderate exploration, or \\"thorough\\" for comprehensive analysis across multiple locations and naming conventions. Use this agent for any read-only exploration that will clearly require more than 3 search queries. Prefer launching multiple explore agents concurrently when investigating independent questions.\\n  Tools: Bash, Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "prompt": { "type": "string", "description": "Full task prompt for the subagent" }, "description": { "type": "string", "description": "Short task description (3-5 words) for UI display" }, "subagent_type": { "description": "One of the available agent types (see \\"Available agent types\\" in this tool description). Defaults to \\"coder\\" when omitted.", "type": "string" }, "resume": { "description": "Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected.", "type": "string" }, "run_in_background": { "description": "If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting.", "type": "boolean" } }, "required": [ "prompt", "description" ], "additionalProperties": false } }, { "name": "AgentSwarm", "description": "Launch multiple subagents from one prompt template, existing agent resumes, or both.\\n\\nUse AgentSwarm when many subagents should run the same kind of task over different inputs. The placeholder is exactly \`{{item}}\`. For example, with \`prompt_template\` set to \`Review {{item}} for likely regressions.\` and \`items\` set to \`[\\"src/a.ts\\", \\"src/b.ts\\"]\`, AgentSwarm launches two new subagents with those two concrete prompts. For a few differently-shaped tasks, make separate \`Agent\` calls in one message instead.\\n\\nUse \`resume_agent_ids\` to continue subagents that already exist from earlier work, such as ones that failed or timed out: map each agent id to the prompt for that resumed subagent (usually \`continue\` if no extra information is needed). You may combine \`resume_agent_ids\` with \`items\` in the same call to resume existing subagents and launch new ones. Do not duplicate resumed work in \`items\`.\\n\\nEach of these is enforced — a violation is rejected before any subagent starts: provide at least 2 \`items\` unless you pass \`resume_agent_ids\`; whenever \`items\` are present, \`prompt_template\` is required and must contain \`{{item}}\`; and the filled-in prompts must be distinct (two items that expand to the same prompt are rejected).\\n\\nUse enough subagents to keep the work focused and parallel. AgentSwarm supports up to 128 subagents, and launches are queued automatically, so it is safe to split large tasks into many clear, independent items.\\n\\nIf \`AgentSwarm\` is called, that call must be the only tool call in the response.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "description": { "type": "string", "minLength": 1, "description": "Short description for the whole swarm." }, "subagent_type": { "description": "Subagent type used for every new subagent spawned from items; defaults to coder when omitted. Resumed subagents always keep their original type, so passing subagent_type together with resume_agent_ids is allowed — it only affects the item-based spawns.", "type": "string", "minLength": 1 }, "prompt_template": { "description": "Prompt template for each subagent. The {{item}} placeholder is replaced with each item value.", "type": "string", "minLength": 1 }, "items": { "description": "Values used to fill {{item}}. Each item launches one new subagent.", "maxItems": 128, "type": "array", "items": { "type": "string", "minLength": 1 } }, "resume_agent_ids": { "description": "Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents.", "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "type": "string", "minLength": 1 } } }, "required": [ "description" ], "additionalProperties": false } }, { "name": "AskUserQuestion", "description": "Use this tool when you need to ask the user questions with structured options during execution. This allows you to:\\n1. Collect user preferences or requirements before proceeding\\n2. Resolve ambiguous or underspecified instructions\\n3. Let the user decide between implementation approaches as you work\\n4. Present concrete options when multiple valid directions exist\\n\\n**When NOT to use:**\\n- When you can infer the answer from context — be decisive and proceed\\n- Trivial decisions that don't materially affect the outcome\\n\\nOverusing this tool interrupts the user's flow. Only use it when the user's input genuinely changes your next action.\\n\\n**Usage notes:**\\n- Users always have an \\"Other\\" option for custom input — don't create one yourself\\n- Use multi_select to allow multiple answers to be selected for a question\\n- Keep option labels concise (1-5 words), use descriptions for trade-offs and details\\n- Each question should have 2-4 meaningful, distinct options\\n- Question texts must be unique across the call, and option labels must be unique within each question\\n- You can ask 1-4 questions at a time; group related questions to minimize interruptions\\n- If you recommend a specific option, list it first and append \\"(Recommended)\\" to its label\\n- The result is JSON with an \`answers\` object keyed by question text; each value is the chosen option's label (comma-separated labels for multi_select, or the user's own words if they picked \\"Other\\"); if \`answers\` is empty and a \`note\` says the user dismissed it, they chose not to answer — do not treat this as selecting the recommended option; decide based on context and do not re-ask the same question\\n- Set background=true when you can keep working without the answer. This starts a background question task and returns a task_id immediately. The answer arrives automatically in a later turn — you do not need to poll, sleep, or check on it. Continue with other work; never fabricate or predict the answer.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "questions": { "minItems": 1, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "question": { "type": "string", "minLength": 1, "description": "A specific, actionable question. End with '?'." }, "header": { "default": "", "description": "Short category tag (max 12 chars, e.g. 'Auth', 'Style').", "type": "string" }, "options": { "minItems": 2, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "description": "Concise display text (1-5 words). If recommended, append '(Recommended)'." }, "description": { "default": "", "description": "Brief explanation of trade-offs or implications.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false }, "description": "2-4 meaningful, distinct options. Do NOT include an 'Other' option — the system adds one automatically." }, "multi_select": { "default": false, "description": "Whether the user can select multiple options.", "type": "boolean" } }, "required": [ "question", "options" ], "additionalProperties": false }, "description": "The questions to ask the user (1-4 questions)." }, "background": { "default": false, "description": "Set true to ask in the background and return immediately with a background task_id; you are notified automatically when the user answers — do not poll with TaskOutput while the question is pending.", "type": "boolean" } }, "required": [ "questions" ], "additionalProperties": false } }, { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nIf \`run_in_background=true\`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short \`description\`. Background commands default to a 600s timeout and \`timeout\` is capped at 86400s; set \`disable_timeout=true\` only when the task should run without a timeout. You will be automatically notified when the task completes. After starting one, default to returning control to the user instead of immediately waiting on it. Use \`TaskOutput\` only for a non-blocking status/output snapshot — do not set \`block=true\` to wait for a task you just launched, since its completion arrives automatically; reserve \`block=true\` for when the user explicitly asked you to wait. Use \`TaskStop\` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the \`/tasks\` command, which opens an interactive panel; it has no subcommands.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the \`timeout\` argument in seconds. Foreground commands default to 60s and allow up to 300s. When a foreground command hits its timeout it is moved to the background instead of being killed, and you will be automatically notified when it completes.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Prefer \`run_in_background=true\` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } }, { "name": "CreateGoal", "description": "Create a durable, structured goal that the runtime will pursue across multiple turns.\\n\\nCall \`CreateGoal\` only when:\\n\\n- the user explicitly asks you to start a goal or work autonomously toward an outcome, or\\n- a host goal-intake prompt asks you to create one.\\n\\nDo NOT create a goal for greetings, ordinary questions, or vague requests that lack a\\nverifiable completion condition. A goal needs a checkable end state.\\n\\nWhen the request is vague, ask the user for the missing completion criterion before creating\\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\\nrespect that and create the goal.\\n\\nInclude a \`completionCriterion\` when the user provides one, or when it can be stated without\\ninventing new requirements. Keep \`objective\` concise; reference long task descriptions by file\\npath rather than pasting them.\\n\\nCreating a goal fails if one already exists, so use \`replace: true\` only when the user explicitly\\nwants to abandon the current goal and start a new one.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "objective": { "type": "string", "minLength": 1, "description": "The objective to pursue. Must have a verifiable end state." }, "completionCriterion": { "description": "How to verify the goal is complete. Include when the user provides one.", "type": "string" }, "replace": { "description": "Replace an existing active, paused, or blocked goal instead of failing.", "type": "boolean" } }, "required": [ "objective" ], "additionalProperties": false } }, { "name": "Edit", "description": "Perform exact replacements in existing files.\\n\\n- Edit is mandatory for every incremental change, especially small edits. DO NOT use Write or Bash \`sed\`.\\n- Read the target file before every Edit. DO NOT call Edit from memory, stale context, or a guessed \`old_string\`.\\n- Take \`old_string\` and \`new_string\` from the Read output view.\\n- Drop the line-number prefix and tab; match only file content.\\n- \`old_string\` must be unique unless \`replace_all\` is set.\\n- If \`old_string\` is ambiguous, add surrounding context. Use \`replace_all\` only when every occurrence should change — for example, renaming a symbol throughout the file.\\n- Multiple Edit calls may run in one response only when they do not target the same file.\\n- DO NOT issue consecutive Edit calls on the same file. A previous Edit can invalidate a later Edit's \`old_string\`, causing \`old_string not found\`. Read the file again before the next Edit.\\n- A write lock serializes same-file edits in response order, but serialization does not make stale \`old_string\` valid.\\n- For pure CRLF files, Read shows LF; use LF in \`old_string\` and \`new_string\`, and Edit writes CRLF back.\\n- For mixed endings or lone carriage returns, Read shows carriage returns as \\\\r; include actual \\\\r escapes in those positions.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the text file to edit. Relative paths resolve against the working directory; a path outside the working directory must be absolute." }, "old_string": { "type": "string", "minLength": 1, "description": "Exact content to replace from the Read output view, without the line-number prefix. Use LF for pure CRLF files; use actual \\\\r escapes where Read shows \\\\r." }, "new_string": { "type": "string", "description": "Replacement text in the same Read output view. LF is written back as CRLF only for pure CRLF files." }, "replace_all": { "description": "Set true only when every occurrence of old_string should be replaced.", "type": "boolean" } }, "required": [ "path", "old_string", "new_string" ], "additionalProperties": false } }, { "name": "EnterPlanMode", "description": "Use this tool proactively when you're about to start a non-trivial implementation task.\\nGetting user sign-off on your approach via ExitPlanMode before writing code prevents wasted effort.\\n\\nUse it when ANY of these conditions apply:\\n\\n1. New Feature Implementation - e.g. \\"Add a caching layer to the API\\"\\n2. Multiple Valid Approaches - e.g. \\"Optimize database queries\\" (indexing vs rewrite vs caching)\\n3. Code Modifications - e.g. \\"Refactor auth module to support OAuth\\"\\n4. Architectural Decisions - e.g. \\"Add WebSocket support\\"\\n5. Multi-File Changes - involves more than 2-3 files\\n6. Unclear Requirements - need exploration to understand scope\\n7. User Preferences Matter - if user input would materially change the implementation approach, use EnterPlanMode to structure the decision\\n\\nPermission mode notes:\\n- EnterPlanMode enters plan mode automatically without an approval prompt in all permission modes.\\n- In yolo and manual modes, ExitPlanMode still presents the plan to the user for approval.\\n- In auto permission mode, do not use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, ExitPlanMode exits plan mode without asking the user.\\n- Use EnterPlanMode only when planning itself adds value.\\n\\nWhen NOT to use:\\n- Single-line or few-line fixes (typos, obvious bugs, small tweaks)\\n- User gave very specific, detailed instructions\\n- Pure research/exploration tasks\\n\\nOnce you are in plan mode, a reminder walks you through the workflow (explore → design → write the plan file → \`ExitPlanMode\`) and enforces read-only access. For non-trivial tasks where you are unsure of the codebase structure or relevant code paths, use \`Agent(subagent_type=\\"explore\\")\` to investigate first when the \`Agent\` tool is available.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "ExitPlanMode", "description": "Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.\\n\\n## How This Tool Works\\n- You should have already written your plan to the plan file specified in the plan mode reminder.\\n- This tool does NOT take the plan content as a parameter - it reads the plan from the file you wrote.\\n- The user will see the contents of your plan file when they review it. In auto permission mode, the tool reads the file and exits plan mode without asking the user.\\n\\n## When to Use\\nOnly use this tool for tasks that require planning implementation steps. For research tasks (searching files, reading code, understanding the codebase), do NOT use this tool.\\n\\n## What a good plan contains\\nList specific, verifiable steps grounded in the actual codebase — real files, functions, and commands, in a sensible order. Each step should be concrete enough to act on and to check. Avoid vague filler like \\"improve performance\\" or \\"add tests\\"; say what to change and where.\\n\\n## Multiple Approaches\\nIf your plan offers multiple alternative approaches, pass them via the \`options\` parameter so the user can choose which one to execute — see the \`options\` parameter for the format, count, and reserved labels. In yolo and manual modes the user sees all options alongside the host's Reject and Revise controls.\\n\\n## Before Using\\n- In auto permission mode, do NOT use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, this tool exits plan mode without asking the user.\\n- In yolo and manual modes, this tool still presents the plan to the user for approval.\\n- If auto permission mode is not active and you have unresolved questions, use AskUserQuestion first.\\n- If auto permission mode is not active and you have multiple approaches and haven't narrowed down yet, consider using AskUserQuestion first to let the user choose, then write a plan for the chosen approach only.\\n- Once your plan is finalized, use THIS tool to request approval.\\n- Do NOT use AskUserQuestion to ask \\"Is this plan OK?\\" or \\"Should I proceed?\\" - that is exactly what ExitPlanMode does.\\n- If rejected, revise based on feedback and call ExitPlanMode again.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "options": { "description": "When the plan contains multiple alternative approaches, list them here so the user can choose which one to execute. Provide up to 3 options; 2-3 distinct approaches work best when the plan offers a real choice. Passing a single option is allowed and is equivalent to a plain plan approval. Each option represents a distinct approach from the plan. Do not use \\"Reject\\", \\"Revise\\", \\"Approve\\", or \\"Reject and Exit\\" as labels.", "minItems": 1, "maxItems": 3, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "maxLength": 80, "description": "Short name for this option (1-8 words). Append \\"(Recommended)\\" if you recommend this option." }, "description": { "default": "", "description": "Brief summary of this approach and its trade-offs.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "FetchURL", "description": "Fetch content from a URL. The content is returned either as the main text extracted from the page, or as the full response body verbatim; a note at the top of the result states which of the two you received, so you can judge how complete it is. Use this when you need to read a specific web page.\\n\\nOnly fully-formed public \`http\`/\`https\` URLs are supported; other schemes and private or loopback addresses are not fetched. Very large pages may be truncated or refused. The fetch carries no login or session for the target site, so pages behind authentication (private repositories, internal dashboards) return a login page or an error instead of the real content — if the text you get back looks like a generic landing or sign-in page, treat that as the login wall, not the answer, and reach the content through a credentialed route (an authenticated CLI or MCP tool) instead.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "url": { "type": "string", "description": "The URL to fetch content from." } }, "required": [ "url" ], "additionalProperties": false } }, { "name": "GetGoal", "description": "Read the current goal: its objective, completion criterion, status, and budgets (turns, tokens,\\ntime, and how much of each remains). When the goal has stopped, it also reports the terminal reason.\\n\\nUse \`GetGoal\` before deciding whether to continue working, report completion, report a blocker,\\nor respect a pause. It returns \`{ \\"goal\\": null }\` when there is no current goal.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "Glob", "description": "Find files by glob pattern, sorted by modification time (most recent first).\\n\\nPowered by ripgrep. Respects \`.gitignore\`, \`.ignore\`, and \`.rgignore\` by default — set \`include_ignored\` to also match ignored files (e.g. build outputs, \`node_modules\`). Sensitive files (such as \`.env\`) are always filtered out. Matches are files only — directories themselves are never listed; to find a directory, glob for a file inside it (e.g. \`**/fixtures/**\`).\\n\\nGood patterns:\\n- \`*.ts\` — all files matching an extension, at any depth below the search root (a bare pattern without \`/\` matches recursively)\\n- \`src/*.ts\` — files directly inside \`src/\` (one level, not recursive)\\n- \`src/**/*.ts\` — recursive walk with a subdirectory anchor and extension\\n- \`**/*.py\` — recursive walk from the search root for an extension\\n- \`*.{ts,tsx}\` — brace expansion is supported\\n- \`{src,test}/**/*.ts\` — cartesian brace expansion is supported too\\n\\nResults are capped at the first 100 matching paths. If a search would return more, a truncation marker is appended. Refine the pattern (extension, subdirectory) when 100 is not enough, or call again with a narrower anchor.\\n\\nLarge-directory caveat — avoid recursing into dependency / build output even with an anchor, especially when \`include_ignored\` is set:\\n- \`node_modules/**/*.js\`, \`.venv/**/*.py\`, \`__pycache__/**\`, \`target/**\` can produce thousands of results that truncate at the match cap and waste context. Prefer specific subpaths like \`node_modules/react/src/**/*.js\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Glob pattern to match files." }, "path": { "description": "Directory to search. Accepts an absolute path, or a path relative to the current working directory. Defaults to the current working directory.", "type": "string" }, "include_ignored": { "description": "Also match files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" }, "include_dirs": { "description": "Deprecated and ignored. Results are always files-only — directories are never listed. Accepted only so older calls that still pass this flag are not rejected by parameter validation.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Grep", "description": "Search file contents using regular expressions (powered by ripgrep).\\n\\nUse Grep when the task is to find unknown content or unknown file locations. Do not use shell \`grep\` or \`rg\` directly; this tool applies workspace path policy, output limits, and sensitive-file filtering.\\nALWAYS use Grep tool instead of running \`grep\` or \`rg\` from a shell — direct shell calls bypass workspace policy, output limits, and sensitive-file filtering.\\nIf you already know a concrete file path and need to inspect its contents, use Read directly instead.\\n\\nWrite patterns in ripgrep regex syntax, which differs from POSIX \`grep\` syntax. For example, braces are special, so escape them as \`\\\\{\` to match a literal \`{\`.\\n\\nHidden files (dotfiles such as \`.gitlab-ci.yml\` or \`.eslintrc.json\`) are searched by default. To also search files excluded by \`.gitignore\` (such as \`node_modules\` or build outputs), set \`include_ignored\` to \`true\`. Sensitive files (such as \`.env\`) are always skipped for safety, even when \`include_ignored\` is \`true\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Regular expression to search for." }, "path": { "description": "File or directory to search. Accepts an absolute path, or a path relative to the current working directory. Omit to search the current working directory. Use Read instead when you already know a concrete file path and need its contents.", "type": "string" }, "glob": { "description": "Optional glob filter for which files to search, e.g. \`*.ts\`. Matched against each file's full absolute path, so a path-anchored pattern like \`src/**/*.ts\` silently matches nothing — use a basename pattern (\`*.ts\`), or anchor with \`**/\` (\`**/src/**/*.ts\`). To scope the search to a directory, use \`path\` instead.", "type": "string" }, "type": { "description": "Optional ripgrep file type filter, such as ts or py. Prefer this over \`glob\` when filtering by language or file kind: it is more efficient and less error-prone than an equivalent glob pattern.", "type": "string" }, "output_mode": { "description": "Shape of the result. \`content\` shows matching lines (honors \`-A\`, \`-B\`, \`-C\`, \`-n\`, and \`head_limit\`); \`files_with_matches\` shows only the paths of files that contain a match, most-recently-modified first (honors \`head_limit\`); \`count_matches\` shows per-file match counts as \`path:count\` lines, preceded by an aggregate total line. Defaults to \`files_with_matches\`.", "type": "string", "enum": [ "content", "files_with_matches", "count_matches" ] }, "-i": { "description": "Perform a case-insensitive search. Defaults to false.", "type": "boolean" }, "-n": { "description": "Prefix each matching line with its line number. Applies only when \`output_mode\` is \`content\`. Defaults to true.", "type": "boolean" }, "-A": { "description": "Number of lines to show after each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-B": { "description": "Number of lines to show before each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-C": { "description": "Number of lines to show before and after each match. Applies only when \`output_mode\` is \`content\`; takes precedence over \`-A\` and \`-B\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "head_limit": { "description": "Limit output to the first N lines/entries after offset. Defaults to 250. Pass 0 for unlimited.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "offset": { "description": "Number of leading lines/entries to skip before applying \`head_limit\`. Use it together with \`head_limit\` to page through large result sets. Defaults to 0.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "multiline": { "description": "Enable multiline matching, where the pattern can span line boundaries and \`.\` also matches newlines. Defaults to false.", "type": "boolean" }, "include_ignored": { "description": "Also search files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Read", "description": "Read a text file from the local filesystem.\\n\\nIf the user provides a concrete file path to a text file, call Read directly. Do not \`Glob\`, \`ls\`, or otherwise pre-check known text file paths; missing or invalid file paths return errors you can handle. Do not use Read for directories; use \`ls\` via Bash for a known directory, or Glob when you need files matching a name pattern (Glob lists files only, never directories). Use \`Grep\` only when the task is to search for unknown content or locations.\\n\\nWhen you need several files, prefer to read them in parallel: emit multiple \`Read\` calls in a single response instead of reading one file per turn.\\n\\n- Relative paths resolve against the working directory; a path outside the working directory must be absolute.\\n- Returns up to 1000 lines or 100 KB per call, whichever comes first; lines longer than 2000 chars are truncated mid-line.\\n- Page larger files with \`line_offset\` (1-based start line) and \`n_lines\`. Omit \`n_lines\` to read up to the 1000-line cap.\\n- Sensitive files (\`.env\` files, credential stores, SSH private keys, and similar secrets) are refused to protect secrets; do not attempt to read them. Templates and public keys are exempt: \`.env.example\` / \`.env.sample\` / \`.env.template\` and public SSH keys such as \`id_rsa.pub\` read normally.\\n- Only UTF-8 text files can be read. Non-UTF-8 encodings, binary files, and files containing NUL bytes are refused; use \`ReadMediaFile\` for images or video, and Bash or an MCP tool for other binary formats.\\n- Negative line_offset reads from the end of the file (for example, -100 reads the last 100 lines); the absolute value cannot exceed 1000.\\n- Output format: \`<line-number>\\\\t<content>\` per line.\\n- A \`<system>...</system>\` status block is appended after the file content; it summarizes how much was read (line and byte counts, truncation, line-ending notes) and is not part of the file itself.\\n- Pure CRLF files are displayed with LF line endings; \`Edit\` matches this output and preserves CRLF when writing back.\\n- Mixed or lone carriage-return line endings are shown as \`\\\\r\` and require exact \`Edit.old_string\` escapes.\\n- After a successful \`Edit\`/\`Write\`, do not re-read solely to prove the write landed. When the task depends on an exact file, API, or output shape, inspect the final external contract before finishing.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to a text file. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Directories are not supported; use \`ls\` via Bash for a known directory, or Glob for pattern search." }, "line_offset": { "description": "The line number to start reading from. Omit to start at line 1. Negative values read from the end of the file; the absolute value cannot exceed 1000.", "anyOf": [ { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, { "type": "integer", "minimum": -1000, "maximum": -1 } ] }, "n_lines": { "description": "The number of lines to read; the tool also applies its internal cap. Omit to read up to the internal cap of 1000 lines.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 } }, "required": [ "path" ], "additionalProperties": false } }, { "name": "SetGoalBudget", "description": "Set a hard budget limit for the current goal.\\n\\nUse this only when the user clearly gives a runtime limit, such as:\\n\\n- \\"stop after 20 turns\\"\\n- \\"use no more than 500k tokens\\"\\n- \\"finish within 30 minutes\\"\\n\\nDo not invent limits. Do not call this for vague wording such as \\"spend some time\\" or\\n\\"try to be quick\\".\\n\\nIf the user gives a compound time, convert it to one supported unit before calling this tool.\\nFor example, \\"2 hours and 3 minutes\\" can be set as \`value: 123, unit: \\"minutes\\"\`.\\n\\nA time budget must be between 1 second and 24 hours — the tool rejects anything shorter or\\nlonger, telling the user it is not a reasonable goal budget. Turn and token budgets are not\\nbounded this way; they must be positive and are rounded to the nearest whole number (minimum 1).\\n\\nSupported units:\\n\\n- \`turns\`\\n- \`tokens\`\\n- \`milliseconds\`\\n- \`seconds\`\\n- \`minutes\`\\n- \`hours\`\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "value": { "type": "number", "exclusiveMinimum": 0, "description": "The positive numeric budget value." }, "unit": { "type": "string", "enum": [ "turns", "tokens", "milliseconds", "seconds", "minutes", "hours" ] } }, "required": [ "value", "unit" ], "additionalProperties": false } }, { "name": "Skill", "description": "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a \`<kimi-skill-loaded>\` block for it with the same \`args\` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier \`args\` and will not reflect new inputs.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "skill": { "type": "string", "description": "The exact name of the skill to invoke, spelled as it appears in the current skill listing (e.g. \\"commit\\", \\"pdf\\")." }, "args": { "description": "Optional argument string for the skill, written like a command line (e.g. \`-m \\"fix bug\\"\`, \`123\`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing \`ARGUMENTS:\` line. Omit it only when there is nothing to pass.", "type": "string" } }, "required": [ "skill" ], "additionalProperties": false } }, { "name": "TaskList", "description": "List background tasks and their current status.\\n\\nUse this tool to discover which background tasks exist and where each one\\nstands. It is the entry point for inspecting background work: it returns a\\ntask ID, status, and description for every task it reports, plus the command,\\nPID, and (once finished) exit code for shell tasks, and a stop reason for any\\ntask that ended early.\\n\\nGuidelines:\\n\\n- After a context compaction, or whenever you are unsure which background\\n  tasks are running or what their task IDs are, call this tool to\\n  re-enumerate them instead of guessing a task ID.\\n- Prefer the default \`active_only=true\`, which lists only non-terminal tasks.\\n  Pass \`active_only=false\` only when you specifically need to see tasks that\\n  have already finished. With \`active_only=false\` the result may also include\\n  \`lost\` tasks — tasks left over from a previous process that can no longer be\\n  inspected or controlled; treat them as already terminated.\\n- \`limit\` caps how many tasks are returned. It accepts a value between 1 and\\n  100 and defaults to 20 when omitted.\\n- This tool only lists tasks; it does not return their output. Use it first\\n  to locate the task ID you need, then call \`TaskOutput\` with that ID to read\\n  the task's output and details.\\n- This tool is read-only and does not change any state, so it is always safe\\n  to call, including in plan mode.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "active_only": { "default": true, "description": "Whether to list only non-terminal background tasks.", "type": "boolean" }, "limit": { "default": 20, "description": "Maximum number of tasks to return.", "type": "integer", "minimum": 1, "maximum": 100 } }, "additionalProperties": false } }, { "name": "TaskOutput", "description": "Retrieve a snapshot of a running or completed background task.\\n\\nUse this after \`Bash(run_in_background=true)\` or \`Agent(run_in_background=true)\` to check progress, or to read the output of a task that has already completed.\\n\\nGuidelines:\\n- Prefer relying on automatic completion notifications. Use this tool only when you need task output before the automatic notification arrives.\\n- By default this tool is non-blocking and returns a current status/output snapshot — that is the normal way to use it.\\n- Do not use TaskOutput to wait for a result you need before continuing — if your next step depends on the task's result, run that task in the foreground instead. TaskOutput is for a deliberate progress check you will act on without blocking, not a way to sit and wait for a background task you just launched.\\n- Use block=true only when the user explicitly asked you to wait for the task. Never block on a task you launched in the current turn — if you need its result right away, it should have been a foreground call.\\n- If a block=true call returns \`retrieval_status: timeout\` (the task is still running), do not block on the same task again. Continue with other work or hand back to the user — the completion notification arrives on its own.\\n- This tool returns structured task metadata, a fixed-size output preview, and an output_path for the full log.\\n- For a terminal task, the metadata also explains why it ended. A shell command that runs to completion reports \`status: completed\` on a zero exit, or \`status: failed\` with its non-zero \`exit_code\` — judge that failure from the \`exit_code\`, because a plain command failure carries no \`stop_reason\` and no \`terminal_reason\`. \`terminal_reason\` is a categorical label emitted only when the end is not an ordinary exit: \`timed_out\` when the deadline aborted it, \`stopped\` when it was explicitly stopped, or \`failed\` when it errored without producing an exit code; the \`stopped\` and \`failed\` cases also carry a human-readable \`stop_reason\`. A task that finished on its own with a clean exit carries neither \`stop_reason\` nor \`terminal_reason\`.\\n- The full, never-truncated log is always available at output_path; use the \`Read\` tool with that path to page through it, whether or not the preview was truncated.\\n- This tool works with the generic background task system and should remain the primary read path for future task types, not just bash.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to inspect." }, "block": { "default": false, "description": "Whether to wait for the task to finish before returning. Discouraged — background tasks notify automatically on completion; use only when the user explicitly asked you to wait.", "type": "boolean" }, "timeout": { "default": 30, "description": "Maximum number of seconds to wait when block=true.", "type": "integer", "minimum": 0, "maximum": 3600 } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TaskStop", "description": "Stop a running background task.\\n\\nOnly use this when a task must genuinely be cancelled — for a task that is\\nfinishing normally, wait for its completion notification or inspect it with\\n\`TaskOutput\` instead of stopping it.\\n\\nGuidelines:\\n- This is a general-purpose stop capability for any background task. It is not\\n  a bash-specific kill.\\n- Stopping a task is destructive: it may leave partial side effects behind.\\n  Use it with care.\\n- If the task has already finished, this tool simply returns its current\\n  status.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to stop." }, "reason": { "default": "Stopped by TaskStop", "description": "Short reason recorded when the task is stopped.", "type": "string" } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TodoList", "description": "Use this tool to maintain a structured TODO list as you work through a multi-step task. Use it proactively and often when progress tracking helps the current work. This is especially useful in long-running investigations and implementation tasks with several tool calls; in plan mode, write the plan to the plan file rather than tracking it here.\\n\\n**When to use:**\\n- Multi-step tasks that span several tool calls\\n- Tracking investigation progress across a large codebase search\\n- Planning a sequence of edits before making them\\n- After receiving new multi-step instructions, capture the requirements as todos\\n- Before starting a tracked task, mark exactly one item as \`in_progress\`\\n- Immediately after finishing a tracked task, mark it \`done\`; do not batch completions at the end\\n\\n**When NOT to use:**\\n- Single-shot answers that complete in one or two tool calls\\n- Trivial requests where tracking adds no clarity\\n- Purely conversational or informational replies\\n\\n**Avoid churn:**\\n- Do not re-call this tool when nothing meaningful has changed since the last call — update the list only after real progress.\\n- When unsure of the current state, call query mode first (omit \`todos\`) to check the list before deciding what to update.\\n- If no available tool can move any task forward, tell the user where you are stuck instead of repeatedly re-ordering the same todos.\\n\\n**How to use:**\\n- Call with \`todos: [...]\` to replace the full list. Statuses: pending / in_progress / done.\\n- Call with no \`todos\` argument to retrieve the current list without changing it.\\n- Call with \`todos: []\` to clear the list.\\n- Keep titles short and actionable (e.g. \\"Read session-control.ts\\", \\"Add planMode flag to TurnManager\\").\\n- Update statuses as you make progress.\\n- When work is underway, keep exactly one task \`in_progress\`.\\n- Only mark a task \`done\` when it is fully accomplished.\\n- Never mark a task \`done\` if tests are failing, implementation is partial, unresolved errors remain, or required files/dependencies could not be found.\\n- If you encounter a blocker, keep the blocked task \`in_progress\` or add a new pending task describing what must be resolved.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "todos": { "description": "The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.", "type": "array", "items": { "type": "object", "properties": { "title": { "type": "string", "minLength": 1, "description": "Short, actionable title for the todo." }, "status": { "type": "string", "enum": [ "pending", "in_progress", "done" ], "description": "Current status of the todo." } }, "required": [ "title", "status" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "UpdateGoal", "description": "Set the status of the current goal. This is how you resume, complete, or block an autonomous goal.\\n\\n- \`active\` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\\n- \`complete\` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded. Before using this, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not use \`complete\` merely because a budget is nearly exhausted or you want to stop.\\n- \`blocked\` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. For non-terminal blockers, do not use \`blocked\` the first time you hit the blocker. The same blocking condition must repeat for at least 3 consecutive goal turns before you call \`blocked\`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. If the objective itself is impossible, unsafe, or contradictory, call \`blocked\` in the same turn instead of running more goal turns. Do not use \`blocked\` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call \`blocked\` instead of leaving the goal active.\\n\\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call \`complete\` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not call \`complete\` after only producing a plan, summary, first pass, or partial result. Call \`blocked\` only after the blocked audit threshold is met. If you call \`blocked\`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "status": { "type": "string", "enum": [ "active", "complete", "blocked" ], "description": "The lifecycle status to set for the current goal. Use \`blocked\` for impossible, unsafe, or contradictory objectives, or after the same non-terminal blocking condition repeats for at least 3 consecutive goal turns." } }, "required": [ "status" ], "additionalProperties": false } }, { "name": "Write", "description": "Create, append to, or replace a file entirely.\\n\\n- Missing parent directories are created automatically (like \`mkdir(parents=True, exist_ok=True)\`).\\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\\n- Do not create unsolicited documentation files (\`*.md\` write-ups, \`README\`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\\n- Read before overwriting an existing file.\\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\\n- Write outputs content literally, including supplied line endings: \\\\n stays LF, \\\\r\\\\n stays CRLF.\\n- For new content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically." }, "content": { "type": "string", "description": "Raw full file content to write exactly as provided. This does not use the Read/Edit text view." }, "mode": { "description": "Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline.", "type": "string", "enum": [ "overwrite", "append" ] } }, "required": [ "path", "content" ], "additionalProperties": false } } ], "time": "<time>" }
-      [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999997, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "e1c03bebb1298f76f76913ceac4f165154dcac73691b41c958927104c5a87dbf", "messageCount": 1, "turnStep": "0.1", "time": "<time>" }
+      [wire] llm.tools_snapshot          { "hash": "b0e35cedccd898afc718a76e65bcb9fb84b7657958a03a95d49f40a40b99a81f", "tools": [ { "name": "Agent", "description": "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\\n\\nWriting the prompt:\\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\\n\\nUsage notes:\\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its \`resume\` id) over spawning a fresh instance — the resumed agent keeps its prior context.\\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\\n- Subagents use a fixed 2-hour timeout. If one times out, resume the same agent instead of starting over.\\n\\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\\n\\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\\n\\n\\nWhen \`run_in_background=true\`, the subagent runs detached from this turn. The completion arrives in a later turn as a synthetic user-role message containing its result — you do not need to poll, sleep, or check on its progress. Continue with other work or respond to the user. Never fabricate or predict what the result will say.\\n\\nDefault to a foreground subagent (omit \`run_in_background\`) when your next step needs its result — foreground hands the result straight back. Reach for \`run_in_background=true\` only when you have other work to do while it runs and do not need its result to proceed. Never launch in the background and then immediately wait on it (with \`TaskOutput block=true\`, sleeping, or otherwise): that just blocks the turn for no benefit — run it in the foreground instead.\\n\\n\\nAvailable agent types (pass via subagent_type):\\n- plan: Read-only implementation planning and architecture design. Use this agent when the parent agent needs a step-by-step implementation plan, key file identification, and architectural trade-off analysis before code changes are made.\\n  Tools: Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL\\n- agent: Default Kimi Code agent\\n  Tools: Read, Write, Edit, Grep, Glob, Bash, TaskList, TaskOutput, TaskStop, CronCreate, CronList, CronDelete, ReadMediaFile, TodoList, Skill, WebSearch, Agent, AgentSwarm, FetchURL, AskUserQuestion, EnterPlanMode, ExitPlanMode, CreateGoal, GetGoal, SetGoalBudget, UpdateGoal, mcp__*, spine_open, spine_close, spine_next, spine_tree\\n- coder: General software engineering agent — the only subagent type with file-editing tools; use it for any delegated task that must modify code. Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.\\n  Tools: Agent, AgentSwarm, Bash, CronCreate, CronDelete, CronList, Edit, EnterPlanMode, ExitPlanMode, Glob, Grep, Read, ReadMediaFile, Skill, TaskList, TaskOutput, TaskStop, TodoList, WebSearch, FetchURL, Write, mcp__*\\n- explore: Fast codebase exploration with prompt-enforced read-only behavior. Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (e.g. \\"src/**/*.yaml\\"), search code for keywords (e.g. \\"database connection\\"), or answer questions about the codebase (e.g. \\"how does the auth module work?\\"). When calling this agent, specify the desired thoroughness level: \\"quick\\" for basic searches, \\"medium\\" for moderate exploration, or \\"thorough\\" for comprehensive analysis across multiple locations and naming conventions. Use this agent for any read-only exploration that will clearly require more than 3 search queries. Prefer launching multiple explore agents concurrently when investigating independent questions.\\n  Tools: Bash, Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "prompt": { "type": "string", "description": "Full task prompt for the subagent" }, "description": { "type": "string", "description": "Short task description (3-5 words) for UI display" }, "subagent_type": { "description": "One of the available agent types (see \\"Available agent types\\" in this tool description). Defaults to \\"coder\\" when omitted.", "type": "string" }, "resume": { "description": "Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected.", "type": "string" }, "run_in_background": { "description": "If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting.", "type": "boolean" } }, "required": [ "prompt", "description" ], "additionalProperties": false } }, { "name": "AgentSwarm", "description": "Launch multiple subagents from one prompt template, existing agent resumes, or both.\\n\\nUse AgentSwarm when many subagents should run the same kind of task over different inputs. The placeholder is exactly \`{{item}}\`. For example, with \`prompt_template\` set to \`Review {{item}} for likely regressions.\` and \`items\` set to \`[\\"src/a.ts\\", \\"src/b.ts\\"]\`, AgentSwarm launches two new subagents with those two concrete prompts. For a few differently-shaped tasks, make separate \`Agent\` calls in one message instead.\\n\\nUse \`resume_agent_ids\` to continue subagents that already exist from earlier work, such as ones that failed or timed out: map each agent id to the prompt for that resumed subagent (usually \`continue\` if no extra information is needed). You may combine \`resume_agent_ids\` with \`items\` in the same call to resume existing subagents and launch new ones. Do not duplicate resumed work in \`items\`.\\n\\nEach of these is enforced — a violation is rejected before any subagent starts: provide at least 2 \`items\` unless you pass \`resume_agent_ids\`; whenever \`items\` are present, \`prompt_template\` is required and must contain \`{{item}}\`; and the filled-in prompts must be distinct (two items that expand to the same prompt are rejected).\\n\\nUse enough subagents to keep the work focused and parallel. AgentSwarm supports up to 128 subagents, and launches are queued automatically, so it is safe to split large tasks into many clear, independent items.\\n\\nIf \`AgentSwarm\` is called, that call must be the only tool call in the response.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "description": { "type": "string", "minLength": 1, "description": "Short description for the whole swarm." }, "subagent_type": { "description": "Subagent type used for every new subagent spawned from items; defaults to coder when omitted. Resumed subagents always keep their original type, so passing subagent_type together with resume_agent_ids is allowed — it only affects the item-based spawns.", "type": "string", "minLength": 1 }, "prompt_template": { "description": "Prompt template for each subagent. The {{item}} placeholder is replaced with each item value.", "type": "string", "minLength": 1 }, "items": { "description": "Values used to fill {{item}}. Each item launches one new subagent.", "maxItems": 128, "type": "array", "items": { "type": "string", "minLength": 1 } }, "resume_agent_ids": { "description": "Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents.", "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "type": "string", "minLength": 1 } } }, "required": [ "description" ], "additionalProperties": false } }, { "name": "AskUserQuestion", "description": "Use this tool when you need to ask the user questions with structured options during execution. This allows you to:\\n1. Collect user preferences or requirements before proceeding\\n2. Resolve ambiguous or underspecified instructions\\n3. Let the user decide between implementation approaches as you work\\n4. Present concrete options when multiple valid directions exist\\n\\n**When NOT to use:**\\n- When you can infer the answer from context — be decisive and proceed\\n- Trivial decisions that don't materially affect the outcome\\n\\nOverusing this tool interrupts the user's flow. Only use it when the user's input genuinely changes your next action.\\n\\n**Usage notes:**\\n- Users always have an \\"Other\\" option for custom input — don't create one yourself\\n- Use multi_select to allow multiple answers to be selected for a question\\n- Keep option labels concise (1-5 words), use descriptions for trade-offs and details\\n- Each question should have 2-4 meaningful, distinct options\\n- Question texts must be unique across the call, and option labels must be unique within each question\\n- You can ask 1-4 questions at a time; group related questions to minimize interruptions\\n- If you recommend a specific option, list it first and append \\"(Recommended)\\" to its label\\n- The result is JSON with an \`answers\` object keyed by question text; each value is the chosen option's label (comma-separated labels for multi_select, or the user's own words if they picked \\"Other\\"); if \`answers\` is empty and a \`note\` says the user dismissed it, they chose not to answer — do not treat this as selecting the recommended option; decide based on context and do not re-ask the same question\\n- Set background=true when you can keep working without the answer. This starts a background question task and returns a task_id immediately. The answer arrives automatically in a later turn — you do not need to poll, sleep, or check on it. Continue with other work; never fabricate or predict the answer.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "questions": { "minItems": 1, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "question": { "type": "string", "minLength": 1, "description": "A specific, actionable question. End with '?'." }, "header": { "default": "", "description": "Short category tag (max 12 chars, e.g. 'Auth', 'Style').", "type": "string" }, "options": { "minItems": 2, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "description": "Concise display text (1-5 words). If recommended, append '(Recommended)'." }, "description": { "default": "", "description": "Brief explanation of trade-offs or implications.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false }, "description": "2-4 meaningful, distinct options. Do NOT include an 'Other' option — the system adds one automatically." }, "multi_select": { "default": false, "description": "Whether the user can select multiple options.", "type": "boolean" } }, "required": [ "question", "options" ], "additionalProperties": false }, "description": "The questions to ask the user (1-4 questions)." }, "background": { "default": false, "description": "Set true to ask in the background and return immediately with a background task_id; you are notified automatically when the user answers — do not poll with TaskOutput while the question is pending.", "type": "boolean" } }, "required": [ "questions" ], "additionalProperties": false } }, { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nIf \`run_in_background=true\`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short \`description\`. Background commands default to a 600s timeout and \`timeout\` is capped at 86400s; set \`disable_timeout=true\` only when the task should run without a timeout. You will be automatically notified when the task completes. After starting one, default to returning control to the user instead of immediately waiting on it. Use \`TaskOutput\` only for a non-blocking status/output snapshot — do not set \`block=true\` to wait for a task you just launched, since its completion arrives automatically; reserve \`block=true\` for when the user explicitly asked you to wait. Use \`TaskStop\` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the \`/tasks\` command, which opens an interactive panel; it has no subcommands.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the \`timeout\` argument in seconds. Foreground commands default to 60s and allow up to 300s. When a foreground command hits its timeout it is moved to the background instead of being killed, and you will be automatically notified when it completes.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Prefer \`run_in_background=true\` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } }, { "name": "CreateGoal", "description": "Create a durable, structured goal that the runtime will pursue across multiple turns.\\n\\nCall \`CreateGoal\` only when:\\n\\n- the user explicitly asks you to start a goal or work autonomously toward an outcome, or\\n- a host goal-intake prompt asks you to create one.\\n\\nDo NOT create a goal for greetings, ordinary questions, or vague requests that lack a\\nverifiable completion condition. A goal needs a checkable end state.\\n\\nWhen the request is vague, ask the user for the missing completion criterion before creating\\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\\nrespect that and create the goal.\\n\\nInclude a \`completionCriterion\` when the user provides one, or when it can be stated without\\ninventing new requirements. Keep \`objective\` concise; reference long task descriptions by file\\npath rather than pasting them.\\n\\nCreating a goal fails if one already exists, so use \`replace: true\` only when the user explicitly\\nwants to abandon the current goal and start a new one.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "objective": { "type": "string", "minLength": 1, "description": "The objective to pursue. Must have a verifiable end state." }, "completionCriterion": { "description": "How to verify the goal is complete. Include when the user provides one.", "type": "string" }, "replace": { "description": "Replace an existing active, paused, or blocked goal instead of failing.", "type": "boolean" } }, "required": [ "objective" ], "additionalProperties": false } }, { "name": "Edit", "description": "Perform exact replacements in existing files.\\n\\n- Edit is mandatory for every incremental change, especially small edits. DO NOT use Write or Bash \`sed\`.\\n- Read the target file before every Edit. DO NOT call Edit from memory, stale context, or a guessed \`old_string\`.\\n- Take \`old_string\` and \`new_string\` from the Read output view.\\n- Drop the line-number prefix and tab; match only file content.\\n- \`old_string\` must be unique unless \`replace_all\` is set.\\n- If \`old_string\` is ambiguous, add surrounding context. Use \`replace_all\` only when every occurrence should change — for example, renaming a symbol throughout the file.\\n- Multiple Edit calls may run in one response only when they do not target the same file.\\n- DO NOT issue consecutive Edit calls on the same file. A previous Edit can invalidate a later Edit's \`old_string\`, causing \`old_string not found\`. Read the file again before the next Edit.\\n- A write lock serializes same-file edits in response order, but serialization does not make stale \`old_string\` valid.\\n- For pure CRLF files, Read shows LF; use LF in \`old_string\` and \`new_string\`, and Edit writes CRLF back.\\n- For mixed endings or lone carriage returns, Read shows carriage returns as \\\\r; include actual \\\\r escapes in those positions.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the text file to edit. Relative paths resolve against the working directory; a path outside the working directory must be absolute." }, "old_string": { "type": "string", "minLength": 1, "description": "Exact content to replace from the Read output view, without the line-number prefix. Use LF for pure CRLF files; use actual \\\\r escapes where Read shows \\\\r." }, "new_string": { "type": "string", "description": "Replacement text in the same Read output view. LF is written back as CRLF only for pure CRLF files." }, "replace_all": { "description": "Set true only when every occurrence of old_string should be replaced.", "type": "boolean" } }, "required": [ "path", "old_string", "new_string" ], "additionalProperties": false } }, { "name": "EnterPlanMode", "description": "Use this tool proactively when you're about to start a non-trivial implementation task.\\nGetting user sign-off on your approach via ExitPlanMode before writing code prevents wasted effort.\\n\\nUse it when ANY of these conditions apply:\\n\\n1. New Feature Implementation - e.g. \\"Add a caching layer to the API\\"\\n2. Multiple Valid Approaches - e.g. \\"Optimize database queries\\" (indexing vs rewrite vs caching)\\n3. Code Modifications - e.g. \\"Refactor auth module to support OAuth\\"\\n4. Architectural Decisions - e.g. \\"Add WebSocket support\\"\\n5. Multi-File Changes - involves more than 2-3 files\\n6. Unclear Requirements - need exploration to understand scope\\n7. User Preferences Matter - if user input would materially change the implementation approach, use EnterPlanMode to structure the decision\\n\\nPermission mode notes:\\n- EnterPlanMode enters plan mode automatically without an approval prompt in all permission modes.\\n- In yolo and manual modes, ExitPlanMode still presents the plan to the user for approval.\\n- In auto permission mode, do not use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, ExitPlanMode exits plan mode without asking the user.\\n- Use EnterPlanMode only when planning itself adds value.\\n\\nWhen NOT to use:\\n- Single-line or few-line fixes (typos, obvious bugs, small tweaks)\\n- User gave very specific, detailed instructions\\n- Pure research/exploration tasks\\n\\nOnce you are in plan mode, a reminder walks you through the workflow (explore → design → write the plan file → \`ExitPlanMode\`) and enforces read-only access. For non-trivial tasks where you are unsure of the codebase structure or relevant code paths, use \`Agent(subagent_type=\\"explore\\")\` to investigate first when the \`Agent\` tool is available.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "ExitPlanMode", "description": "Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.\\n\\n## How This Tool Works\\n- You should have already written your plan to the plan file specified in the plan mode reminder.\\n- This tool does NOT take the plan content as a parameter - it reads the plan from the file you wrote.\\n- The user will see the contents of your plan file when they review it. In auto permission mode, the tool reads the file and exits plan mode without asking the user.\\n\\n## When to Use\\nOnly use this tool for tasks that require planning implementation steps. For research tasks (searching files, reading code, understanding the codebase), do NOT use this tool.\\n\\n## What a good plan contains\\nList specific, verifiable steps grounded in the actual codebase — real files, functions, and commands, in a sensible order. Each step should be concrete enough to act on and to check. Avoid vague filler like \\"improve performance\\" or \\"add tests\\"; say what to change and where.\\n\\n## Multiple Approaches\\nIf your plan offers multiple alternative approaches, pass them via the \`options\` parameter so the user can choose which one to execute — see the \`options\` parameter for the format, count, and reserved labels. In yolo and manual modes the user sees all options alongside the host's Reject and Revise controls.\\n\\n## Before Using\\n- In auto permission mode, do NOT use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, this tool exits plan mode without asking the user.\\n- In yolo and manual modes, this tool still presents the plan to the user for approval.\\n- If auto permission mode is not active and you have unresolved questions, use AskUserQuestion first.\\n- If auto permission mode is not active and you have multiple approaches and haven't narrowed down yet, consider using AskUserQuestion first to let the user choose, then write a plan for the chosen approach only.\\n- Once your plan is finalized, use THIS tool to request approval.\\n- Do NOT use AskUserQuestion to ask \\"Is this plan OK?\\" or \\"Should I proceed?\\" - that is exactly what ExitPlanMode does.\\n- If rejected, revise based on feedback and call ExitPlanMode again.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "options": { "description": "When the plan contains multiple alternative approaches, list them here so the user can choose which one to execute. Provide up to 3 options; 2-3 distinct approaches work best when the plan offers a real choice. Passing a single option is allowed and is equivalent to a plain plan approval. Each option represents a distinct approach from the plan. Do not use \\"Reject\\", \\"Revise\\", \\"Approve\\", or \\"Reject and Exit\\" as labels.", "minItems": 1, "maxItems": 3, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "maxLength": 80, "description": "Short name for this option (1-8 words). Append \\"(Recommended)\\" if you recommend this option." }, "description": { "default": "", "description": "Brief summary of this approach and its trade-offs.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "FetchURL", "description": "Fetch content from a URL. The content is returned either as the main text extracted from the page, or as the full response body verbatim; a note at the top of the result states which of the two you received, so you can judge how complete it is. Use this when you need to read a specific web page.\\n\\nOnly fully-formed public \`http\`/\`https\` URLs are supported; other schemes and private or loopback addresses are not fetched. Very large pages may be truncated or refused. The fetch carries no login or session for the target site, so pages behind authentication (private repositories, internal dashboards) return a login page or an error instead of the real content — if the text you get back looks like a generic landing or sign-in page, treat that as the login wall, not the answer, and reach the content through a credentialed route (an authenticated CLI or MCP tool) instead.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "url": { "type": "string", "description": "The URL to fetch content from." } }, "required": [ "url" ], "additionalProperties": false } }, { "name": "GetGoal", "description": "Read the current goal: its objective, completion criterion, status, and budgets (turns, tokens,\\ntime, and how much of each remains). When the goal has stopped, it also reports the terminal reason.\\n\\nUse \`GetGoal\` before deciding whether to continue working, report completion, report a blocker,\\nor respect a pause. It returns \`{ \\"goal\\": null }\` when there is no current goal.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "Glob", "description": "Find files by glob pattern, sorted by modification time (most recent first).\\n\\nPowered by ripgrep. Respects \`.gitignore\`, \`.ignore\`, and \`.rgignore\` by default — set \`include_ignored\` to also match ignored files (e.g. build outputs, \`node_modules\`). Sensitive files (such as \`.env\`) are always filtered out. Matches are files only — directories themselves are never listed; to find a directory, glob for a file inside it (e.g. \`**/fixtures/**\`).\\n\\nGood patterns:\\n- \`*.ts\` — all files matching an extension, at any depth below the search root (a bare pattern without \`/\` matches recursively)\\n- \`src/*.ts\` — files directly inside \`src/\` (one level, not recursive)\\n- \`src/**/*.ts\` — recursive walk with a subdirectory anchor and extension\\n- \`**/*.py\` — recursive walk from the search root for an extension\\n- \`*.{ts,tsx}\` — brace expansion is supported\\n- \`{src,test}/**/*.ts\` — cartesian brace expansion is supported too\\n\\nResults are capped at the first 100 matching paths. If a search would return more, a truncation marker is appended. Refine the pattern (extension, subdirectory) when 100 is not enough, or call again with a narrower anchor.\\n\\nLarge-directory caveat — avoid recursing into dependency / build output even with an anchor, especially when \`include_ignored\` is set:\\n- \`node_modules/**/*.js\`, \`.venv/**/*.py\`, \`__pycache__/**\`, \`target/**\` can produce thousands of results that truncate at the match cap and waste context. Prefer specific subpaths like \`node_modules/react/src/**/*.js\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Glob pattern to match files." }, "path": { "description": "Directory to search. Accepts an absolute path, or a path relative to the current working directory. Defaults to the current working directory.", "type": "string" }, "include_ignored": { "description": "Also match files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" }, "include_dirs": { "description": "Deprecated and ignored. Results are always files-only — directories are never listed. Accepted only so older calls that still pass this flag are not rejected by parameter validation.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Grep", "description": "Search file contents using regular expressions (powered by ripgrep).\\n\\nUse Grep when the task is to find unknown content or unknown file locations. Do not use shell \`grep\` or \`rg\` directly; this tool applies workspace path policy, output limits, and sensitive-file filtering.\\nALWAYS use Grep tool instead of running \`grep\` or \`rg\` from a shell — direct shell calls bypass workspace policy, output limits, and sensitive-file filtering.\\nIf you already know a concrete file path and need to inspect its contents, use Read directly instead.\\n\\nWrite patterns in ripgrep regex syntax, which differs from POSIX \`grep\` syntax. For example, braces are special, so escape them as \`\\\\{\` to match a literal \`{\`.\\n\\nHidden files (dotfiles such as \`.gitlab-ci.yml\` or \`.eslintrc.json\`) are searched by default. To also search files excluded by \`.gitignore\` (such as \`node_modules\` or build outputs), set \`include_ignored\` to \`true\`. Sensitive files (such as \`.env\`) are always skipped for safety, even when \`include_ignored\` is \`true\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Regular expression to search for." }, "path": { "description": "File or directory to search. Accepts an absolute path, or a path relative to the current working directory. Omit to search the current working directory. Use Read instead when you already know a concrete file path and need its contents.", "type": "string" }, "glob": { "description": "Optional glob filter for which files to search, e.g. \`*.ts\`. Matched against each file's full absolute path, so a path-anchored pattern like \`src/**/*.ts\` silently matches nothing — use a basename pattern (\`*.ts\`), or anchor with \`**/\` (\`**/src/**/*.ts\`). To scope the search to a directory, use \`path\` instead.", "type": "string" }, "type": { "description": "Optional ripgrep file type filter, such as ts or py. Prefer this over \`glob\` when filtering by language or file kind: it is more efficient and less error-prone than an equivalent glob pattern.", "type": "string" }, "output_mode": { "description": "Shape of the result. \`content\` shows matching lines (honors \`-A\`, \`-B\`, \`-C\`, \`-n\`, and \`head_limit\`); \`files_with_matches\` shows only the paths of files that contain a match, most-recently-modified first (honors \`head_limit\`); \`count_matches\` shows per-file match counts as \`path:count\` lines, preceded by an aggregate total line. Defaults to \`files_with_matches\`.", "type": "string", "enum": [ "content", "files_with_matches", "count_matches" ] }, "-i": { "description": "Perform a case-insensitive search. Defaults to false.", "type": "boolean" }, "-n": { "description": "Prefix each matching line with its line number. Applies only when \`output_mode\` is \`content\`. Defaults to true.", "type": "boolean" }, "-A": { "description": "Number of lines to show after each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-B": { "description": "Number of lines to show before each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-C": { "description": "Number of lines to show before and after each match. Applies only when \`output_mode\` is \`content\`; takes precedence over \`-A\` and \`-B\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "head_limit": { "description": "Limit output to the first N lines/entries after offset. Defaults to 250. Pass 0 for unlimited.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "offset": { "description": "Number of leading lines/entries to skip before applying \`head_limit\`. Use it together with \`head_limit\` to page through large result sets. Defaults to 0.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "multiline": { "description": "Enable multiline matching, where the pattern can span line boundaries and \`.\` also matches newlines. Defaults to false.", "type": "boolean" }, "include_ignored": { "description": "Also search files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Read", "description": "Read a text file from the local filesystem.\\n\\nIf the user provides a concrete file path to a text file, call Read directly. Do not \`Glob\`, \`ls\`, or otherwise pre-check known text file paths; missing or invalid file paths return errors you can handle. Do not use Read for directories; use \`ls\` via Bash for a known directory, or Glob when you need files matching a name pattern (Glob lists files only, never directories). Use \`Grep\` only when the task is to search for unknown content or locations.\\n\\nWhen you need several files, prefer to read them in parallel: emit multiple \`Read\` calls in a single response instead of reading one file per turn.\\n\\n- Relative paths resolve against the working directory; a path outside the working directory must be absolute.\\n- Returns up to 1000 lines or 100 KB per call, whichever comes first; lines longer than 2000 chars are truncated mid-line.\\n- Page larger files with \`line_offset\` (1-based start line) and \`n_lines\`. Omit \`n_lines\` to read up to the 1000-line cap.\\n- Sensitive files (\`.env\` files, credential stores, SSH private keys, and similar secrets) are refused to protect secrets; do not attempt to read them. Templates and public keys are exempt: \`.env.example\` / \`.env.sample\` / \`.env.template\` and public SSH keys such as \`id_rsa.pub\` read normally.\\n- Only UTF-8 text files can be read. Non-UTF-8 encodings, binary files, and files containing NUL bytes are refused; use \`ReadMediaFile\` for images or video, and Bash or an MCP tool for other binary formats.\\n- Negative line_offset reads from the end of the file (for example, -100 reads the last 100 lines); the absolute value cannot exceed 1000.\\n- Output format: \`<line-number>\\\\t<content>\` per line.\\n- A \`<system>...</system>\` status block is appended after the file content; it summarizes how much was read (line and byte counts, truncation, line-ending notes) and is not part of the file itself.\\n- Pure CRLF files are displayed with LF line endings; \`Edit\` matches this output and preserves CRLF when writing back.\\n- Mixed or lone carriage-return line endings are shown as \`\\\\r\` and require exact \`Edit.old_string\` escapes.\\n- After a successful \`Edit\`/\`Write\`, do not re-read solely to prove the write landed. When the task depends on an exact file, API, or output shape, inspect the final external contract before finishing.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to a text file. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Directories are not supported; use \`ls\` via Bash for a known directory, or Glob for pattern search." }, "line_offset": { "description": "The line number to start reading from. Omit to start at line 1. Negative values read from the end of the file; the absolute value cannot exceed 1000.", "anyOf": [ { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, { "type": "integer", "minimum": -1000, "maximum": -1 } ] }, "n_lines": { "description": "The number of lines to read; the tool also applies its internal cap. Omit to read up to the internal cap of 1000 lines.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 } }, "required": [ "path" ], "additionalProperties": false } }, { "name": "SetGoalBudget", "description": "Set a hard budget limit for the current goal.\\n\\nUse this only when the user clearly gives a runtime limit, such as:\\n\\n- \\"stop after 20 turns\\"\\n- \\"use no more than 500k tokens\\"\\n- \\"finish within 30 minutes\\"\\n\\nDo not invent limits. Do not call this for vague wording such as \\"spend some time\\" or\\n\\"try to be quick\\".\\n\\nIf the user gives a compound time, convert it to one supported unit before calling this tool.\\nFor example, \\"2 hours and 3 minutes\\" can be set as \`value: 123, unit: \\"minutes\\"\`.\\n\\nA time budget must be between 1 second and 24 hours — the tool rejects anything shorter or\\nlonger, telling the user it is not a reasonable goal budget. Turn and token budgets are not\\nbounded this way; they must be positive and are rounded to the nearest whole number (minimum 1).\\n\\nSupported units:\\n\\n- \`turns\`\\n- \`tokens\`\\n- \`milliseconds\`\\n- \`seconds\`\\n- \`minutes\`\\n- \`hours\`\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "value": { "type": "number", "exclusiveMinimum": 0, "description": "The positive numeric budget value." }, "unit": { "type": "string", "enum": [ "turns", "tokens", "milliseconds", "seconds", "minutes", "hours" ] } }, "required": [ "value", "unit" ], "additionalProperties": false } }, { "name": "Skill", "description": "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a \`<kimi-skill-loaded>\` block for it with the same \`args\` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier \`args\` and will not reflect new inputs.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "skill": { "type": "string", "description": "The exact name of the skill to invoke, spelled as it appears in the current skill listing (e.g. \\"commit\\", \\"pdf\\")." }, "args": { "description": "Optional argument string for the skill, written like a command line (e.g. \`-m \\"fix bug\\"\`, \`123\`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing \`ARGUMENTS:\` line. Omit it only when there is nothing to pass.", "type": "string" } }, "required": [ "skill" ], "additionalProperties": false } }, { "name": "TaskList", "description": "List background tasks and their current status.\\n\\nUse this tool to discover which background tasks exist and where each one\\nstands. It is the entry point for inspecting background work: it returns a\\ntask ID, status, and description for every task it reports, plus the command,\\nPID, and (once finished) exit code for shell tasks, and a stop reason for any\\ntask that ended early.\\n\\nGuidelines:\\n\\n- After a context compaction, or whenever you are unsure which background\\n  tasks are running or what their task IDs are, call this tool to\\n  re-enumerate them instead of guessing a task ID.\\n- Prefer the default \`active_only=true\`, which lists only non-terminal tasks.\\n  Pass \`active_only=false\` only when you specifically need to see tasks that\\n  have already finished. With \`active_only=false\` the result may also include\\n  \`lost\` tasks — tasks left over from a previous process that can no longer be\\n  inspected or controlled; treat them as already terminated.\\n- \`limit\` caps how many tasks are returned. It accepts a value between 1 and\\n  100 and defaults to 20 when omitted.\\n- This tool only lists tasks; it does not return their output. Use it first\\n  to locate the task ID you need, then call \`TaskOutput\` with that ID to read\\n  the task's output and details.\\n- This tool is read-only and does not change any state, so it is always safe\\n  to call, including in plan mode.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "active_only": { "default": true, "description": "Whether to list only non-terminal background tasks.", "type": "boolean" }, "limit": { "default": 20, "description": "Maximum number of tasks to return.", "type": "integer", "minimum": 1, "maximum": 100 } }, "additionalProperties": false } }, { "name": "TaskOutput", "description": "Retrieve a snapshot of a running or completed background task.\\n\\nUse this after \`Bash(run_in_background=true)\` or \`Agent(run_in_background=true)\` to check progress, or to read the output of a task that has already completed.\\n\\nGuidelines:\\n- Prefer relying on automatic completion notifications. Use this tool only when you need task output before the automatic notification arrives.\\n- By default this tool is non-blocking and returns a current status/output snapshot — that is the normal way to use it.\\n- Do not use TaskOutput to wait for a result you need before continuing — if your next step depends on the task's result, run that task in the foreground instead. TaskOutput is for a deliberate progress check you will act on without blocking, not a way to sit and wait for a background task you just launched.\\n- Use block=true only when the user explicitly asked you to wait for the task. Never block on a task you launched in the current turn — if you need its result right away, it should have been a foreground call.\\n- If a block=true call returns \`retrieval_status: timeout\` (the task is still running), do not block on the same task again. Continue with other work or hand back to the user — the completion notification arrives on its own.\\n- This tool returns structured task metadata, a fixed-size output preview, and an output_path for the full log.\\n- For a terminal task, the metadata also explains why it ended. A shell command that runs to completion reports \`status: completed\` on a zero exit, or \`status: failed\` with its non-zero \`exit_code\` — judge that failure from the \`exit_code\`, because a plain command failure carries no \`stop_reason\` and no \`terminal_reason\`. \`terminal_reason\` is a categorical label emitted only when the end is not an ordinary exit: \`timed_out\` when the deadline aborted it, \`stopped\` when it was explicitly stopped, or \`failed\` when it errored without producing an exit code; the \`stopped\` and \`failed\` cases also carry a human-readable \`stop_reason\`. A task that finished on its own with a clean exit carries neither \`stop_reason\` nor \`terminal_reason\`.\\n- The full, never-truncated log is always available at output_path; use the \`Read\` tool with that path to page through it, whether or not the preview was truncated.\\n- This tool works with the generic background task system and should remain the primary read path for future task types, not just bash.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to inspect." }, "block": { "default": false, "description": "Whether to wait for the task to finish before returning. Discouraged — background tasks notify automatically on completion; use only when the user explicitly asked you to wait.", "type": "boolean" }, "timeout": { "default": 30, "description": "Maximum number of seconds to wait when block=true.", "type": "integer", "minimum": 0, "maximum": 3600 } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TaskStop", "description": "Stop a running background task.\\n\\nOnly use this when a task must genuinely be cancelled — for a task that is\\nfinishing normally, wait for its completion notification or inspect it with\\n\`TaskOutput\` instead of stopping it.\\n\\nGuidelines:\\n- This is a general-purpose stop capability for any background task. It is not\\n  a bash-specific kill.\\n- Stopping a task is destructive: it may leave partial side effects behind.\\n  Use it with care.\\n- If the task has already finished, this tool simply returns its current\\n  status.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to stop." }, "reason": { "default": "Stopped by TaskStop", "description": "Short reason recorded when the task is stopped.", "type": "string" } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TodoList", "description": "Use this tool to maintain a structured TODO list as you work through a multi-step task. Use it proactively and often when progress tracking helps the current work. This is especially useful in long-running investigations and implementation tasks with several tool calls; in plan mode, write the plan to the plan file rather than tracking it here.\\n\\n**When to use:**\\n- Multi-step tasks that span several tool calls\\n- Tracking investigation progress across a large codebase search\\n- Planning a sequence of edits before making them\\n- After receiving new multi-step instructions, capture the requirements as todos\\n- Before starting a tracked task, mark exactly one item as \`in_progress\`\\n- Immediately after finishing a tracked task, mark it \`done\`; do not batch completions at the end\\n\\n**When NOT to use:**\\n- Single-shot answers that complete in one or two tool calls\\n- Trivial requests where tracking adds no clarity\\n- Purely conversational or informational replies\\n\\n**Avoid churn:**\\n- Do not re-call this tool when nothing meaningful has changed since the last call — update the list only after real progress.\\n- When unsure of the current state, call query mode first (omit \`todos\`) to check the list before deciding what to update.\\n- If no available tool can move any task forward, tell the user where you are stuck instead of repeatedly re-ordering the same todos.\\n\\n**How to use:**\\n- Call with \`todos: [...]\` to replace the full list. Statuses: pending / in_progress / done.\\n- Call with no \`todos\` argument to retrieve the current list without changing it.\\n- Call with \`todos: []\` to clear the list.\\n- Keep titles short and actionable (e.g. \\"Read session-control.ts\\", \\"Add planMode flag to TurnManager\\").\\n- Update statuses as you make progress.\\n- When work is underway, keep exactly one task \`in_progress\`.\\n- Only mark a task \`done\` when it is fully accomplished.\\n- Never mark a task \`done\` if tests are failing, implementation is partial, unresolved errors remain, or required files/dependencies could not be found.\\n- If you encounter a blocker, keep the blocked task \`in_progress\` or add a new pending task describing what must be resolved.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "todos": { "description": "The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.", "type": "array", "items": { "type": "object", "properties": { "title": { "type": "string", "minLength": 1, "description": "Short, actionable title for the todo." }, "status": { "type": "string", "enum": [ "pending", "in_progress", "done" ], "description": "Current status of the todo." } }, "required": [ "title", "status" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "UpdateGoal", "description": "Set the status of the current goal. This is how you resume, complete, or block an autonomous goal.\\n\\n- \`active\` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\\n- \`complete\` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded. Before using this, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not use \`complete\` merely because a budget is nearly exhausted or you want to stop.\\n- \`blocked\` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. For non-terminal blockers, do not use \`blocked\` the first time you hit the blocker. The same blocking condition must repeat for at least 3 consecutive goal turns before you call \`blocked\`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. If the objective itself is impossible, unsafe, or contradictory, call \`blocked\` in the same turn instead of running more goal turns. Do not use \`blocked\` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call \`blocked\` instead of leaving the goal active.\\n\\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call \`complete\` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not call \`complete\` after only producing a plan, summary, first pass, or partial result. Call \`blocked\` only after the blocked audit threshold is met. If you call \`blocked\`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "status": { "type": "string", "enum": [ "active", "complete", "blocked" ], "description": "The lifecycle status to set for the current goal. Use \`blocked\` for impossible, unsafe, or contradictory objectives, or after the same non-terminal blocking condition repeats for at least 3 consecutive goal turns." } }, "required": [ "status" ], "additionalProperties": false } }, { "name": "Write", "description": "Create, append to, or replace a file entirely.\\n\\n- Missing parent directories are created automatically (like \`mkdir(parents=True, exist_ok=True)\`).\\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\\n- Do not create unsolicited documentation files (\`*.md\` write-ups, \`README\`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\\n- Read before overwriting an existing file.\\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\\n- Write outputs content literally, including supplied line endings: \\\\n stays LF, \\\\r\\\\n stays CRLF.\\n- For new content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically." }, "content": { "type": "string", "description": "Raw full file content to write exactly as provided. This does not use the Read/Edit text view." }, "mode": { "description": "Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline.", "type": "string", "enum": [ "overwrite", "append" ] } }, "required": [ "path", "content" ], "additionalProperties": false } } ], "time": "<time>" }
+      [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999997, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "b0e35cedccd898afc718a76e65bcb9fb84b7657958a03a95d49f40a40b99a81f", "messageCount": 1, "turnStep": "0.1", "time": "<time>" }
       [emit] assistant.delta             { "turnId": 0, "delta": "blocked" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
       [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] agent.status.updated        { "contextTokens": 8, "rawContextTokens": 11 }
-      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "blocked" } }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 8, "rawContextTokens": 13 }
-      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "filtered", "usage": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "filtered", "rawFinishReason": "filtered" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 8, "rawContextTokens": 8 }
       [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "filtered", "providerFinishReason": "filtered", "rawFinishReason": "filtered" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "blocked" } }, "time": "<time>" }
+      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "filtered", "usage": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "filtered", "rawFinishReason": "filtered" }, "time": "<time>" }
       [emit] turn.ended                  { "turnId": 0, "reason": "failed", "error": { "code": "provider.filtered", "message": "Provider safety policy blocked the response.", "name": "ProviderFilteredError", "details": { "finishReason": "filtered" }, "retryable": false } }
     `);
 
@@ -315,22 +317,25 @@ describe('Agent loop', () => {
       [wire] tools.set_active_tools          { "names": [ "Lookup" ], "time": "<time>" }
       [wire] turn.prompt                     { "input": [ { "type": "text", "text": "Look up moon" } ], "origin": { "kind": "user" }, "time": "<time>" }
       [emit] turn.started                    { "turnId": 0, "origin": { "kind": "user" } }
-      [wire] context.append_message          { "message": { "role": "user", "content": [ { "type": "text", "text": "Look up moon" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
-      [emit] agent.status.updated            { "contextTokens": 5, "rawContextTokens": 5 }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] context.spliced                 { "start": 0, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Look up moon" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" } ] }
+      [emit] agent.status.updated            { "contextTokens": 5, "rawContextTokens": 5 }
+      [wire] context.append_message          { "message": { "role": "user", "content": [ { "type": "text", "text": "Look up moon" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
       [emit] turn.step.started               { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event       { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
-      [emit] agent.status.updated            { "contextTokens": 5, "rawContextTokens": 8 }
       [wire] llm.tools_snapshot              { "hash": "3bfeb22e61431247933e79f6ab94e7ca14a127f899bc87e7bbd22594ba9cdb66", "tools": [ { "name": "Lookup", "description": "Look up a short test value.", "parameters": { "type": "object", "properties": { "query": { "type": "string" } }, "required": [ "query" ], "additionalProperties": false } } ], "time": "<time>" }
       [wire] llm.request                     { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999995, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "3bfeb22e61431247933e79f6ab94e7ca14a127f899bc87e7bbd22594ba9cdb66", "messageCount": 1, "turnStep": "0.1", "time": "<time>" }
       [emit] assistant.delta                 { "turnId": 0, "delta": "I will look it up." }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] tool.call.delta                 { "turnId": 0, "toolCallId": "call_lookup", "name": "Lookup", "argumentsPart": "{\\"query\\":\\"moon\\"}" }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] usage.record                    { "model": "mock-model", "usage": { "inputOther": 5, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
       [emit] agent.status.updated            { "usage": { "byModel": { "mock-model": { "inputOther": 5, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 5, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 5, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] agent.status.updated            { "contextTokens": 26, "rawContextTokens": 29 }
       [wire] context.append_loop_event       { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "I will look it up." } }, "time": "<time>" }
-      [emit] agent.status.updated            { "contextTokens": 26, "rawContextTokens": 35 }
       [emit] permission.approval.requested   { "sessionId": "test-session", "agentId": "main", "turnId": 0, "toolCallId": "call_lookup", "toolName": "Lookup", "action": "Approve Lookup", "display": { "kind": "generic", "summary": "Approve Lookup", "detail": { "query": "moon" } }, "toolInput": { "query": "moon" } }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [ { "approvalId": "call_lookup", "toolCallId": "call_lookup", "since": "<time>" } ], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] requestApproval                 { "turnId": 0, "toolCallId": "call_lookup", "toolName": "Lookup", "action": "Approve Lookup", "display": { "kind": "generic", "summary": "Approve Lookup", "detail": { "query": "moon" } } }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -342,29 +347,29 @@ describe('Agent loop', () => {
 
     expect(await ctx.untilTurnEnd()).toMatchInlineSnapshot(`
       [emit] permission.approval.resolved        { "sessionId": "test-session", "agentId": "main", "turnId": 0, "toolCallId": "call_lookup", "toolName": "Lookup", "action": "Approve Lookup", "display": { "kind": "generic", "summary": "Approve Lookup", "detail": { "query": "moon" } }, "toolInput": { "query": "moon" }, "decision": "approved", "selectedLabel": "approve" }
+      [emit] agent.activity.updated              { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] permission.record_approval_result   { "turnId": 0, "toolCallId": "call_lookup", "toolName": "Lookup", "action": "Approve Lookup", "result": { "decision": "approved", "selectedLabel": "approve" }, "time": "<time>" }
       [emit] tool.call.started                   { "turnId": 0, "toolCallId": "call_lookup", "name": "Lookup", "args": { "query": "moon" } }
+      [emit] agent.activity.updated              { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [ { "toolCallId": "call_lookup", "name": "Lookup", "since": "<time>" } ], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event           { "event": { "type": "tool.call", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "toolCallId": "call_lookup", "name": "Lookup", "args": { "query": "moon" } }, "time": "<time>" }
-      [emit] agent.status.updated                { "contextTokens": 26, "rawContextTokens": 47 }
       [emit] tool.result                         { "turnId": 0, "toolCallId": "call_lookup", "output": "lookup-result" }
+      [emit] agent.activity.updated              { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event           { "event": { "type": "tool.result", "parentUuid": "<uuid-3>", "toolCallId": "call_lookup", "result": { "output": "lookup-result" } }, "time": "<time>" }
-      [emit] agent.status.updated                { "contextTokens": 31, "rawContextTokens": 52 }
-      [wire] context.append_loop_event           { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 5, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
-      [emit] agent.status.updated                { "contextTokens": 31, "rawContextTokens": 31 }
       [emit] turn.step.completed                 { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 5, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "tool_use", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }
+      [wire] context.append_loop_event           { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 5, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
       [emit] turn.step.started                   { "turnId": 0, "step": 2, "stepId": "<uuid-4>" }
+      [emit] agent.activity.updated              { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event           { "event": { "type": "step.begin", "uuid": "<uuid-4>", "turnId": "0", "step": 2 }, "time": "<time>" }
-      [emit] agent.status.updated                { "contextTokens": 34, "rawContextTokens": 37 }
       [wire] llm.request                         { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999966, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "3bfeb22e61431247933e79f6ab94e7ca14a127f899bc87e7bbd22594ba9cdb66", "messageCount": 3, "turnStep": "0.2", "time": "<time>" }
       [emit] assistant.delta                     { "turnId": 0, "delta": "The lookup result is lookup-result." }
+      [emit] agent.activity.updated              { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] usage.record                        { "model": "mock-model", "usage": { "inputOther": 31, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
       [emit] agent.status.updated                { "usage": { "byModel": { "mock-model": { "inputOther": 36, "output": 34, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 36, "output": 34, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 36, "output": 34, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] agent.status.updated                { "contextTokens": 44, "rawContextTokens": 47 }
-      [wire] context.append_loop_event           { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The lookup result is lookup-result." } }, "time": "<time>" }
-      [emit] agent.status.updated                { "contextTokens": 44, "rawContextTokens": 57 }
-      [wire] context.append_loop_event           { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 31, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-      [emit] agent.status.updated                { "contextTokens": 44, "rawContextTokens": 44 }
       [emit] turn.step.completed                 { "turnId": 0, "step": 2, "stepId": "<uuid-4>", "usage": { "inputOther": 31, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+      [emit] agent.activity.updated              { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+      [wire] context.append_loop_event           { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The lookup result is lookup-result." } }, "time": "<time>" }
+      [wire] context.append_loop_event           { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 31, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
       [emit] turn.ended                          { "turnId": 0, "reason": "completed" }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -633,11 +638,12 @@ describe('turn telemetry', () => {
 
       expect(records).toContainEqual({
         event: 'turn_started',
-        properties: { mode: 'agent', provider_type: 'kimi', protocol: 'kimi' },
+        properties: { turn_id: 0, mode: 'agent', provider_type: 'kimi', protocol: 'kimi' },
       });
       expect(records).toContainEqual({
         event: 'turn_ended',
         properties: expect.objectContaining({
+          turn_id: 0,
           reason: 'completed',
           duration_ms: expect.any(Number),
           mode: 'agent',
@@ -651,6 +657,64 @@ describe('turn telemetry', () => {
     }
   });
 
+  it('attaches the latest request trace id to turn_ended', async () => {
+    const records: TelemetryRecord[] = [];
+    const local = createTestAgent({ telemetry: recordingTelemetry(records) });
+    try {
+      local.get(IAgentProfileService).update({ activeToolNames: [] });
+      local.mockNextProviderResponse({
+        parts: [{ type: 'text', text: 'hi' }],
+        traceId: 'trace-turn-1',
+      });
+      await local.rpc.prompt({ input: [{ type: 'text', text: 'Hello' }] });
+      await local.untilTurnEnd();
+
+      expect(records).toContainEqual({
+        event: 'turn_ended',
+        properties: expect.objectContaining({
+          turn_id: 0,
+          reason: 'completed',
+          trace_id: 'trace-turn-1',
+        }),
+      });
+    } finally {
+      await local.dispose();
+    }
+  });
+
+  it('does not reuse the previous step trace when a step hook fails before a request', async () => {
+    const records: TelemetryRecord[] = [];
+    const local = createTestAgent({ telemetry: recordingTelemetry(records) });
+    try {
+      const localLoop = local.get(IAgentLoopService);
+      local.get(IAgentProfileService).update({ activeToolNames: [] });
+      localLoop.hooks.onDidFinishStep.register('test-continue-after-first-step', async (hookCtx, next) => {
+        if (hookCtx.step === 1) {
+          localLoop.enqueue(new ContinuationStepRequest());
+          return;
+        }
+        await next();
+      });
+      localLoop.hooks.onWillBeginStep.register('test-fail-before-second-request', async (hookCtx, next) => {
+        if (hookCtx.step === 2) throw new Error('before step failed');
+        await next();
+      });
+      local.mockNextProviderResponse({
+        parts: [{ type: 'text', text: 'first' }],
+        traceId: 'trace-step-1',
+      });
+
+      await local.rpc.prompt({ input: [{ type: 'text', text: 'Hello' }] });
+      await local.untilTurnEnd();
+
+      expect(local.llmCalls).toHaveLength(1);
+      expect(records.find((record) => record.event === 'turn_interrupted')?.properties?.['trace_id']).toBeUndefined();
+      expect(records.find((record) => record.event === 'turn_ended')?.properties?.['trace_id']).toBeUndefined();
+    } finally {
+      await local.dispose();
+    }
+  });
+
   it('emits turn_interrupted with interrupt_reason filtered and turn_ended failed', async () => {
     const records: TelemetryRecord[] = [];
     const local = createTestAgent({ telemetry: recordingTelemetry(records) });
@@ -658,6 +722,7 @@ describe('turn telemetry', () => {
       local.mockNextProviderResponse({
         parts: [{ type: 'text', text: 'blocked' }],
         finishReason: 'filtered',
+        traceId: 'trace-turn-2',
       });
       await local.rpc.prompt({ input: [{ type: 'text', text: 'Hello' }] });
       await local.untilTurnEnd();
@@ -665,16 +730,23 @@ describe('turn telemetry', () => {
       expect(records).toContainEqual({
         event: 'turn_interrupted',
         properties: expect.objectContaining({
+          turn_id: 0,
           at_step: 1,
           mode: 'agent',
           interrupt_reason: 'filtered',
           provider_type: 'kimi',
           protocol: 'kimi',
+          trace_id: 'trace-turn-2',
         }),
       });
       expect(records).toContainEqual({
         event: 'turn_ended',
-        properties: expect.objectContaining({ reason: 'failed', mode: 'agent' }),
+        properties: expect.objectContaining({
+          turn_id: 0,
+          reason: 'failed',
+          mode: 'agent',
+          trace_id: 'trace-turn-2',
+        }),
       });
     } finally {
       await local.dispose();
@@ -712,7 +784,7 @@ describe('turn telemetry', () => {
 
         expect(records).toContainEqual({
           event: 'turn_interrupted',
-          properties: expect.objectContaining({ interrupt_reason: expected, mode: 'agent' }),
+          properties: expect.objectContaining({ turn_id: 0, interrupt_reason: expected, mode: 'agent' }),
         });
         expect(records).toContainEqual({
           event: 'turn_ended',
@@ -855,7 +927,7 @@ function createTimingRequester(): IAgentLLMRequesterService {
     clientConsumeMs: 50,
   };
 
-  return {
+  const requester: IAgentLLMRequesterService = {
     _serviceBrand: undefined,
     registerSystemPromptContribution: () => ({ dispose: () => undefined }),
     async request(_overrides, onPart = () => {}) {
@@ -871,7 +943,11 @@ function createTimingRequester(): IAgentLLMRequesterService {
         timing,
       };
     },
+    start(overrides, onPart, signal) {
+      return { trace: { traceId: undefined }, result: this.request(overrides, onPart, signal) };
+    },
   };
+  return requester;
 }
 
 function createAbortedStepGenerate(): GenerateFn {
diff --git a/packages/agent-core-v2/test/agent/loop/stubs.ts b/packages/agent-core-v2/test/agent/loop/stubs.ts
index 42d6f1938..53bb9ad81 100644
--- a/packages/agent-core-v2/test/agent/loop/stubs.ts
+++ b/packages/agent-core-v2/test/agent/loop/stubs.ts
@@ -10,7 +10,7 @@ import type { ContentPart } from '#/app/llmProtocol/message';
 import type { ContextMessage, PromptOrigin } from '#/agent/contextMemory/types';
 import { createHooks } from '#/hooks';
 import type { Op } from '#/wire/op';
-import type { IWireService } from '#/wire/wireService';
+import type { IWireService } from '#/wire/wire';
 
 export interface StubLoopOptions { readonly hasActiveTurn?: boolean; readonly currentId?: string | number; readonly pendingTurnResult?: boolean }
 export type StubLoop = IAgentLoopService & {
@@ -70,10 +70,11 @@ export function stubLoopWithHooks(options: StubLoopOptions = {}): StubLoop {
     status() { return { state: active !== undefined ? 'running' : 'idle', activeTurnId: active?.id, pendingTurnIds: [], hasPendingRequests: queue.hasPendingRequests() }; },
     cancel(turnId, reason) { cancels.push({ turnId, reason }); if (active === undefined || (turnId !== undefined && active.id !== turnId)) return false; active.cancel(reason); return true; },
     hasPendingRequests: () => queue.hasPendingRequests(), registerLoopErrorHandler: errorHandlers.register,
+    settled: () => Promise.resolve(),
     drainNextBatch(context) { const batch = queue.takeNextBatch(); if (!batch) return undefined; materialize(batch.driver, context); for (const r of batch.merged) materialize(r, context); return batch; },
   };
   return stub;
 }
 export type StubWire = IWireService & { readonly ops: readonly Op[]; readonly steered: readonly { readonly input: readonly ContentPart[]; readonly origin?: PromptOrigin }[] };
-export function stubWire(): StubWire { const ops: Op[] = []; const steered: { input: readonly ContentPart[]; origin?: PromptOrigin }[] = []; return { _serviceBrand: undefined, ops, steered, dispatch: (...incoming: Op[]) => { for (const op of incoming) { ops.push(op); if (op.type === 'turn.steer') steered.push(op.payload as never); } }, replay: async () => {}, signal: () => {}, flush: async () => {}, attach: () => toDisposable(() => {}), getModel: () => ({}), subscribe: () => toDisposable(() => {}), onEmission: () => toDisposable(() => {}), onRestored: () => toDisposable(() => {}) } as unknown as StubWire; }
+export function stubWire(): StubWire { const ops: Op[] = []; const steered: { input: readonly ContentPart[]; origin?: PromptOrigin }[] = []; return { _serviceBrand: undefined, hooks: createHooks(['onDidRestore']), ops, steered, dispatch: (...incoming: Op[]) => { for (const op of incoming) { ops.push(op); if (op.type === 'turn.steer') steered.push(op.payload as never); } }, replay: async () => {}, signal: () => {}, flush: async () => {}, getModel: () => ({}), subscribe: () => toDisposable(() => {}), onEmission: () => toDisposable(() => {}) } as unknown as StubWire; }
 export function stubToolExecutor(): IAgentToolExecutorService { return { _serviceBrand: undefined, execute: async function* () {}, hooks: createHooks(['onBeforeExecuteTool', 'onDidExecuteTool']) as IAgentToolExecutorService['hooks'], recordDupType: () => {}, registerUnavailableToolDescriber: () => ({ dispose() {} }), registerMissingToolDescriber: () => ({ dispose() {} }) }; }
diff --git a/packages/agent-core-v2/test/agent/mcp/mcp.test.ts b/packages/agent-core-v2/test/agent/mcp/mcp.test.ts
index 04b02413c..3f62a94cd 100644
--- a/packages/agent-core-v2/test/agent/mcp/mcp.test.ts
+++ b/packages/agent-core-v2/test/agent/mcp/mcp.test.ts
@@ -16,11 +16,9 @@ import { ISessionMcpService } from '#/session/mcp/sessionMcp';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import type { McpOAuthService } from '#/agent/mcp/oauth/service';
 import type { MCPClient, MCPToolDefinition } from '#/agent/mcp/types';
-import { IAgentWireService } from '#/wire/tokens';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import type { WireRecord } from '#/wire/record';
 import { McpDiscoveryModel } from '#/agent/mcp/mcpDiscoveryOps';
-import { AGENT_WIRE_PROTOCOL_VERSION } from '#/agent/wireRecord/wireRecord';
-import { wireMetadata } from '#/agent/wireRecord/metadataOps';
 import { AgentToolExecutorService } from '#/agent/toolExecutor/toolExecutorService';
 import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
 import { IAgentToolResultTruncationService } from '#/agent/toolResultTruncation/toolResultTruncation';
@@ -33,6 +31,8 @@ import { createTestAgent, mcpServices, type TestAgentContext } from '../../harne
 import { recordingTelemetry, type TelemetryRecord } from '../../app/telemetry/stubs';
 import { stubLoopWithHooks } from '../loop/stubs';
 import { stubToolResultTruncationService } from '../toolResultTruncation/stubs';
+import { recordingWireLog, registerTestAgentWire } from '../../wire/stubs';
+
 import { discoverTools, executeTool, fakeMcpClient } from './stubs';
 
 const MCP_OUTPUT_TRUNCATED_TEXT =
@@ -156,13 +156,15 @@ describe('AgentMcpService', () => {
   let ix: TestInstantiationService;
   let events: DomainEvent[];
   let telemetryEvents: TelemetryRecord[];
-  let wire: WireService;
+  let wire: IWireService;
+  let wireRecordListeners: Set<(record: WireRecord) => void>;
 
   beforeEach(() => {
     disposables = new DisposableStore();
     ix = disposables.add(new TestInstantiationService());
     events = [];
     telemetryEvents = [];
+    wireRecordListeners = new Set();
     ix.stub(IEventBus, {
       publish: (event) => {
         events.push(event);
@@ -174,8 +176,12 @@ describe('AgentMcpService', () => {
     ix.set(IAgentToolExecutorService, new SyncDescriptor(AgentToolExecutorService));
     ix.stub(IAgentToolResultTruncationService, stubToolResultTruncationService());
     ix.stub(IAgentLoopService, stubLoopWithHooks());
-    wire = disposables.add(new WireService({ logScope: 'mcp-test', logKey: 'wire.jsonl' }));
-    ix.stub(IAgentWireService, wire);
+    wire = registerTestAgentWire(ix, 'mcp-test', {
+      eventBus: ix.get(IEventBus),
+      log: recordingWireLog([], (record) => {
+        for (const listener of wireRecordListeners) listener(record);
+      }),
+    });
   });
   afterEach(() => {
     disposables.dispose();
@@ -573,12 +579,13 @@ describe('AgentMcpService', () => {
     off: { dispose(): void };
   } {
     const records: { type: string; [key: string]: unknown }[] = [];
-    const off = wire.onEmission((e) => {
-      if (e.record.type === 'mcp.tools_discovered') {
-        records.push(e.record as { type: string; [key: string]: unknown });
+    const listener = (record: WireRecord): void => {
+      if (record.type === 'mcp.tools_discovered') {
+        records.push(record as { type: string; [key: string]: unknown });
       }
-    });
-    return { records, off };
+    };
+    wireRecordListeners.add(listener);
+    return { records, off: toDisposable(() => wireRecordListeners.delete(listener)) };
   }
 
   it('records tools/list once after restore and dedups unchanged reconnects', async () => {
@@ -598,7 +605,8 @@ describe('AgentMcpService', () => {
     try {
       manager.connect('grafana');
       expect(records).toHaveLength(0);
-      await wire.replay();
+      await wire.restore();
+      await wire.flush();
       expect(records).toHaveLength(1);
       expect(records[0]).toMatchObject({
         type: 'mcp.tools_discovered',
@@ -613,6 +621,7 @@ describe('AgentMcpService', () => {
 
       manager.setResolved('grafana', client, await discoverTools(client), new Set(), rawTools);
       manager.connect('grafana');
+      await wire.flush();
       expect(records).toHaveLength(2);
     } finally {
       off.dispose();
@@ -636,7 +645,8 @@ describe('AgentMcpService', () => {
     try {
       manager.connect('grafana');
       expect(records).toHaveLength(0);
-      await wire.replay();
+      await wire.restore();
+      await wire.flush();
       expect(records).toHaveLength(1);
     } finally {
       off.dispose();
@@ -662,7 +672,8 @@ describe('AgentMcpService', () => {
       manager.connect('grafana');
       enabledNames.clear();
       enabledNames.add('mutated_after_observation');
-      await wire.replay();
+      await wire.restore();
+      await wire.flush();
 
       expect(records).toHaveLength(1);
       expect(records[0]).toMatchObject({
@@ -676,41 +687,6 @@ describe('AgentMcpService', () => {
     }
   });
 
-  it('flushes a parked discovery after the first live wire record on a fresh session', async () => {
-    const manager = new FakeMcpManager();
-    const client = fakeMcpClient([RAW_QUERY]);
-    const rawTools = await client.listTools();
-    manager.setResolved(
-      'grafana',
-      client,
-      await discoverTools(client),
-      new Set(['query_range']),
-      rawTools,
-    );
-    createService(manager);
-
-    const { records, off } = collectDiscoveries();
-    try {
-      manager.connect('grafana');
-      expect(records).toHaveLength(0);
-      wire.dispatch(
-        wireMetadata({
-          protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
-          created_at: 1,
-        }),
-      );
-      expect(records).toHaveLength(1);
-      expect(records[0]).toMatchObject({
-        type: 'mcp.tools_discovered',
-        serverName: 'grafana',
-        tools: rawTools,
-        enabledNames: ['query_range'],
-      });
-    } finally {
-      off.dispose();
-    }
-  });
-
   it('re-records when only the collision outcome changes', async () => {
     const manager = new FakeMcpManager();
     const occupant = fakeMcpClient([RAW_QUERY]);
@@ -724,7 +700,8 @@ describe('AgentMcpService', () => {
     );
     createService(manager);
     manager.connect('graf.ana');
-    await wire.replay();
+    await wire.restore();
+    await wire.flush();
 
     const { records, off } = collectDiscoveries();
     try {
@@ -738,11 +715,13 @@ describe('AgentMcpService', () => {
         rawTools,
       );
       manager.connect('graf_ana');
+      await wire.flush();
       expect(records).toHaveLength(1);
       expect(records[0]!['collisions']).toHaveLength(1);
 
       manager.disconnect('graf.ana');
       manager.connect('graf_ana');
+      await wire.flush();
       expect(records).toHaveLength(2);
       expect(records[1]!['collisions']).toBeUndefined();
     } finally {
diff --git a/packages/agent-core-v2/test/agent/mcp/tools/auth.test.ts b/packages/agent-core-v2/test/agent/mcp/tools/auth.test.ts
index 31f719858..bfa958df7 100644
--- a/packages/agent-core-v2/test/agent/mcp/tools/auth.test.ts
+++ b/packages/agent-core-v2/test/agent/mcp/tools/auth.test.ts
@@ -1,4 +1,4 @@
-import { MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE } from '@moonshot-ai/protocol';
+import { MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE } from '#/agent/mcp/tools/auth';
 import { describe, expect, it } from 'vitest';
 
 import { AlreadyAuthorizedError, type BeginAuthorizationResult, type McpOAuthService } from '#/agent/mcp/oauth/service';
diff --git a/packages/agent-core-v2/test/agent/permissionGate/permissionGate.test.ts b/packages/agent-core-v2/test/agent/permissionGate/permissionGate.test.ts
index 0cfb64d2f..2faa65638 100644
--- a/packages/agent-core-v2/test/agent/permissionGate/permissionGate.test.ts
+++ b/packages/agent-core-v2/test/agent/permissionGate/permissionGate.test.ts
@@ -34,7 +34,7 @@ import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceCo
 import type { ToolCall } from '#/app/llmProtocol/message';
 import { IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 
 import { stubApprovalService } from '../../session/approval/stubs';
 import { stubPermissionModeService } from '../permissionMode/stubs';
@@ -47,6 +47,7 @@ function makeContext(
   toolName: string,
   args: Record<string, unknown> = {},
   display?: ToolInputDisplay,
+  traceId?: string,
 ): ResolvedToolExecutionHookContext {
   const toolCall: ToolCall = {
     type: 'function',
@@ -57,6 +58,7 @@ function makeContext(
   return {
     turnId: 1,
     signal: new AbortController().signal,
+    trace: { traceId },
     toolCall,
     toolCalls: [toolCall],
     args,
@@ -543,6 +545,25 @@ describe('AgentPermissionGate', () => {
       }),
     });
   });
+
+  it('merges the request trace id into approval result telemetry', async () => {
+    mode = 'manual';
+    policyResult = { policyName: 'p', result: { kind: 'ask' } };
+    approvalResponse = { decision: 'approved' };
+    const records = recordTelemetry();
+    const svc = make();
+
+    await svc.authorize(makeContext('bash', {}, undefined, 'trace-approval-1'));
+
+    expect(records).toContainEqual({
+      event: 'permission_approval_result',
+      properties: expect.objectContaining({
+        tool_name: 'bash',
+        result: 'approved',
+        trace_id: 'trace-approval-1',
+      }),
+    });
+  });
 });
 
 interface MutableRulesOptions {
diff --git a/packages/agent-core-v2/test/agent/permissionMode/permissionMode.test.ts b/packages/agent-core-v2/test/agent/permissionMode/permissionMode.test.ts
index 82261cdb6..05fbd52d9 100644
--- a/packages/agent-core-v2/test/agent/permissionMode/permissionMode.test.ts
+++ b/packages/agent-core-v2/test/agent/permissionMode/permissionMode.test.ts
@@ -16,9 +16,10 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'permission-mode-test';
@@ -56,18 +57,19 @@ beforeEach(() => {
   ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: KEY }]));
   ix.stub(IAgentContextInjectorService, injectorStub);
   ix.set(IAgentPermissionModeService, new SyncDescriptor(AgentPermissionModeService));
   log = ix.get(IAppendLogStore);
+  registerTestAgentWire(ix, testWireScope(SCOPE, KEY), { log });
   svc = ix.get(IAgentPermissionModeService);
 });
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, KEY)) {
+async function readRecords(): Promise<WireRecord[]> {
+  await ix.get(IWireService).flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, KEY), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -103,6 +105,9 @@ describe('AgentPermissionModeService (wire-backed)', () => {
 
     expect(svc.mode).toBe('manual');
 
+    svc.setMode('manual');
+    expect(changes).toEqual([]);
+
     svc.setMode('auto');
     expect(svc.mode).toBe('auto');
     expect(changes).toEqual([{ mode: 'auto', previousMode: 'manual' }]);
@@ -121,6 +126,14 @@ describe('AgentPermissionModeService (wire-backed)', () => {
     expect('payload' in records[0]!).toBe(false);
   });
 
+  it('persists an explicitly configured manual mode when it matches the initial value', async () => {
+    svc.setMode('manual');
+
+    expect(await readRecords()).toEqual([
+      { type: 'permission.set_mode', mode: 'manual', time: expect.any(Number) },
+    ]);
+  });
+
   it('registers auto-mode reminder injection through the injection service', async () => {
     expect(registeredInjection?.name).toBe('permission_mode');
 
@@ -186,21 +199,25 @@ describe('AgentPermissionModeService (wire-backed)', () => {
     const ix2 = disposables.add(new TestInstantiationService());
     ix2.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix2.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix2.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: 'permission-mode-replay' }]),
-    );
     const log2 = ix2.get(IAppendLogStore);
-    const fresh = ix2.get(IAgentWireService);
+    const fresh = registerTestAgentWire(ix2, testWireScope(SCOPE, 'permission-mode-replay'), {
+      log: log2,
+    });
 
-    void fresh.replay({ type: 'permission.set_mode', mode: 'auto' });
+    await restoreTestAgentWire(
+      fresh,
+      log2,
+      testWireScope(SCOPE, 'permission-mode-replay'),
+      [{ type: 'permission.set_mode', mode: 'auto' }],
+    );
 
     expect(fresh.getModel(PermissionModeModel)).toBe('auto');
 
-    const written: PersistedRecord[] = [];
-    for await (const record of log2.read<PersistedRecord>(SCOPE, 'permission-mode-replay')) {
+    const written: WireRecord[] = [];
+    for await (const record of log2.read<WireRecord>(testWireScope(SCOPE, 'permission-mode-replay'), AGENT_WIRE_RECORD_KEY)) {
       written.push(record);
     }
-    expect(written).toEqual([]);
+    expect(written[0]).toMatchObject({ type: 'metadata' });
+    expect(written.slice(1)).toEqual([{ type: 'permission.set_mode', mode: 'auto' }]);
   });
 });
diff --git a/packages/agent-core-v2/test/agent/permissionPolicy/permissionPolicyService.test.ts b/packages/agent-core-v2/test/agent/permissionPolicy/permissionPolicyService.test.ts
index b2fdbc0a9..2c0679f76 100644
--- a/packages/agent-core-v2/test/agent/permissionPolicy/permissionPolicyService.test.ts
+++ b/packages/agent-core-v2/test/agent/permissionPolicy/permissionPolicyService.test.ts
@@ -3,7 +3,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import type { ToolCall } from '#/app/llmProtocol/message';
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { DisposableStore } from '#/_base/di/lifecycle';
diff --git a/packages/agent-core-v2/test/agent/permissionPolicy/policies/exit-plan-mode-review-ask.test.ts b/packages/agent-core-v2/test/agent/permissionPolicy/policies/exit-plan-mode-review-ask.test.ts
index a2196b584..7ad1627f4 100644
--- a/packages/agent-core-v2/test/agent/permissionPolicy/policies/exit-plan-mode-review-ask.test.ts
+++ b/packages/agent-core-v2/test/agent/permissionPolicy/policies/exit-plan-mode-review-ask.test.ts
@@ -1,5 +1,6 @@
 import type { ToolCall } from '#/app/llmProtocol/message';
-import type { ApprovalResponse, ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
+import type { ApprovalResponse } from '#/session/approval/approval';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { DisposableStore } from '#/_base/di/lifecycle';
diff --git a/packages/agent-core-v2/test/agent/permissionPolicy/policies/goal-start-review-ask.test.ts b/packages/agent-core-v2/test/agent/permissionPolicy/policies/goal-start-review-ask.test.ts
index 8a4b8da26..81ff3cb57 100644
--- a/packages/agent-core-v2/test/agent/permissionPolicy/policies/goal-start-review-ask.test.ts
+++ b/packages/agent-core-v2/test/agent/permissionPolicy/policies/goal-start-review-ask.test.ts
@@ -1,5 +1,5 @@
 import type { ToolCall } from '#/app/llmProtocol/message';
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 import { describe, expect, it } from 'vitest';
 
 import type { ResolvedToolExecutionHookContext } from '#/agent/toolExecutor/toolHooks';
diff --git a/packages/agent-core-v2/test/agent/permissionRules/permissionRules.test.ts b/packages/agent-core-v2/test/agent/permissionRules/permissionRules.test.ts
index 12e32b56f..517edaa7c 100644
--- a/packages/agent-core-v2/test/agent/permissionRules/permissionRules.test.ts
+++ b/packages/agent-core-v2/test/agent/permissionRules/permissionRules.test.ts
@@ -10,9 +10,10 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'permission-rules-test';
@@ -41,17 +42,18 @@ beforeEach(() => {
   ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: KEY }]));
   ix.set(IAgentPermissionRulesService, new SyncDescriptor(AgentPermissionRulesService));
   log = ix.get(IAppendLogStore);
+  registerTestAgentWire(ix, testWireScope(SCOPE, KEY), { log });
   svc = ix.get(IAgentPermissionRulesService);
 });
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, KEY)) {
+async function readRecords(): Promise<WireRecord[]> {
+  await ix.get(IWireService).flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, KEY), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -120,27 +122,27 @@ describe('AgentPermissionRulesService (wire-backed)', () => {
     const ix2 = disposables.add(new TestInstantiationService());
     ix2.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix2.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix2.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: 'permission-rules-replay' }]),
-    );
     const log2 = ix2.get(IAppendLogStore);
-    const fresh = ix2.get(IAgentWireService);
+    const fresh = registerTestAgentWire(ix2, testWireScope(SCOPE, 'permission-rules-replay'), {
+      log: log2,
+    });
 
-    let changes = 0;
-    disposables.add(fresh.subscribe(PermissionRulesModel, () => (changes += 1)));
-
-    void fresh.replay(...records);
+    await restoreTestAgentWire(
+      fresh,
+      log2,
+      testWireScope(SCOPE, 'permission-rules-replay'),
+      records,
+    );
 
     expect(fresh.getModel(PermissionRulesModel)).toEqual({
       rules: [],
       sessionApprovalRulePatterns: ['Bash(rm *)'],
     });
-    expect(changes).toBe(0);
-    const written: PersistedRecord[] = [];
-    for await (const record of log2.read<PersistedRecord>(SCOPE, 'permission-rules-replay')) {
+    const written: WireRecord[] = [];
+    for await (const record of log2.read<WireRecord>(testWireScope(SCOPE, 'permission-rules-replay'), AGENT_WIRE_RECORD_KEY)) {
       written.push(record);
     }
-    expect(written).toEqual([]);
+    expect(written[0]).toMatchObject({ type: 'metadata' });
+    expect(written.slice(1)).toEqual(records);
   });
 });
diff --git a/packages/agent-core-v2/test/agent/plan/plan.test.ts b/packages/agent-core-v2/test/agent/plan/plan.test.ts
index b57d0d25e..69a53315d 100644
--- a/packages/agent-core-v2/test/agent/plan/plan.test.ts
+++ b/packages/agent-core-v2/test/agent/plan/plan.test.ts
@@ -580,47 +580,48 @@ describe('Plan service', () => {
         [emit] agent.status.updated        { "planMode": true }
         [wire] turn.prompt                 { "input": [ { "type": "text", "text": "Inspect without mutating files" } ], "origin": { "kind": "user" }, "time": "<time>" }
         [emit] turn.started                { "turnId": 0, "origin": { "kind": "user" } }
-        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Inspect without mutating files" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 9, "rawContextTokens": 9 }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [emit] context.spliced             { "start": 0, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Inspect without mutating files" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" } ] }
-        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "<plan-mode-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "plan_mode" } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 566, "rawContextTokens": 566 }
+        [emit] agent.status.updated        { "contextTokens": 9, "rawContextTokens": 9 }
+        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Inspect without mutating files" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
         [emit] context.spliced             { "start": 1, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "<plan-mode-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "plan_mode" } } ] }
+        [emit] agent.status.updated        { "contextTokens": 566, "rawContextTokens": 566 }
+        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "<plan-mode-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "plan_mode" } }, "time": "<time>" }
         [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 566, "rawContextTokens": 569 }
         [wire] llm.tools_snapshot          { "hash": "aca3041121ee711028f726fed37e7b999f7e8885c05dbece76ef97eb43e2ec1e", "tools": [ { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nBackground execution is disabled for this agent. Do not set \`run_in_background=true\`.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running commands, set the \`timeout\` argument in seconds. The default is 60s; foreground commands allow up to 300s; a foreground command that hits its timeout is killed.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Do not set \`run_in_background=true\`; background task management tools are not available.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } } ], "time": "<time>" }
         [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999434, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "aca3041121ee711028f726fed37e7b999f7e8885c05dbece76ef97eb43e2ec1e", "messageCount": 2, "turnStep": "0.1", "time": "<time>" }
         [emit] assistant.delta             { "turnId": 0, "delta": "I will inspect safely." }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [emit] tool.call.delta             { "turnId": 0, "toolCallId": "call_bash", "name": "Bash", "argumentsPart": "{\\"command\\":\\"printf plan-safe\\",\\"timeout\\":60}" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 540, "output": 30, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
         [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 540, "output": 30, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 540, "output": 30, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 540, "output": 30, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
         [emit] agent.status.updated        { "contextTokens": 570, "rawContextTokens": 573 }
         [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "I will inspect safely." } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 570, "rawContextTokens": 580 }
         [emit] tool.call.started           { "turnId": 0, "toolCallId": "call_bash", "name": "Bash", "args": { "command": "printf plan-safe", "timeout": 60 }, "description": "Running: printf plan-safe", "display": { "kind": "command", "command": "printf plan-safe", "cwd": "<cwd>", "language": "bash" } }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [ { "toolCallId": "call_bash", "name": "Bash", "since": "<time>" } ], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "tool.call", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "toolCallId": "call_bash", "name": "Bash", "args": { "command": "printf plan-safe", "timeout": 60 } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 570, "rawContextTokens": 600 }
         [emit] tool.progress               { "turnId": 0, "toolCallId": "call_bash", "update": { "kind": "stdout", "text": "plan-safe" } }
         [emit] tool.result                 { "turnId": 0, "toolCallId": "call_bash", "output": "plan-safe" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "tool.result", "parentUuid": "<uuid-3>", "toolCallId": "call_bash", "result": { "output": "plan-safe" } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 574, "rawContextTokens": 604 }
-        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 540, "output": 30, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 574, "rawContextTokens": 574 }
         [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 540, "output": 30, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "tool_use", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }
+        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 540, "output": 30, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
         [emit] turn.step.started           { "turnId": 0, "step": 2, "stepId": "<uuid-4>" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-4>", "turnId": "0", "step": 2 }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 577, "rawContextTokens": 580 }
         [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999423, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "aca3041121ee711028f726fed37e7b999f7e8885c05dbece76ef97eb43e2ec1e", "messageCount": 4, "turnStep": "0.2", "time": "<time>" }
         [emit] assistant.delta             { "turnId": 0, "delta": "The safe command printed plan-safe." }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 574, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
         [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 1114, "output": 43, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 1114, "output": 43, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 1114, "output": 43, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
         [emit] agent.status.updated        { "contextTokens": 587, "rawContextTokens": 590 }
-        [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The safe command printed plan-safe." } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 587, "rawContextTokens": 600 }
-        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 574, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 587, "rawContextTokens": 587 }
         [emit] turn.step.completed         { "turnId": 0, "step": 2, "stepId": "<uuid-4>", "usage": { "inputOther": 574, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+        [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The safe command printed plan-safe." } }, "time": "<time>" }
+        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 574, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
         [emit] turn.ended                  { "turnId": 0, "reason": "completed" }
       `);
 
@@ -656,47 +657,48 @@ describe('Plan service', () => {
         [emit] agent.status.updated        { "planMode": true }
         [wire] turn.prompt                 { "input": [ { "type": "text", "text": "Remove forbidden.txt" } ], "origin": { "kind": "user" }, "time": "<time>" }
         [emit] turn.started                { "turnId": 0, "origin": { "kind": "user" } }
-        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Remove forbidden.txt" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 8, "rawContextTokens": 8 }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [emit] context.spliced             { "start": 0, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Remove forbidden.txt" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" } ] }
-        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "<plan-mode-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "plan_mode" } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 565, "rawContextTokens": 565 }
+        [emit] agent.status.updated        { "contextTokens": 8, "rawContextTokens": 8 }
+        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Remove forbidden.txt" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
         [emit] context.spliced             { "start": 1, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "<plan-mode-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "plan_mode" } } ] }
+        [emit] agent.status.updated        { "contextTokens": 565, "rawContextTokens": 565 }
+        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "<plan-mode-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "plan_mode" } }, "time": "<time>" }
         [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 565, "rawContextTokens": 568 }
         [wire] llm.tools_snapshot          { "hash": "aca3041121ee711028f726fed37e7b999f7e8885c05dbece76ef97eb43e2ec1e", "tools": [ { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nBackground execution is disabled for this agent. Do not set \`run_in_background=true\`.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running commands, set the \`timeout\` argument in seconds. The default is 60s; foreground commands allow up to 300s; a foreground command that hits its timeout is killed.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Do not set \`run_in_background=true\`; background task management tools are not available.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } } ], "time": "<time>" }
         [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999435, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "aca3041121ee711028f726fed37e7b999f7e8885c05dbece76ef97eb43e2ec1e", "messageCount": 2, "turnStep": "0.1", "time": "<time>" }
         [emit] assistant.delta             { "turnId": 0, "delta": "I will mutate a file." }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [emit] tool.call.delta             { "turnId": 0, "toolCallId": "call_bash", "name": "Bash", "argumentsPart": "{\\"command\\":\\"rm forbidden.txt\\",\\"timeout\\":60}" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 539, "output": 29, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
         [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 539, "output": 29, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 539, "output": 29, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 539, "output": 29, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
         [emit] agent.status.updated        { "contextTokens": 568, "rawContextTokens": 571 }
         [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "I will mutate a file." } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 568, "rawContextTokens": 577 }
         [emit] tool.call.started           { "turnId": 0, "toolCallId": "call_bash", "name": "Bash", "args": { "command": "rm forbidden.txt", "timeout": 60 }, "description": "Running: rm forbidden.txt", "display": { "kind": "command", "command": "rm forbidden.txt", "cwd": "<cwd>", "language": "bash" } }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [ { "toolCallId": "call_bash", "name": "Bash", "since": "<time>" } ], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "tool.call", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "toolCallId": "call_bash", "name": "Bash", "args": { "command": "rm forbidden.txt", "timeout": 60 } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 568, "rawContextTokens": 597 }
         [emit] tool.progress               { "turnId": 0, "toolCallId": "call_bash", "update": { "kind": "stdout", "text": "removed" } }
         [emit] tool.result                 { "turnId": 0, "toolCallId": "call_bash", "output": "removed" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "tool.result", "parentUuid": "<uuid-3>", "toolCallId": "call_bash", "result": { "output": "removed" } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 571, "rawContextTokens": 600 }
-        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 539, "output": 29, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 571, "rawContextTokens": 571 }
         [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 539, "output": 29, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "tool_use", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }
+        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 539, "output": 29, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
         [emit] turn.step.started           { "turnId": 0, "step": 2, "stepId": "<uuid-4>" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-4>", "turnId": "0", "step": 2 }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 574, "rawContextTokens": 577 }
         [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999426, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "aca3041121ee711028f726fed37e7b999f7e8885c05dbece76ef97eb43e2ec1e", "messageCount": 4, "turnStep": "0.2", "time": "<time>" }
         [emit] assistant.delta             { "turnId": 0, "delta": "The command completed." }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 571, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
         [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 1110, "output": 39, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 1110, "output": 39, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 1110, "output": 39, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
         [emit] agent.status.updated        { "contextTokens": 581, "rawContextTokens": 584 }
-        [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The command completed." } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 581, "rawContextTokens": 591 }
-        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 571, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 581, "rawContextTokens": 581 }
         [emit] turn.step.completed         { "turnId": 0, "step": 2, "stepId": "<uuid-4>", "usage": { "inputOther": 571, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+        [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The command completed." } }, "time": "<time>" }
+        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 571, "output": 10, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
         [emit] turn.ended                  { "turnId": 0, "reason": "completed" }
       `);
       expect(toolResultText(context.get())).toContain('removed');
diff --git a/packages/agent-core-v2/test/agent/plan/planOps.test.ts b/packages/agent-core-v2/test/agent/plan/planOps.test.ts
index 1cac99ca6..3c6e1c610 100644
--- a/packages/agent-core-v2/test/agent/plan/planOps.test.ts
+++ b/packages/agent-core-v2/test/agent/plan/planOps.test.ts
@@ -15,9 +15,10 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'plan-test';
@@ -30,9 +31,12 @@ function buildHost(key: string): { wire: IWireService; log: IAppendLogStore; eve
   const ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: key }]));
   ix.set(IEventBus, new SyncDescriptor(EventBusService));
-  return { wire: ix.get(IAgentWireService), log: ix.get(IAppendLogStore), eventBus: ix.get(IEventBus) };
+  const wire = registerTestAgentWire(ix, testWireScope(SCOPE, key), {
+    log: ix.get(IAppendLogStore),
+    eventBus: ix.get(IEventBus),
+  });
+  return { wire, log: ix.get(IAppendLogStore), eventBus: ix.get(IEventBus) };
 }
 
 beforeEach(() => {
@@ -44,9 +48,10 @@ beforeEach(() => {
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(key = KEY): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, key)) {
+async function readRecords(key = KEY): Promise<WireRecord[]> {
+  await wire.flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -116,7 +121,7 @@ describe('plan ops (wire-backed)', () => {
     expect(wire.getModel(PlanModel)).toBe(active);
   });
 
-  it('replay rebuilds active state silently (no emissions, no subscriber notifications)', async () => {
+  it('replay rebuilds active state silently', async () => {
     wire.dispatch(planModeEnter({ id: 'p1' }));
     const records = await readRecords();
 
@@ -125,23 +130,27 @@ describe('plan ops (wire-backed)', () => {
     host.eventBus.subscribe((e) => {
       emissions.push(e.type);
     });
-    let modelChanges = 0;
-    host.wire.subscribe(PlanModel, () => {
-      modelChanges += 1;
-    });
-
-    await host.wire.replay(...records);
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'plan-replay'),
+      records,
+    );
     expect(host.wire.getModel(PlanModel)).toEqual({
       active: true,
       id: 'p1',
     });
     expect(emissions).toEqual([]);
-    expect(modelChanges).toBe(0);
 
     const cancelled = buildHost('plan-replay-cancel');
-    await cancelled.wire.replay(
+    await restoreTestAgentWire(
+      cancelled.wire,
+      cancelled.log,
+      testWireScope(SCOPE, 'plan-replay-cancel'),
+      [
       { type: 'plan_mode.enter', id: 'p1', planFilePath: '/w/plan/p1.md' },
       { type: 'plan_mode.cancel', id: 'p1' },
+      ],
     );
     expect(cancelled.wire.getModel(PlanModel).active).toBe(false);
   });
diff --git a/packages/agent-core-v2/test/agent/profile/binding.test.ts b/packages/agent-core-v2/test/agent/profile/binding.test.ts
index cd9992451..20d57fed1 100644
--- a/packages/agent-core-v2/test/agent/profile/binding.test.ts
+++ b/packages/agent-core-v2/test/agent/profile/binding.test.ts
@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { DEFAULT_AGENT_PROFILE_NAME, IAgentProfileCatalogService } from '#/app/agentProfileCatalog/agentProfileCatalog';
 import { IAgentProfileService } from '#/agent/profile/profile';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 
 import {
   InMemoryWireRecordPersistence,
@@ -74,7 +74,7 @@ describe('AgentProfileService.bind', () => {
       },
     });
     const svc = ctx.get(IAgentProfileService);
-    await ctx.get(IAgentWireService).flush();
+    await ctx.get(IWireService).flush();
     const start = persistence.records.length;
 
     await svc.bind({
@@ -83,7 +83,7 @@ describe('AgentProfileService.bind', () => {
       thinking: 'low',
       cwd: homeDir,
     });
-    await ctx.get(IAgentWireService).flush();
+    await ctx.get(IWireService).flush();
 
     const records = persistence.records
       .slice(start)
diff --git a/packages/agent-core-v2/test/agent/profile/config-state.test.ts b/packages/agent-core-v2/test/agent/profile/config-state.test.ts
index 7dc77ffd2..d39aeeb51 100644
--- a/packages/agent-core-v2/test/agent/profile/config-state.test.ts
+++ b/packages/agent-core-v2/test/agent/profile/config-state.test.ts
@@ -277,6 +277,15 @@ describe('ConfigState thinking clamp for always-thinking models', () => {
           supportEfforts: ['low', 'high', 'ultra'],
           defaultEffort: 'ultra',
         },
+        'kimi-code/compatible': {
+          provider: 'kimi',
+          protocol: 'anthropic',
+          model: 'compatible-model',
+          maxContextSize: 128_000,
+          capabilities: ['thinking', 'always_thinking'],
+          supportEfforts: ['max'],
+          defaultEffort: 'max',
+        } as TestProtocolModelConfig,
       },
     };
     generate = defaultGenerate;
@@ -389,6 +398,38 @@ describe('ConfigState thinking clamp for always-thinking models', () => {
 
     expect(profile.data().thinkingLevel).toBe('max');
   });
+
+  it('preserves unlisted and off efforts for Kimi-managed Anthropic models', () => {
+    profile.update({ modelAlias: 'kimi-code/compatible', thinkingLevel: 'max' });
+
+    expect(() => {
+      profile.setThinking('high');
+    }).not.toThrow();
+    expect(profile.data().thinkingLevel).toBe('high');
+    expect(ctx.allEvents).toContainEqual({
+      type: '[rpc]',
+      event: 'warning',
+      args: {
+        code: 'anthropic-thinking-effort-not-listed',
+        message:
+          'Thinking effort "high" is not listed for model "compatible-model" (known: max). The configured value will be sent unchanged to the Anthropic-compatible backend.',
+      },
+    });
+
+    expect(() => {
+      profile.setThinking('off');
+    }).not.toThrow();
+    expect(profile.data().thinkingLevel).toBe('off');
+    expect(ctx.allEvents).toContainEqual({
+      type: '[rpc]',
+      event: 'warning',
+      args: {
+        code: 'anthropic-thinking-cannot-disable',
+        message:
+          'Model "compatible-model" declares always-on thinking. The configured effort "off" will be sent unchanged to the Anthropic-compatible backend.',
+      },
+    });
+  });
 });
 
 describe('ConfigState.provider applies global KIMI_MODEL_* request config', () => {
diff --git a/packages/agent-core-v2/test/agent/profile/profileOps.test.ts b/packages/agent-core-v2/test/agent/profile/profileOps.test.ts
index cf4ff05fd..ab552c51c 100644
--- a/packages/agent-core-v2/test/agent/profile/profileOps.test.ts
+++ b/packages/agent-core-v2/test/agent/profile/profileOps.test.ts
@@ -25,9 +25,10 @@ import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import { ISessionSkillCatalog } from '#/session/sessionSkillCatalog/skillCatalog';
 import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceContext';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'profile-test';
@@ -92,7 +93,6 @@ function buildHost(key: string): {
   const host = disposables.add(new TestInstantiationService());
   host.stub(IFileSystemStorageService, new InMemoryStorageService());
   host.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  host.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: key }]));
   host.stub(ITelemetryService, createTelemetryStub());
   host.stub(IAgentTelemetryContextService, new AgentTelemetryContextService());
   host.stub(IConfigService, createConfigStub());
@@ -105,9 +105,12 @@ function buildHost(key: string): {
   host.stub(IAgentProfileCatalogService, stubUnused());
   host.stub(ISessionSkillCatalog, stubUnused());
   host.set(IAgentProfileService, new SyncDescriptor(AgentProfileService));
+  const wire = registerTestAgentWire(host, testWireScope(SCOPE, key), {
+    log: host.get(IAppendLogStore),
+  });
   return {
     ix: host,
-    wire: host.get(IAgentWireService),
+    wire,
     svc: host.get(IAgentProfileService),
     log: host.get(IAppendLogStore),
   };
@@ -126,9 +129,10 @@ beforeEach(() => {
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(key = KEY): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, key)) {
+async function readRecords(key = KEY): Promise<WireRecord[]> {
+  await wire.flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -256,17 +260,26 @@ describe('AgentProfileService (wire-backed config.update)', () => {
       },
     });
 
-    await host.wire.replay(...records);
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'profile-replay'),
+      records,
+    );
     expect(modelOf(host.wire).cwd).toBe('/work');
     expect(modelOf(host.wire).profileName).toBe(DEFAULT_AGENT_PROFILE_NAME);
     expect(replayChdir).toBe(0);
     expect(replayEmits).toBe(0);
 
-    const written: PersistedRecord[] = [];
-    for await (const record of host.log.read<PersistedRecord>(SCOPE, 'profile-replay')) {
+    const written: WireRecord[] = [];
+    for await (const record of host.log.read<WireRecord>(
+      testWireScope(SCOPE, 'profile-replay'),
+      AGENT_WIRE_RECORD_KEY,
+    )) {
       written.push(record);
     }
-    expect(written).toEqual([]);
+    expect(written[0]).toMatchObject({ type: 'metadata' });
+    expect(written.slice(1)).toEqual(records);
   });
 
   it('replay rebuilds the resolved thinkingLevel without re-reading config', async () => {
@@ -274,14 +287,24 @@ describe('AgentProfileService (wire-backed config.update)', () => {
     const records = await readRecords();
 
     const host = buildHost('profile-replay-thinking');
-    await host.wire.replay(...records);
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'profile-replay-thinking'),
+      records,
+    );
     expect(modelOf(host.wire).thinkingLevel).toBe('on');
   });
 
   it('replays legacy config.update thinkingLevel records', async () => {
     const host = buildHost('profile-replay-legacy-thinking-level');
 
-    await host.wire.replay({ type: 'config.update', thinkingLevel: 'high' });
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'profile-replay-legacy-thinking-level'),
+      [{ type: 'config.update', thinkingLevel: 'high' }],
+    );
 
     expect(modelOf(host.wire).thinkingLevel).toBe('high');
   });
@@ -289,11 +312,16 @@ describe('AgentProfileService (wire-backed config.update)', () => {
   it('returns the persisted effort when a replayed model alias no longer resolves', async () => {
     const host = buildHost('profile-replay-removed-model');
 
-    await host.wire.replay({
-      type: 'config.update',
-      modelAlias: 'removed-model',
-      thinkingEffort: 'high',
-    });
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'profile-replay-removed-model'),
+      [{
+        type: 'config.update',
+        modelAlias: 'removed-model',
+        thinkingEffort: 'high',
+      }],
+    );
 
     expect(host.svc.getEffectiveThinkingLevel()).toBe('high');
   });
@@ -302,7 +330,12 @@ describe('AgentProfileService (wire-backed config.update)', () => {
     const host = buildHost('profile-replay-conflicting-thinking-aliases');
 
     await expect(
-      host.wire.replay({ type: 'config.update', thinkingEffort: 'low', thinkingLevel: 'high' }),
+      restoreTestAgentWire(
+        host.wire,
+        host.log,
+        testWireScope(SCOPE, 'profile-replay-conflicting-thinking-aliases'),
+        [{ type: 'config.update', thinkingEffort: 'low', thinkingLevel: 'high' }],
+      ),
     ).rejects.toMatchObject({
       code: 'profile.thinking_alias_conflict',
       name: 'ProfileError',
diff --git a/packages/agent-core-v2/test/agent/profile/thinking.test.ts b/packages/agent-core-v2/test/agent/profile/thinking.test.ts
index 750edbcaf..a301c3744 100644
--- a/packages/agent-core-v2/test/agent/profile/thinking.test.ts
+++ b/packages/agent-core-v2/test/agent/profile/thinking.test.ts
@@ -16,10 +16,12 @@ const effortModelWithDefault = {
 const alwaysThinkingModel = {
   capabilities: ['thinking', 'always_thinking'],
   alwaysThinking: true,
+  protocol: 'kimi',
 };
 const alwaysThinkingEffortModel = {
   capabilities: ['thinking', 'always_thinking'],
   alwaysThinking: true,
+  protocol: 'kimi',
   supportEfforts: ['low', 'high', 'max'],
   defaultEffort: 'high',
 };
@@ -117,6 +119,16 @@ describe('resolveThinkingEffort', () => {
     expect(resolveThinkingEffort(undefined, { enabled: false }, booleanModel)).toBe('off');
   });
 
+  it('preserves off for Kimi-managed always-thinking models using Anthropic protocol', () => {
+    expect(
+      resolveThinkingEffort('off', undefined, {
+        ...alwaysThinkingEffortModel,
+        protocol: 'anthropic',
+        providerType: 'kimi',
+      }),
+    ).toBe('off');
+  });
+
   it('carries custom requested efforts through', () => {
     expect(resolveThinkingEffort('xhigh', undefined)).toBe('xhigh');
     expect(resolveThinkingEffort('bogus', { effort: 'low' })).toBe('bogus');
@@ -131,6 +143,7 @@ describe('resolveThinkingEffort', () => {
     expect(
       resolveThinkingEffort('ultra', undefined, {
         ...effortModel,
+        protocol: 'kimi',
         providerType: 'kimi',
       }),
     ).toBe('medium');
@@ -140,6 +153,7 @@ describe('resolveThinkingEffort', () => {
     expect(
       resolveThinkingEffort('ultra', undefined, {
         ...booleanModel,
+        protocol: 'kimi',
         providerType: 'kimi',
       }),
     ).toBe('on');
@@ -147,7 +161,11 @@ describe('resolveThinkingEffort', () => {
 
   it('reports unsupported concrete efforts only for Kimi effort models', () => {
     expect(
-      supportsThinkingEffort('ultra', { ...effortModel, providerType: 'kimi' }),
+      supportsThinkingEffort('ultra', {
+        ...effortModel,
+        protocol: 'kimi',
+        providerType: 'kimi',
+      }),
     ).toBe(false);
     expect(
       supportsThinkingEffort('ultra', { ...effortModel, providerType: 'openai' }),
diff --git a/packages/agent-core-v2/test/agent/prompt/promptService.test.ts b/packages/agent-core-v2/test/agent/prompt/promptService.test.ts
index d546626b0..790fb8770 100644
--- a/packages/agent-core-v2/test/agent/prompt/promptService.test.ts
+++ b/packages/agent-core-v2/test/agent/prompt/promptService.test.ts
@@ -24,7 +24,7 @@ import { IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
 import { ErrorCodes, Error2 } from '#/errors';
 import { createHooks } from '#/hooks';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 
 import { stubContextMemory } from '../contextMemory/stubs';
 import { stubLoopWithHooks, stubToolExecutor, stubWire } from '../loop/stubs';
@@ -49,7 +49,7 @@ function harness() {
     strict: true, additionalServices: (reg) => {
       reg.defineInstance(IAgentContextMemoryService, context);
       reg.defineInstance(IAgentLoopService, loop);
-      reg.defineInstance(IAgentWireService, stubWire());
+      reg.defineInstance(IWireService, stubWire());
       reg.defineInstance(IAgentToolExecutorService, stubToolExecutor());
       reg.defineInstance(IAgentFullCompactionService, fullCompaction);
       reg.define(IEventBus, EventBusService);
@@ -121,7 +121,7 @@ describe('AgentPromptService', () => {
   it('settles the prompt as failed when the loop throws on launch', async () => {
     const { prompt, loop } = harness();
     vi.spyOn(loop, 'enqueue').mockImplementation(() => {
-      throw new Error2(ErrorCodes.ACTIVITY_INITIALIZING, 'Agent is still restoring');
+      throw new Error2(ErrorCodes.TURN_AGENT_BUSY, 'Cannot launch a new turn while another turn is active');
     });
     const handle = await prompt.enqueue({ id: 'prompt-x', message: message('hello') });
     expect(handle.state).toBe('failed');
diff --git a/packages/agent-core-v2/test/agent/questionTools/tools/ask-user.test.ts b/packages/agent-core-v2/test/agent/questionTools/tools/ask-user.test.ts
index 89ad3ab3d..0f57febd9 100644
--- a/packages/agent-core-v2/test/agent/questionTools/tools/ask-user.test.ts
+++ b/packages/agent-core-v2/test/agent/questionTools/tools/ask-user.test.ts
@@ -259,6 +259,7 @@ describe('AskUserQuestionTool', () => {
     );
     expect(telemetryTrack).toHaveBeenCalledWith('question_answered', {
       answered: 1,
+      trace_id: undefined,
     });
   });
 
@@ -314,6 +315,25 @@ describe('AskUserQuestionTool', () => {
     expect(telemetryTrack).toHaveBeenCalledWith('question_answered', {
       answered: 1,
       method: 'number_key',
+      trace_id: undefined,
+    });
+  });
+
+  it('merges the request trace id into question telemetry', async () => {
+    const { tool, telemetryTrack } = makeTool();
+
+    const result = await executeTool(tool, {
+      turnId: 0,
+      toolCallId: 'call_question',
+      args: input(),
+      signal,
+      trace: { traceId: 'trace-q-1' },
+    });
+
+    expect(result).toMatchObject({ isError: false });
+    expect(telemetryTrack).toHaveBeenCalledWith('question_answered', {
+      answered: 1,
+      trace_id: 'trace-q-1',
     });
   });
 
@@ -332,7 +352,7 @@ describe('AskUserQuestionTool', () => {
     expect(result).toMatchObject({ isError: false });
     expect(result.output).toContain('dismissed');
     expect(result.output).toContain('answers');
-    expect(telemetryTrack).toHaveBeenCalledWith('question_dismissed');
+    expect(telemetryTrack).toHaveBeenCalledWith('question_dismissed', { trace_id: undefined });
   });
 
   it('resolves question service error responses as dismissed answers', async () => {
@@ -442,7 +462,6 @@ describe('AskUserQuestionTool', () => {
       expect(result.output).toContain('task_id: q_test_task_id');
       expect(result.output).toContain('automatic_notification: true');
       expect(result.output).toContain('/tasks');
-      expect(result.message).toBe('Started q_test_task_id');
       expect(registerTask).toHaveBeenCalledOnce();
       expect(registerTask.mock.calls[0]![1]).toMatchObject({ detached: true });
       expect(getTask).toHaveBeenCalledWith('q_test_task_id');
diff --git a/packages/agent-core-v2/test/agent/runtime/runtime.test.ts b/packages/agent-core-v2/test/agent/runtime/runtime.test.ts
deleted file mode 100644
index 196f98238..000000000
--- a/packages/agent-core-v2/test/agent/runtime/runtime.test.ts
+++ /dev/null
@@ -1,228 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { SyncDescriptor } from '#/_base/di/descriptors';
-import { DisposableStore } from '#/_base/di/lifecycle';
-import { TestInstantiationService } from '#/_base/di/test';
-import { USER_PROMPT_ORIGIN } from '#/agent/contextMemory/types';
-import type { PermissionApprovalRequestContext } from '#/agent/permissionGate/permissionGateService';
-import { type AgentPhase, IAgentRuntimeService } from '#/agent/runtime/runtime';
-import { AgentRuntimeService } from '#/agent/runtime/runtimeService';
-import { RuntimeModel } from '#/agent/runtime/runtimeOps';
-import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
-import { EventBusService } from '#/app/event/eventBusService';
-import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
-import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
-import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
-import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
-
-const SCOPE = 'wire';
-const KEY = 'runtime-test';
-
-let disposables: DisposableStore;
-let ix: TestInstantiationService;
-let log: IAppendLogStore;
-let eventBus: IEventBus;
-let svc: IAgentRuntimeService;
-
-beforeEach(() => {
-  disposables = new DisposableStore();
-  ix = disposables.add(new TestInstantiationService());
-  ix.stub(IFileSystemStorageService, new InMemoryStorageService());
-  ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: KEY }]));
-  ix.set(IEventBus, new SyncDescriptor(EventBusService));
-  ix.set(IAgentRuntimeService, new SyncDescriptor(AgentRuntimeService));
-  log = ix.get(IAppendLogStore);
-  eventBus = ix.get(IEventBus);
-  svc = ix.get(IAgentRuntimeService);
-});
-
-afterEach(() => disposables.dispose());
-
-function collect(): AgentPhase[] {
-  const phases: AgentPhase[] = [];
-  disposables.add(
-    eventBus.subscribe('agent.status.updated', (e: DomainEvent<'agent.status.updated'>) => {
-      if (e.phase !== undefined) phases.push(e.phase);
-    }),
-  );
-  return phases;
-}
-
-async function readRecords(): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, KEY)) {
-    out.push(record);
-  }
-  return out;
-}
-
-function startTurn(turnId = 1, step = 1, stepId = 's1'): void {
-  eventBus.publish({ type: 'turn.started', turnId, origin: USER_PROMPT_ORIGIN });
-  eventBus.publish({ type: 'turn.step.started', turnId, step, stepId });
-}
-
-const approval = {
-  toolCallId: 'c1',
-  toolName: 'Read',
-  action: 'read',
-  display: {},
-  turnId: 1,
-  toolInput: { path: '/tmp/x' },
-} as unknown as PermissionApprovalRequestContext;
-
-describe('AgentRuntimeService', () => {
-  it('starts idle', () => {
-    expect(svc.phase()).toEqual({ kind: 'idle' });
-  });
-
-  it('turn.started then turn.step.started → running with step cursor', () => {
-    const phases = collect();
-    startTurn();
-
-    expect(svc.phase()).toMatchObject({ kind: 'running', turnId: 1, step: 1, stepId: 's1' });
-    expect(phases.map((p) => p.kind)).toEqual(['running', 'running']);
-  });
-
-  it('first assistant.delta enters streaming(assistant); subsequent deltas are debounced', () => {
-    const phases = collect();
-    startTurn();
-    const baseline = phases.length;
-
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'he' });
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'llo' });
-
-    expect(svc.phase()).toMatchObject({ kind: 'streaming', stream: 'assistant' });
-    expect(phases.length).toBe(baseline + 1);
-  });
-
-  it('thinking.delta switches the stream variant', () => {
-    startTurn();
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'x' });
-    eventBus.publish({ type: 'thinking.delta', turnId: 1, delta: 'hmm' });
-
-    expect(svc.phase()).toMatchObject({ kind: 'streaming', stream: 'thinking' });
-  });
-
-  it('tool.call.delta → streaming(tool_call); tool.call.started → tool_call; tool.result → running', () => {
-    const phases = collect();
-    startTurn();
-
-    eventBus.publish({
-      type: 'tool.call.delta',
-      turnId: 1,
-      toolCallId: 'c1',
-      name: 'Read',
-      argumentsPart: '{',
-    });
-    expect(svc.phase()).toMatchObject({
-      kind: 'streaming',
-      stream: 'tool_call',
-      toolCallId: 'c1',
-      toolName: 'Read',
-    });
-
-    eventBus.publish({ type: 'tool.call.started', turnId: 1, toolCallId: 'c1', name: 'Read', args: {} });
-    expect(svc.phase()).toMatchObject({ kind: 'tool_call', toolCallId: 'c1', name: 'Read' });
-
-    eventBus.publish({ type: 'tool.result', turnId: 1, toolCallId: 'c1', output: 'ok', isError: false });
-    expect(svc.phase()).toMatchObject({ kind: 'running', turnId: 1, step: 1 });
-    expect(phases.map((p) => p.kind)).toEqual([
-      'running',
-      'running',
-      'streaming',
-      'tool_call',
-      'running',
-    ]);
-  });
-
-  it('turn.step.retrying → retrying with the backoff fields', () => {
-    startTurn();
-    eventBus.publish({
-      type: 'turn.step.retrying',
-      turnId: 1,
-      step: 1,
-      stepId: 's1',
-      failedAttempt: 1,
-      nextAttempt: 2,
-      maxAttempts: 3,
-      delayMs: 500,
-      errorName: 'RateLimitError',
-      errorMessage: 'slow down',
-      statusCode: 429,
-    });
-
-    expect(svc.phase()).toMatchObject({
-      kind: 'retrying',
-      failedAttempt: 1,
-      nextAttempt: 2,
-      maxAttempts: 3,
-      delayMs: 500,
-      errorName: 'RateLimitError',
-      statusCode: 429,
-    });
-  });
-
-  it('turn.step.interrupted → interrupted(reason)', () => {
-    startTurn();
-    eventBus.publish({ type: 'turn.step.interrupted', turnId: 1, step: 1, reason: 'aborted' });
-
-    expect(svc.phase()).toMatchObject({ kind: 'interrupted', reason: 'aborted' });
-  });
-
-  it('turn.ended → ended(reason)', () => {
-    startTurn();
-    eventBus.publish({ type: 'turn.ended', turnId: 1, reason: 'completed', durationMs: 123 });
-
-    expect(svc.phase()).toMatchObject({ kind: 'ended', turnId: 1, reason: 'completed', durationMs: 123 });
-  });
-
-  it('permission approval requests pause into awaiting_approval and resolve back to the prior phase', () => {
-    startTurn();
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'hi' });
-    expect(svc.phase().kind).toBe('streaming');
-
-    eventBus.publish({ type: 'permission.approval.requested', ...approval });
-    expect(svc.phase().kind).toBe('awaiting_approval');
-
-    eventBus.publish({ type: 'permission.approval.resolved', ...approval, decision: 'approved' });
-    expect(svc.phase()).toMatchObject({ kind: 'streaming', stream: 'assistant' });
-  });
-
-  it('never persists runtime.set_phase (live-only)', async () => {
-    startTurn();
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'a' });
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'b' });
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'c' });
-    eventBus.publish({ type: 'turn.ended', turnId: 1, reason: 'completed', durationMs: 1 });
-
-    expect(await readRecords()).toEqual([]);
-  });
-
-  it('fresh replay leaves the phase at idle silently (no persisted phase records)', async () => {
-    startTurn();
-    eventBus.publish({ type: 'assistant.delta', turnId: 1, delta: 'hi' });
-    eventBus.publish({ type: 'turn.ended', turnId: 1, reason: 'completed', durationMs: 5 });
-    const records = await readRecords();
-    expect(records).toEqual([]);
-
-    const ix2 = disposables.add(new TestInstantiationService());
-    ix2.stub(IFileSystemStorageService, new InMemoryStorageService());
-    ix2.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix2.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: 'runtime-replay' }]));
-    ix2.set(IEventBus, new SyncDescriptor(EventBusService));
-    const fresh = ix2.get(IAgentWireService);
-    const bus2 = ix2.get(IEventBus);
-
-    const emitted: DomainEvent[] = [];
-    disposables.add(bus2.subscribe((e) => emitted.push(e)));
-
-    await fresh.replay(...records);
-
-    expect(fresh.getModel(RuntimeModel).phase).toEqual({ kind: 'idle' });
-    expect(emitted.filter((e) => e.type === 'agent.status.updated')).toHaveLength(0);
-  });
-});
diff --git a/packages/agent-core-v2/test/agent/skill/skill.test.ts b/packages/agent-core-v2/test/agent/skill/skill.test.ts
index 18742ecd9..c4b07fdaa 100644
--- a/packages/agent-core-v2/test/agent/skill/skill.test.ts
+++ b/packages/agent-core-v2/test/agent/skill/skill.test.ts
@@ -19,10 +19,9 @@ import {
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import type { Turn } from '#/agent/loop/loop';
-import { IAgentWireService } from '#/wire/tokens';
-import { WireService } from '#/wire/wireServiceImpl';
 import { executeTool } from '../../tools/fixtures/execute-tool';
 import { stubSkill } from '../../app/skillCatalog/stubs';
+import { registerTestAgentWireServices } from '../../wire/stubs';
 
 const COMMIT_SKILL = stubSkill('commit', {
   description: 'commit changes',
@@ -72,10 +71,7 @@ describe('AgentSkillService', () => {
           undo: () => 0,
           clear: () => {},
         });
-        reg.defineInstance(
-          IAgentWireService,
-          new WireService({ logScope: 'wire', logKey: 'skill-test' }),
-        );
+        registerTestAgentWireServices(reg, 'wire/skill-test');
         reg.definePartialInstance(ITelemetryService, { track: () => {}, track2: () => {} });
         reg.definePartialInstance(IAgentToolRegistryService, {
           register: () => ({ dispose: () => {} }),
@@ -167,10 +163,7 @@ describe('SkillTool', () => {
           undo: () => 0,
           clear: () => {},
         });
-        reg.defineInstance(
-          IAgentWireService,
-          new WireService({ logScope: 'wire', logKey: 'skill-test' }),
-        );
+        registerTestAgentWireServices(reg, 'wire/skill-test');
         reg.definePartialInstance(ITelemetryService, { track: () => {}, track2: () => {} });
         reg.definePartialInstance(IAgentToolRegistryService, {
           register: () => ({ dispose: () => {} }),
diff --git a/packages/agent-core-v2/test/agent/stepRetry/stepRetry.test.ts b/packages/agent-core-v2/test/agent/stepRetry/stepRetry.test.ts
index 5fa0c6a20..7d0fe8e81 100644
--- a/packages/agent-core-v2/test/agent/stepRetry/stepRetry.test.ts
+++ b/packages/agent-core-v2/test/agent/stepRetry/stepRetry.test.ts
@@ -70,7 +70,7 @@ describe('stepRetry plugin', () => {
           step: 1,
           failedAttempt: 1,
           nextAttempt: 2,
-          maxAttempts: 3,
+          maxAttempts: 10,
           delayMs: expect.any(Number),
           errorName: 'APIConnectionError',
           errorMessage: 'terminated',
@@ -102,11 +102,11 @@ describe('stepRetry plugin', () => {
     const result = await runTurn(1);
 
     expect(result.type).toBe('failed');
-    expect(calls).toBe(3);
-    expect(rpcEvents('turn.step.retrying')).toHaveLength(2);
+    expect(calls).toBe(10);
+    expect(rpcEvents('turn.step.retrying')).toHaveLength(9);
     expect(rpcEvents('turn.step.interrupted')).toEqual([
       expect.objectContaining({
-        args: expect.objectContaining({ reason: 'error', step: 3 }),
+        args: expect.objectContaining({ reason: 'error', step: 10 }),
       }),
     ]);
   });
@@ -221,7 +221,7 @@ describe('stepRetry plugin', () => {
 
     const first = await runTurn(1);
     expect(first.type).toBe('failed');
-    expect(calls).toBe(3);
+    expect(calls).toBe(10);
 
     failing = false;
     const second = await runTurn(2);
diff --git a/packages/agent-core-v2/test/agent/swarm/swarm.test.ts b/packages/agent-core-v2/test/agent/swarm/swarm.test.ts
index d4476de53..30f8d385e 100644
--- a/packages/agent-core-v2/test/agent/swarm/swarm.test.ts
+++ b/packages/agent-core-v2/test/agent/swarm/swarm.test.ts
@@ -5,10 +5,9 @@ import { SyncDescriptor } from '#/_base/di/descriptors';
 import { DisposableStore } from '#/_base/di/lifecycle';
 import { TestInstantiationService } from '#/_base/di/test';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
-const DEFAULT_SUBAGENT_TIMEOUT_MS = 30 * 60 * 1000;
+import { DEFAULT_SUBAGENT_TIMEOUT_MS } from '#/session/subagent/configSection';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { ISessionSwarmService, type SessionSwarmRunResult, type SessionSwarmTask } from '#/session/swarm/sessionSwarm';
-import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
 import { AgentSystemReminderService } from '#/agent/systemReminder/systemReminderService';
 import { IAgentSwarmService } from '#/agent/swarm/swarm';
@@ -19,19 +18,18 @@ import type { ExecutableToolContext } from '#/tool/toolContract';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { AgentToolRegistryService } from '#/agent/toolRegistry/toolRegistryService';
 import { IAgentLoopService } from '#/agent/loop/loop';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { IConfigService } from '#/app/config/config';
 import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
 import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
 
-import { stubContextMemory, stubWireRecord } from '../contextMemory/stubs';
+import { stubContextMemory } from '../contextMemory/stubs';
 import { executeTool } from '../../tools/fixtures/execute-tool';
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 import { stubLoopWithHooks } from '../loop/stubs';
 
 const signal = new AbortController().signal;
@@ -62,6 +60,13 @@ function mockSwarmMode() {
   return { _serviceBrand: undefined, isActive: false, enter: vi.fn(), exit: vi.fn() };
 }
 
+function stubConfig(timeoutMs?: number): IConfigService {
+  return {
+    _serviceBrand: undefined,
+    get: () => (timeoutMs === undefined ? undefined : { timeoutMs }),
+  } as unknown as IConfigService;
+}
+
 describe('AgentSwarmService', () => {
   let disposables: DisposableStore;
   let ix: TestInstantiationService;
@@ -70,13 +75,8 @@ describe('AgentSwarmService', () => {
     disposables = new DisposableStore();
     ix = disposables.add(new TestInstantiationService());
     ix.stub(IAgentContextMemoryService, stubContextMemory());
-    ix.stub(IAgentWireRecordService, stubWireRecord());
     ix.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: 'wire', logKey: 'swarm-test' }]),
-    );
     ix.set(IEventBus, new SyncDescriptor(EventBusService));
     ix.stub(IAgentLoopService, stubLoopWithHooks());
     ix.set(IAgentToolRegistryService, new SyncDescriptor(AgentToolRegistryService));
@@ -86,7 +86,10 @@ describe('AgentSwarmService', () => {
       run: async () => [],
       cancel: () => {},
     });
-    ix.stub(IAgentScopeContext, makeAgentScopeContext({ agentId: 'main', agentScope: '' }));
+    registerTestAgentWire(ix, testWireScope('wire', 'swarm-test'), {
+      log: ix.get(IAppendLogStore),
+      eventBus: ix.get(IEventBus),
+    });
     ix.set(IAgentSystemReminderService, new SyncDescriptor(AgentSystemReminderService));
     ix.set(IAgentSwarmService, new SyncDescriptor(AgentSwarmService));
   });
@@ -115,8 +118,11 @@ describe('AgentSwarmService', () => {
     swarm.enter('manual');
 
     const log = ix.get(IAppendLogStore);
-    const records: PersistedRecord[] = [];
-    for await (const record of log.read<PersistedRecord>('wire', 'swarm-test')) {
+    const records: WireRecord[] = [];
+    for await (const record of log.read<WireRecord>(
+      testWireScope('wire', 'swarm-test'),
+      AGENT_WIRE_RECORD_KEY,
+    )) {
       records.push(record);
     }
     expect(records).toEqual([
@@ -126,12 +132,15 @@ describe('AgentSwarmService', () => {
     const ix2 = disposables.add(new TestInstantiationService());
     ix2.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix2.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix2.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: 'wire', logKey: 'swarm-replay' }]),
+    const fresh = registerTestAgentWire(ix2, testWireScope('wire', 'swarm-replay'), {
+      log: ix2.get(IAppendLogStore),
+    });
+    await restoreTestAgentWire(
+      fresh,
+      ix2.get(IAppendLogStore),
+      testWireScope('wire', 'swarm-replay'),
+      records,
     );
-    const fresh = ix2.get(IAgentWireService);
-    void fresh.replay(...records);
     expect(fresh.getModel(SwarmModel)).toBe('manual');
   });
 });
@@ -181,7 +190,7 @@ describe('AgentSwarmTool', () => {
       ]),
     });
     const swarmMode = mockSwarmMode();
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), swarmMode);
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), swarmMode, stubConfig());
     const input = {
       description: 'Review files',
       prompt_template: 'Review {{item}}',
@@ -278,7 +287,7 @@ describe('AgentSwarmTool', () => {
 
   it('does not expose permission rule argument matching', () => {
     const host = mockSwarmHost();
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
     const execution = tool.resolveExecution({
       description: 'Review files',
       prompt_template: 'Review {{item}}',
@@ -293,7 +302,7 @@ describe('AgentSwarmTool', () => {
 
   it('description states the enforced input requirements', () => {
     const host = mockSwarmHost();
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
     expect(tool.description).toContain('at least 2');
     expect(tool.description).toContain('{{item}}');
     expect(tool.description.toLowerCase()).toContain('distinct');
@@ -345,7 +354,7 @@ describe('AgentSwarmTool', () => {
 
     for (const testCase of cases) {
       const host = mockSwarmHost();
-      const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+      const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
 
       const result = await executeTool(tool, context(testCase.input));
 
@@ -378,7 +387,7 @@ describe('AgentSwarmTool', () => {
       async ({ agentId }: { readonly agentId: string }) => persistedItems[agentId],
     );
     const host = mockSwarmHost({ run, getSwarmItem });
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
     const input = {
       description: 'Finish review',
       subagent_type: 'explore',
@@ -498,7 +507,7 @@ describe('AgentSwarmTool', () => {
     );
     const getSwarmItem = vi.fn(async () => 'src/old-a.ts');
     const host = mockSwarmHost({ run, getSwarmItem });
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
     const input = {
       description: 'Resume review',
       resume_agent_ids: {
@@ -561,7 +570,7 @@ describe('AgentSwarmTool', () => {
         },
       ]),
     });
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
 
     const result = await executeTool(
       tool,
@@ -585,6 +594,29 @@ describe('AgentSwarmTool', () => {
     expect(result.isError).toBeUndefined();
   });
 
+  it('passes the configured subagent timeout to swarm tasks', async () => {
+    const host = mockSwarmHost();
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig(5_000));
+
+    await executeTool(
+      tool,
+      context({
+        description: 'Review files',
+        prompt_template: 'Review {{item}}',
+        items: ['src/a.ts', 'src/b.ts'],
+      }),
+    );
+
+    expect(host.swarmService.run).toHaveBeenCalledWith(
+      expect.objectContaining({
+        tasks: [
+          expect.objectContaining({ timeout: 5_000 }),
+          expect.objectContaining({ timeout: 5_000 }),
+        ],
+      }),
+    );
+  });
+
   it('omits resume hint when incomplete subagents have no agent ids', async () => {
     const host = mockSwarmHost({
       run: vi.fn().mockImplementation(async ({ tasks }) => [
@@ -600,7 +632,7 @@ describe('AgentSwarmTool', () => {
         },
       ]),
     });
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
 
     const result = await executeTool(
       tool,
@@ -647,7 +679,7 @@ describe('AgentSwarmTool', () => {
         },
       ]),
     });
-    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode());
+    const tool = new AgentSwarmTool(host.swarmService, makeAgentScopeContext({ agentId: host.callerAgentId, agentScope: '' }), mockSwarmMode(), stubConfig());
 
     const result = await executeTool(
       tool,
diff --git a/packages/agent-core-v2/test/agent/task/idle-notification-repro.test.ts b/packages/agent-core-v2/test/agent/task/idle-notification-repro.test.ts
index 67f4c547a..115b5f0ac 100644
--- a/packages/agent-core-v2/test/agent/task/idle-notification-repro.test.ts
+++ b/packages/agent-core-v2/test/agent/task/idle-notification-repro.test.ts
@@ -24,8 +24,11 @@ import { join } from 'pathe';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { LifecycleScope, type IAgentScopeHandle } from '#/_base/di/scope';
+import type { generate as kosongGenerate } from '#/app/llmProtocol/generate';
 import { IAgentTaskService } from '#/agent/task/task';
 import { SubagentTask } from '#/session/subagent/tools/subagent-task';
+import { runAgentTurn } from '#/session/subagent/runAgentTurn';
 import { IAgentProfileService } from '#/agent/profile/profile';
 import { IAgentLoopService } from '#/agent/loop/loop';
 import {
@@ -238,6 +241,125 @@ describe('task notification → main agent (real Agent instance)', () => {
     });
   });
 
+  describe('kill ordering vs child loop unwind', () => {
+    type GenerateFn = typeof kosongGenerate;
+
+    function agentScopeHandle(ctx: TestAgentContext, id: string): IAgentScopeHandle {
+      return {
+        id,
+        kind: LifecycleScope.Agent,
+        accessor: { get: ctx.get.bind(ctx) },
+        dispose: () => {},
+      } as IAgentScopeHandle;
+    }
+
+    // Regression for: "manual stop of a background subagent → main
+    // auto-resumes → resume fails with 'already running and cannot run
+    // concurrently'". The killed task used to settle (and notify) the
+    // moment the abort landed — while the child loop was still unwinding,
+    // so the resume guard (`ensureOwnedIdleSubagent`, which reads
+    // `loop.status().state`) rejected the auto-resume. Settlement must
+    // wait for the loop to go idle. A turn that ignores the cancel stays
+    // bounded by the task layer's SIGTERM grace instead.
+    it('stop settles killed + notifies only after the child loop goes idle', async () => {
+      // Child agent whose in-flight LLM call unwinds slowly after cancel
+      // (models a tool mid-execution / a slow request abort): it rejects
+      // 200ms after the abort lands, not immediately.
+      let generateStarted!: () => void;
+      const inFlight = new Promise<void>((resolve) => {
+        generateStarted = resolve;
+      });
+      const slowToCancelGenerate: GenerateFn = async (
+        _chat,
+        _systemPrompt,
+        _tools,
+        _history,
+        _callbacks,
+        options,
+      ) => {
+        const signal = options?.signal;
+        signal?.throwIfAborted();
+        generateStarted();
+        await new Promise<never>((_resolve, reject) => {
+          signal?.addEventListener(
+            'abort',
+            () => {
+              setTimeout(() => {
+                reject(signal.reason);
+              }, 200);
+            },
+            { once: true },
+          );
+        });
+        throw new Error('slowToCancelGenerate returned without being aborted');
+      };
+
+      const main = createTestAgent(taskServices());
+      const child = createTestAgent({ generate: slowToCancelGenerate });
+      try {
+        const childHandle = agentScopeHandle(child, 'agent-child');
+        const childLoop = child.get(IAgentLoopService);
+
+        // Launch the subagent run (what AgentTool.launch does).
+        const controller = new AbortController();
+        const run = await runAgentTurn(
+          childHandle,
+          { kind: 'prompt', prompt: 'do background work' },
+          { signal: controller.signal },
+        );
+        // Mirror AgentTool.launch: the task handle maps summary → result.
+        const completion = run.completion.then((r) => ({ result: r.summary, usage: r.usage }));
+        void completion.catch(() => {});
+
+        // Wait until the in-flight step is genuinely parked inside the LLM
+        // call — the loop reports 'running' before the request starts, and
+        // stopping that early takes a different (already-fast) path.
+        await inFlight;
+        expect(childLoop.status().state).toBe('running');
+
+        const background = main.get(IAgentTaskService);
+        const taskId = background.registerTask(
+          new SubagentTask(
+            { agentId: 'agent-child', profileName: 'coder', completion },
+            'kill-order repro',
+            controller,
+          ),
+          { detached: true, timeoutMs: 0 },
+        );
+
+        // The main agent is idle; the killed notification auto-launches a turn.
+        main.mockNextResponse({ type: 'text', text: 'ack from main agent' });
+        const notificationTurnEnd = main.untilTurnEnd();
+
+        // Manual stop (TUI / REST path — no notification suppression).
+        const info = await background.stop(taskId, 'User initiated stop');
+        expect(info?.status).toBe('killed');
+        // Settlement waited for the child loop to unwind — this is the
+        // assertion the old race-based implementation fails.
+        expect(childLoop.status().state).toBe('idle');
+
+        // The task.killed notification reaches the main agent (this is what
+        // makes main call Agent(resume="agent-child")), and by then the
+        // resume guard's precondition already holds.
+        await vi.waitFor(
+          () => {
+            expect(main.llmCalls.length).toBeGreaterThanOrEqual(1);
+          },
+          { timeout: 2000 },
+        );
+        const notified = JSON.stringify(main.llmCalls.at(-1)!.history);
+        expect(notified).toContain('task.killed');
+        expect(notified).toContain(taskId);
+        expect(childLoop.status().state).toBe('idle');
+
+        await notificationTurnEnd;
+      } finally {
+        await main.dispose();
+        await child.dispose();
+      }
+    });
+  });
+
   describe('resumed notifications', () => {
     let sessionDir: string;
     let ctx: TestAgentContext;
diff --git a/packages/agent-core-v2/test/agent/task/rpc-events.test.ts b/packages/agent-core-v2/test/agent/task/rpc-events.test.ts
index 50001b968..ffd132c72 100644
--- a/packages/agent-core-v2/test/agent/task/rpc-events.test.ts
+++ b/packages/agent-core-v2/test/agent/task/rpc-events.test.ts
@@ -502,7 +502,7 @@ describe('AgentTaskService — notification delivery', () => {
     const { agent, ctx, manager } = createAgentTaskService();
     const taskId = registerProcess(manager, pendingProcess(), 'sleep 60', 'long shell task');
 
-    await manager.stop(taskId);
+    await manager.stopByUser(taskId);
 
     await vi.waitFor(() => {
       expect(notifiedCount(ctx)).toBe(1);
@@ -516,9 +516,7 @@ describe('AgentTaskService — notification delivery', () => {
       status: 'killed',
       notificationId: `task:${taskId}:killed`,
     });
-    expect(message.content[0]!.text).toContain(
-      'Background process killed',
-    );
+    expect(message.content[0]!.text).toContain('long shell task was stopped by user.');
   });
 
   it('TaskStopTool suppresses the real terminal notification for model-requested stops', async () => {
diff --git a/packages/agent-core-v2/test/agent/task/taskManager.test.ts b/packages/agent-core-v2/test/agent/task/taskManager.test.ts
index eede8e5a3..212bfdd1c 100644
--- a/packages/agent-core-v2/test/agent/task/taskManager.test.ts
+++ b/packages/agent-core-v2/test/agent/task/taskManager.test.ts
@@ -477,7 +477,7 @@ describe('AgentTaskService', () => {
     expect(killSpy).toHaveBeenCalledWith('SIGTERM');
     expect(manager.getTask(taskId)).toMatchObject({
       status: 'killed',
-      stopReason: 'Interrupted by user',
+      stopReason: 'Aborted by the user',
     });
   });
 
@@ -507,7 +507,7 @@ describe('AgentTaskService', () => {
     const info = await manager.wait(taskId);
     expect(info).toMatchObject({
       status: 'killed',
-      stopReason: 'Interrupted by user',
+      stopReason: 'Aborted by the user',
     });
     expect(isUserCancellation(subagentController.signal.reason)).toBe(true);
   });
diff --git a/packages/agent-core-v2/test/agent/task/taskOps.test.ts b/packages/agent-core-v2/test/agent/task/taskOps.test.ts
index 375077a3f..828dc4b7b 100644
--- a/packages/agent-core-v2/test/agent/task/taskOps.test.ts
+++ b/packages/agent-core-v2/test/agent/task/taskOps.test.ts
@@ -11,9 +11,10 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'task-test';
@@ -26,9 +27,12 @@ function buildHost(key: string): { wire: IWireService; log: IAppendLogStore; eve
   const ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: key }]));
   ix.set(IEventBus, new SyncDescriptor(EventBusService));
-  return { wire: ix.get(IAgentWireService), log: ix.get(IAppendLogStore), eventBus: ix.get(IEventBus) };
+  const wire = registerTestAgentWire(ix, testWireScope(SCOPE, key), {
+    log: ix.get(IAppendLogStore),
+    eventBus: ix.get(IEventBus),
+  });
+  return { wire, log: ix.get(IAppendLogStore), eventBus: ix.get(IEventBus) };
 }
 
 beforeEach(() => {
@@ -40,9 +44,10 @@ beforeEach(() => {
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(key = KEY): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, key)) {
+async function readRecords(key = KEY): Promise<WireRecord[]> {
+  await wire.flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -84,29 +89,28 @@ describe('task ops (wire-backed)', () => {
     expect(after.get('t1')?.status).toBe('running');
   });
 
-  it('replay rebuilds the task map from legacy task.* records silently (no emissions, no subscriber notifications)', async () => {
-    const records: PersistedRecord[] = [
+  it('replay rebuilds the task map from legacy task.* records silently', async () => {
+    const records: WireRecord[] = [
       { type: 'task.started', info: info('t1', 'running') },
       { type: 'task.terminated', info: info('t1', 'completed') },
       { type: 'task.started', info: info('t2', 'running') },
-    ] as unknown as PersistedRecord[];
+    ] as unknown as WireRecord[];
 
     const host = buildHost('task-replay');
     const emissions: string[] = [];
     host.eventBus.subscribe((e) => {
       emissions.push(e.type);
     });
-    let modelChanges = 0;
-    host.wire.subscribe(TaskModel, () => {
-      modelChanges += 1;
-    });
-
-    await host.wire.replay(...records);
+    await restoreTestAgentWire(
+      host.wire,
+      host.log,
+      testWireScope(SCOPE, 'task-replay'),
+      records,
+    );
     const model = host.wire.getModel(TaskModel);
     expect(model.size).toBe(2);
     expect(model.get('t1')?.status).toBe('completed');
     expect(model.get('t2')?.status).toBe('running');
     expect(emissions).toEqual([]);
-    expect(modelChanges).toBe(0);
   });
 });
diff --git a/packages/agent-core-v2/test/agent/task/taskService.test.ts b/packages/agent-core-v2/test/agent/task/taskService.test.ts
index 7c2c37468..f873dfeb9 100644
--- a/packages/agent-core-v2/test/agent/task/taskService.test.ts
+++ b/packages/agent-core-v2/test/agent/task/taskService.test.ts
@@ -38,15 +38,14 @@ import { IAtomicDocumentStore } from '#/persistence/interface/atomicDocumentStor
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService } from '#/wire/wireService';
+import { createHooks } from '#/hooks';
+import { IWireService, type WireHooks } from '#/wire/wire';
 import { IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
 import { ITaskService } from '#/app/task/task';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 
-import { stubContextMemory, stubWireRecord } from '../contextMemory/stubs';
+import { stubContextMemory } from '../contextMemory/stubs';
 import { stubLoopWithHooks } from '../loop/stubs';
 import type { TaskServiceTestManager } from './stubs';
 
@@ -60,24 +59,21 @@ function fakeProcessTask(): AgentTask {
   };
 }
 
-type RestoreHandler = Parameters<IWireService['onRestored']>[0];
+type RestoreHook = IWireService['hooks']['onDidRestore'];
 
-function stubWireService(captureRestored?: (handler: RestoreHandler) => void): IWireService {
+function stubWireService(captureRestoreHook?: (hook: RestoreHook) => void): IWireService {
+  const hooks = createHooks<WireHooks, keyof WireHooks>(['onDidRestore']);
+  captureRestoreHook?.(hooks.onDidRestore);
   return {
     _serviceBrand: undefined,
+    hooks,
     dispatch: () => {},
-    replay: async () => {},
-    signal: () => {},
+    seal: async () => {},
+    restore: async () => {},
     flush: async () => {},
-    attach: () => toDisposable(() => {}),
-    getModel: () => new Map(),
+    getModel: (model) => model.initial() as never,
     subscribe: () => toDisposable(() => {}),
-    onEmission: () => toDisposable(() => {}),
-    onRestored: (handler: RestoreHandler) => {
-      captureRestored?.(handler);
-      return toDisposable(() => {});
-    },
-  } as unknown as IWireService;
+  } as IWireService;
 }
 
 describe('AgentTaskService', () => {
@@ -91,8 +87,7 @@ describe('AgentTaskService', () => {
     ix = disposables.add(new TestInstantiationService());
     eventBus = disposables.add(new EventBusService());
     injectionProviders = new Map();
-    ix.stub(IAgentWireRecordService, stubWireRecord());
-    ix.stub(IAgentWireService, stubWireService());
+    ix.stub(IWireService, stubWireService());
     ix.stub(IEventBus, eventBus);
     ix.stub(IAgentContextInjectorService, {
       register: (name, provider) => {
@@ -395,11 +390,10 @@ describe('AgentTaskService', () => {
     agentId: string,
     docs: IAtomicDocumentStore,
     bytes: IFileSystemStorageService,
-    captureRestored?: (handler: RestoreHandler) => void,
+    captureRestoreHook?: (hook: RestoreHook) => void,
   ): TestInstantiationService {
     const ix = disposables.add(new TestInstantiationService());
-    ix.stub(IAgentWireRecordService, stubWireRecord());
-    ix.stub(IAgentWireService, stubWireService(captureRestored));
+    ix.stub(IWireService, stubWireService(captureRestoreHook));
     ix.stub(IEventBus, disposables.add(new EventBusService()));
     ix.stub(IAgentContextInjectorService, {
       register: () => toDisposable(() => {}),
@@ -503,12 +497,12 @@ describe('AgentTaskService', () => {
       'output.log',
       new TextEncoder().encode('legacy output'),
     );
-    let restore!: RestoreHandler;
-    const main = buildAgentIx('main', docs, bytes, (handler) => {
-      restore = handler;
+    let restoreHook!: RestoreHook;
+    const main = buildAgentIx('main', docs, bytes, (hook) => {
+      restoreHook = hook;
     }).get(IAgentTaskService);
 
-    await restore();
+    await restoreHook.run({});
 
     expect(main.list(false)).toEqual([
       expect.objectContaining({ taskId, description: 'legacy task', status: 'completed' }),
@@ -540,12 +534,12 @@ describe('AgentTaskService', () => {
       status: 'completed',
       detached: true,
     });
-    let restore!: RestoreHandler;
-    const subagent = buildAgentIx('agent-1', docs, bytes, (handler) => {
-      restore = handler;
+    let restoreHook!: RestoreHook;
+    const subagent = buildAgentIx('agent-1', docs, bytes, (hook) => {
+      restoreHook = hook;
     }).get(IAgentTaskService);
 
-    await restore();
+    await restoreHook.run({});
 
     expect(subagent.list(false)).toEqual([]);
   });
diff --git a/packages/agent-core-v2/test/agent/task/tools/task-tools.test.ts b/packages/agent-core-v2/test/agent/task/tools/task-tools.test.ts
index f5bc14540..97051a38b 100644
--- a/packages/agent-core-v2/test/agent/task/tools/task-tools.test.ts
+++ b/packages/agent-core-v2/test/agent/task/tools/task-tools.test.ts
@@ -220,6 +220,10 @@ class FakeTaskService implements IAgentTaskService {
     return entry.info;
   }
 
+  async stopByUser(taskId: string): Promise<AgentTaskInfo | undefined> {
+    return this.stop(taskId, 'Aborted by the user');
+  }
+
   async stopAll(reason?: string): Promise<readonly AgentTaskInfo[]> {
     const stopped = await Promise.all(
       Array.from(this.entries.keys()).map((taskId) => this.stop(taskId, reason)),
@@ -441,7 +445,7 @@ describe('TaskOutputTool', () => {
     );
     const output = outputString(result);
 
-    expect(result).toMatchObject({ isError: false, message: 'Task snapshot retrieved.' });
+    expect(result).toMatchObject({ isError: false });
     expect(output).toContain('retrieval_status: success');
     expect(output).toContain('status: completed');
     expect(output).toContain('[output]\nDETACHED-PAYLOAD-LINE');
diff --git a/packages/agent-core-v2/test/agent/toolDedupe/toolDedupe.test.ts b/packages/agent-core-v2/test/agent/toolDedupe/toolDedupe.test.ts
index ed7c394b1..6103cc0ea 100644
--- a/packages/agent-core-v2/test/agent/toolDedupe/toolDedupe.test.ts
+++ b/packages/agent-core-v2/test/agent/toolDedupe/toolDedupe.test.ts
@@ -18,14 +18,11 @@ import { IAgentToolExecutorService, type ToolExecutionResult } from '#/agent/too
 import { AgentToolExecutorService } from '#/agent/toolExecutor/toolExecutorService';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { AgentToolRegistryService } from '#/agent/toolRegistry/toolRegistryService';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
-import { IAgentWireService } from '#/wire/tokens';
-import { WireService } from '#/wire/wireServiceImpl';
-import { stubWireRecord } from '../contextMemory/stubs';
 import { registerLogServices } from '../../_base/log/stubs';
 import { recordingTelemetry, type TelemetryRecord } from '../../app/telemetry/stubs';
 import { stubLoopWithHooks } from '../loop/stubs';
 import { registerToolResultTruncationServices } from '../toolResultTruncation/stubs';
+import { registerTestAgentWireServices } from '../../wire/stubs';
 
 const { REMINDER_TEXT_1, REMINDER_TEXT_3, makeReminderText2 } = toolDedupeTesting;
 const ZERO_USAGE = emptyUsage();
@@ -57,6 +54,7 @@ function createHarness(telemetry: ITelemetryService = recordingTelemetry(telemet
   const loop = stubLoopWithHooks();
   const ix = createServices(disposables, {
     additionalServices: (reg) => {
+      registerTestAgentWireServices(reg, 'wire/tool-dedupe');
       reg.defineInstance(ITelemetryService, telemetry);
       reg.defineInstance(IEventBus, noopEventBus);
       const homedir = '/tmp/tool-dedupe-homedir';
@@ -77,17 +75,11 @@ function createHarness(telemetry: ITelemetryService = recordingTelemetry(telemet
       } satisfies IAgentScopeContext);
       reg.defineInstance(IBootstrapService, {
         homeDir: homedir,
-        agentHomedir: () => homedir,
       } as unknown as IBootstrapService);
       reg.defineInstance(IAgentLoopService, loop);
       reg.define(IAgentToolRegistryService, AgentToolRegistryService);
       reg.define(IAgentToolExecutorService, AgentToolExecutorService);
       registerToolResultTruncationServices(reg);
-      reg.defineInstance(IAgentWireRecordService, stubWireRecord());
-      reg.defineInstance(
-        IAgentWireService,
-        disposables.add(new WireService({ logScope: 'wire', logKey: 'tool-dedupe' })),
-      );
       reg.define(IAgentToolDedupeService, AgentToolDedupeService);
       registerLogServices(reg);
     },
@@ -169,9 +161,10 @@ async function executeAll(
   calls: ToolCall[],
   turnId: number,
   signal = new AbortController().signal,
+  traceId?: string,
 ): Promise<ToolExecutionResult[]> {
   const results: ToolExecutionResult[] = [];
-  for await (const item of h.executor.execute(calls, { turnId, signal })) {
+  for await (const item of h.executor.execute(calls, { turnId, signal, trace: { traceId } })) {
     results.push(item);
   }
   return results;
@@ -685,6 +678,34 @@ describe('AgentToolDedupeService', () => {
       });
     });
 
+    it('merges the request trace id into dedupe and repeat telemetry', async () => {
+      const h = createHarness();
+      h.registry.register(new EchoTool('Read'));
+      await runStep(h, 7, 1, [toolCall('c1', 'Read', { path: '/a' })]);
+      telemetryEvents.length = 0;
+
+      const signal = new AbortController().signal;
+      await beforeStep(h, 7, 2, signal);
+      await executeAll(h, [toolCall('c2', 'Read', { path: '/a' })], 7, signal, 'trace-dedupe-1');
+
+      expect(telemetryEvents).toContainEqual({
+        event: 'tool_call_dedup_detected',
+        properties: expect.objectContaining({
+          tool_call_id: 'c2',
+          dup_type: 'cross_step',
+          trace_id: 'trace-dedupe-1',
+        }),
+      });
+      expect(telemetryEvents).toContainEqual({
+        event: 'tool_call_repeat',
+        properties: expect.objectContaining({
+          tool_name: 'Read',
+          repeat_count: 2,
+          trace_id: 'trace-dedupe-1',
+        }),
+      });
+    });
+
     it('does not keep interrupted cross-step history just for duplicate telemetry', async () => {
       const h = createHarness();
       h.registry.register(new EchoTool('Read'));
diff --git a/packages/agent-core-v2/test/agent/toolExecutor/toolExecutor.test.ts b/packages/agent-core-v2/test/agent/toolExecutor/toolExecutor.test.ts
index 8e5e56a65..fbf9eba0f 100644
--- a/packages/agent-core-v2/test/agent/toolExecutor/toolExecutor.test.ts
+++ b/packages/agent-core-v2/test/agent/toolExecutor/toolExecutor.test.ts
@@ -1,5 +1,6 @@
 import type { ToolCall } from '#/app/llmProtocol/message';
-import type { AgentEvent, ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { DomainEvent } from '#/app/event/eventBus';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { SyncDescriptor } from '#/_base/di/descriptors';
@@ -19,14 +20,14 @@ import { AgentToolExecutorService, parseToolCallArguments } from '#/agent/toolEx
 import { IAgentToolResultTruncationService } from '#/agent/toolResultTruncation/toolResultTruncation';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { AgentToolRegistryService } from '#/agent/toolRegistry/toolRegistryService';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
-import { IAgentWireService } from '#/wire/tokens';
-import { WireService } from '#/wire/wireServiceImpl';
 import { IEventBus } from '#/app/event/eventBus';
+import type { LLMRequestTrace } from '#/app/llmProtocol/requestTrace';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
-import { stubWireRecord } from '../contextMemory/stubs';
+import { IAgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContext';
+import { AgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContextService';
 import { registerLogServices } from '../../_base/log/stubs';
 import { recordingTelemetry, type TelemetryRecord } from '../../app/telemetry/stubs';
+import { registerTestAgentWireServices } from '../../wire/stubs';
 
 type ToolExecutorEvent =
   | { readonly type: 'tool.result'; readonly toolCallId: string; readonly result: ToolResult };
@@ -36,7 +37,7 @@ let ix: TestInstantiationService;
 let executor: IAgentToolExecutorService;
 let registry: IAgentToolRegistryService;
 let events: ToolExecutorEvent[];
-let protocolEvents: AgentEvent[];
+let protocolEvents: DomainEvent[];
 let telemetryEvents: TelemetryRecord[];
 let truncateForModel: IAgentToolResultTruncationService['truncateForModel'];
 
@@ -48,14 +49,11 @@ beforeEach(() => {
   truncateForModel = async (input) => input.result;
   ix = createServices(disposables, {
     additionalServices: (reg) => {
+      registerTestAgentWireServices(reg, 'wire/tool-executor');
       reg.define(IAgentToolRegistryService, AgentToolRegistryService);
       reg.define(IAgentToolExecutorService, AgentToolExecutorService);
-      reg.defineInstance(IAgentWireRecordService, stubWireRecord());
-      reg.defineInstance(
-        IAgentWireService,
-        disposables.add(new WireService({ logScope: 'wire', logKey: 'tool-executor' })),
-      );
       reg.defineInstance(ITelemetryService, recordingTelemetry(telemetryEvents));
+      reg.defineInstance(IAgentTelemetryContextService, new AgentTelemetryContextService());
       reg.defineInstance(IAgentToolResultTruncationService, {
         _serviceBrand: undefined,
         truncateForModel: (input) => truncateForModel(input),
@@ -63,7 +61,7 @@ beforeEach(() => {
       reg.defineInstance(IEventBus, {
         publish: (event: { type: string }) => {
           if (event.type.startsWith('tool.')) {
-            protocolEvents.push(event as unknown as AgentEvent);
+            protocolEvents.push(event as unknown as DomainEvent);
           }
         },
         subscribe: (..._args: unknown[]) => ({ dispose: () => {} }),
@@ -145,6 +143,25 @@ describe('AgentToolExecutorService', () => {
     });
   });
 
+  it('merges the request trace id into tool_call telemetry', async () => {
+    const tool = new TestTool('echo');
+    registry.register(tool);
+
+    await execute(
+      [toolCall('call_traced', 'echo', { text: 'hi' })],
+      undefined,
+      { traceId: 'trace-tool-1' },
+    );
+
+    expect(telemetryEvents).toContainEqual({
+      event: 'tool_call',
+      properties: expect.objectContaining({
+        tool_call_id: 'call_traced',
+        trace_id: 'trace-tool-1',
+      }),
+    });
+  });
+
   it('truncates final tool results before publishing protocol events', async () => {
     truncateForModel = async (input) => ({
       ...input.result,
@@ -185,7 +202,7 @@ describe('AgentToolExecutorService', () => {
       note: '<system>Image compressed.</system>',
     });
     const protocolResult = protocolEvents.find(
-      (event): event is Extract<AgentEvent, { type: 'tool.result' }> =>
+      (event): event is Extract<DomainEvent, { type: 'tool.result' }> =>
         event.type === 'tool.result',
     );
     expect(protocolResult).toMatchObject({
@@ -341,7 +358,7 @@ describe('AgentToolExecutorService', () => {
       }),
     ]);
     const toolCallEvent = protocolEvents.find(
-      (event): event is Extract<AgentEvent, { type: 'tool.call.started' }> =>
+      (event): event is Extract<DomainEvent, { type: 'tool.call.started' }> =>
         event.type === 'tool.call.started',
     );
     expect(toolCallEvent?.args).toEqual({ x: 1 });
@@ -735,11 +752,16 @@ describe('parseToolCallArguments', () => {
   });
 });
 
-async function execute(calls: ToolCall[], signal?: AbortSignal): Promise<ToolResult[]> {
+async function execute(
+  calls: ToolCall[],
+  signal?: AbortSignal,
+  trace?: LLMRequestTrace,
+): Promise<ToolResult[]> {
   const results: ToolResult[] = [];
   for await (const item of executor.execute(calls, {
     turnId: 0,
     signal: signal ?? new AbortController().signal,
+    trace,
   })) {
     results.push(item.result);
     events.push({ type: 'tool.result', toolCallId: item.toolCallId, result: item.result });
@@ -760,7 +782,7 @@ function eventTypes(): ToolExecutorEvent['type'][] {
   return events.map((event) => event.type);
 }
 
-function protocolEventTypes(): AgentEvent['type'][] {
+function protocolEventTypes(): DomainEvent['type'][] {
   return protocolEvents.map((event) => event.type);
 }
 
@@ -768,13 +790,13 @@ function pairedToolCallIds(): { readonly calls: string[]; readonly results: stri
   return {
     calls: protocolEvents
       .filter(
-        (event): event is Extract<AgentEvent, { type: 'tool.call.started' }> =>
+        (event): event is Extract<DomainEvent, { type: 'tool.call.started' }> =>
           event.type === 'tool.call.started',
       )
       .map((event) => event.toolCallId),
     results: protocolEvents
       .filter(
-        (event): event is Extract<AgentEvent, { type: 'tool.result' }> =>
+        (event): event is Extract<DomainEvent, { type: 'tool.result' }> =>
           event.type === 'tool.result',
       )
       .map((event) => event.toolCallId),
diff --git a/packages/agent-core-v2/test/agent/toolSelect/toolSelect.e2e.test.ts b/packages/agent-core-v2/test/agent/toolSelect/toolSelect.e2e.test.ts
index 09f62146b..db6e07250 100644
--- a/packages/agent-core-v2/test/agent/toolSelect/toolSelect.e2e.test.ts
+++ b/packages/agent-core-v2/test/agent/toolSelect/toolSelect.e2e.test.ts
@@ -41,7 +41,7 @@ const DISCLOSURE_CAPABILITIES = {
   thinking: false,
   tool_use: true,
   max_context_tokens: 128_000,
-  select_tools: true,
+  dynamically_loaded_tools: true,
 } as const;
 
 type WireEvent = Extract<
diff --git a/packages/agent-core-v2/test/agent/toolSelect/toolSelectService.test.ts b/packages/agent-core-v2/test/agent/toolSelect/toolSelectService.test.ts
index 9588d5f8e..6f166a261 100644
--- a/packages/agent-core-v2/test/agent/toolSelect/toolSelectService.test.ts
+++ b/packages/agent-core-v2/test/agent/toolSelect/toolSelectService.test.ts
@@ -50,6 +50,8 @@ import { AgentToolSelectAnnouncementsService } from '#/agent/toolSelect/toolSele
 import { AgentToolSelectService } from '#/agent/toolSelect/toolSelectService';
 import { SelectToolsTool } from '#/agent/toolSelect/tools/select-tools';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
+import { IAgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContext';
+import { AgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContextService';
 import { registerLogServices } from '../../_base/log/stubs';
 import { recordingTelemetry } from '../../app/telemetry/stubs';
 import { stubToolExecutor } from '../loop/stubs';
@@ -73,7 +75,7 @@ let activeToolNames: ReadonlySet<string> | undefined;
 
 beforeEach(() => {
   disposables = new DisposableStore();
-  capabilities = makeCapabilities({ tool_use: true, select_tools: true });
+  capabilities = makeCapabilities({ tool_use: true, dynamically_loaded_tools: true });
   flagEnabled = false;
   activeToolNames = undefined;
 });
@@ -82,7 +84,7 @@ afterEach(() => disposables.dispose());
 
 function makeCapabilities(overrides: {
   readonly tool_use?: boolean;
-  readonly select_tools?: boolean;
+  readonly dynamically_loaded_tools?: boolean;
 } = {}): ModelCapability {
   return {
     image_in: false,
@@ -91,7 +93,7 @@ function makeCapabilities(overrides: {
     thinking: false,
     tool_use: overrides.tool_use ?? false,
     max_context_tokens: 128_000,
-    select_tools: overrides.select_tools,
+    dynamically_loaded_tools: overrides.dynamically_loaded_tools,
   };
 }
 
@@ -225,6 +227,8 @@ class FakeLoopService implements IAgentLoopService {
     return false;
   }
 
+  async settled(): Promise<void> {}
+
   registerLoopErrorHandler(): IDisposable {
     throw new Error('unused in this suite');
   }
@@ -351,6 +355,7 @@ function createExecutorHarness(): ExecutorHarness {
     additionalServices: (reg) => {
       registerSharedServices(reg, contextMemory, loop, eventBus);
       reg.defineInstance(ITelemetryService, recordingTelemetry([]));
+      reg.defineInstance(IAgentTelemetryContextService, new AgentTelemetryContextService());
       reg.define(IAgentToolExecutorService, AgentToolExecutorService);
       registerToolResultTruncationServices(reg);
     },
@@ -413,22 +418,22 @@ async function execute(
 }
 
 describe('AgentToolSelectService gate', () => {
-  it('opens only when select_tools capability, tool_use capability and flag are all on', () => {
+  it('opens only when dynamically_loaded_tools capability, tool_use capability and flag are all on', () => {
     flagEnabled = true;
     const { sut } = createHarness();
     expect(sut.enabled()).toBe(true);
   });
 
-  it('stays closed without the select_tools capability', () => {
+  it('stays closed without the dynamically_loaded_tools capability', () => {
     flagEnabled = true;
-    capabilities = makeCapabilities({ tool_use: true, select_tools: false });
+    capabilities = makeCapabilities({ tool_use: true, dynamically_loaded_tools: false });
     const { sut } = createHarness();
     expect(sut.enabled()).toBe(false);
   });
 
   it('stays closed without tool_use capability', () => {
     flagEnabled = true;
-    capabilities = makeCapabilities({ tool_use: false, select_tools: true });
+    capabilities = makeCapabilities({ tool_use: false, dynamically_loaded_tools: true });
     const { sut } = createHarness();
     expect(sut.enabled()).toBe(false);
   });
@@ -441,7 +446,7 @@ describe('AgentToolSelectService gate', () => {
 });
 
 describe('AgentToolSelectService S0 baseline (gate closed)', () => {
-  it('shapeTools returns the identical array when select_tools is absent', () => {
+  it('shapeTools returns the identical array when dynamically_loaded_tools is absent', () => {
     const h = createHarness();
     registerBuiltin(h, new EchoTool());
     registerMcp(h, new StubMcpTool(MCP_ALPHA));
diff --git a/packages/agent-core-v2/test/agent/usage/usage.test.ts b/packages/agent-core-v2/test/agent/usage/usage.test.ts
index 0db1886ad..8e086f440 100644
--- a/packages/agent-core-v2/test/agent/usage/usage.test.ts
+++ b/packages/agent-core-v2/test/agent/usage/usage.test.ts
@@ -14,12 +14,13 @@ import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
 import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
 
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
+
 const SCOPE = 'wire';
 const KEY = 'usage-test';
 
@@ -33,18 +34,22 @@ beforeEach(() => {
   ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: KEY }]));
   ix.set(IEventBus, new SyncDescriptor(EventBusService));
   ix.set(IAgentUsageService, new SyncDescriptor(AgentUsageService));
   log = ix.get(IAppendLogStore);
+  registerTestAgentWire(ix, testWireScope(SCOPE, KEY), {
+    log,
+    eventBus: ix.get(IEventBus),
+  });
   svc = ix.get(IAgentUsageService);
 });
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, KEY)) {
+async function readRecords(): Promise<WireRecord[]> {
+  await ix.get(IWireService).flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, KEY), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -54,10 +59,13 @@ function createFreshWire(logKey: string): { readonly fresh: IWireService; readon
   const freshIx = disposables.add(new TestInstantiationService());
   freshIx.stub(IFileSystemStorageService, new InMemoryStorageService());
   freshIx.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  freshIx.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey }]));
+  const freshLog = freshIx.get(IAppendLogStore);
+  const fresh = registerTestAgentWire(freshIx, testWireScope(SCOPE, logKey), {
+    log: freshLog,
+  });
   return {
-    fresh: freshIx.get(IAgentWireService),
-    freshLog: freshIx.get(IAppendLogStore),
+    fresh,
+    freshLog,
   };
 }
 
@@ -192,30 +200,41 @@ describe('AgentUsageService (wire-backed)', () => {
 
     const { fresh, freshLog } = createFreshWire('usage-replay');
 
-    await fresh.replay(...records);
+    await restoreTestAgentWire(
+      fresh,
+      freshLog,
+      testWireScope(SCOPE, 'usage-replay'),
+      records,
+    );
 
     expect(fresh.getModel(UsageModel).byModel).toEqual({
       'model-a': { inputOther: 11, output: 22, inputCacheRead: 33, inputCacheCreation: 44 },
     });
 
-    const written: PersistedRecord[] = [];
-    for await (const record of freshLog.read<PersistedRecord>(SCOPE, 'usage-replay')) {
+    const written: WireRecord[] = [];
+    for await (const record of freshLog.read<WireRecord>(testWireScope(SCOPE, 'usage-replay'), AGENT_WIRE_RECORD_KEY)) {
       written.push(record);
     }
-    expect(written).toEqual([]);
+    expect(written[0]).toMatchObject({ type: 'metadata' });
+    expect(written.slice(1)).toEqual(records);
   });
 
   it('replays legacy turn context records into byModel totals only (currentTurn is not rebuilt)', async () => {
-    const { fresh } = createFreshWire('usage-legacy-context-replay');
+    const { fresh, freshLog } = createFreshWire('usage-legacy-context-replay');
 
-    await fresh.replay({
-      type: 'usage.record',
-      model: 'model-a',
-      usage: a1,
-      usageScope: 'turn',
-      turnId: 1,
-      context: { type: 'turn', turnId: 9, step: 3 },
-    });
+    await restoreTestAgentWire(
+      fresh,
+      freshLog,
+      testWireScope(SCOPE, 'usage-legacy-context-replay'),
+      [{
+        type: 'usage.record',
+        model: 'model-a',
+        usage: a1,
+        usageScope: 'turn',
+        turnId: 1,
+        context: { type: 'turn', turnId: 9, step: 3 },
+      }],
+    );
 
     expect(fresh.getModel(UsageModel)).toEqual({
       byModel: { 'model-a': a1 },
diff --git a/packages/agent-core-v2/test/agent/userTool/userTool.test.ts b/packages/agent-core-v2/test/agent/userTool/userTool.test.ts
index 0fe40248c..314c7b3b8 100644
--- a/packages/agent-core-v2/test/agent/userTool/userTool.test.ts
+++ b/packages/agent-core-v2/test/agent/userTool/userTool.test.ts
@@ -14,9 +14,10 @@ import { InMemoryStorageService } from '#/persistence/backends/memory/inMemorySt
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { ISessionInteractionService } from '#/session/interaction/interaction';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from '../../wire/stubs';
 
 const SCOPE = 'wire';
 const KEY = 'user-tool-test';
@@ -74,23 +75,23 @@ beforeEach(() => {
   ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: KEY }]));
   ix.set(IAgentToolRegistryService, new SyncDescriptor(AgentToolRegistryService));
   profile = createProfileStub();
   ix.stub(IAgentProfileService, profile);
   ix.stub(ISessionInteractionService, createInteractionStub());
   ix.set(IAgentUserToolService, new SyncDescriptor(AgentUserToolService));
   log = ix.get(IAppendLogStore);
-  wire = ix.get(IAgentWireService);
+  wire = registerTestAgentWire(ix, testWireScope(SCOPE, KEY), { log });
   registry = ix.get(IAgentToolRegistryService);
   svc = ix.get(IAgentUserToolService);
 });
 
 afterEach(() => disposables.dispose());
 
-async function readRecords(key = KEY): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, key)) {
+async function readRecords(key = KEY): Promise<WireRecord[]> {
+  await wire.flush();
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -138,18 +139,16 @@ describe('AgentUserToolService (wire-backed)', () => {
     const ixChild = disposables.add(new TestInstantiationService());
     ixChild.stub(IFileSystemStorageService, new InMemoryStorageService());
     ixChild.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ixChild.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: 'user-tool-child' }]),
-    );
     ixChild.set(IAgentToolRegistryService, new SyncDescriptor(AgentToolRegistryService));
     const childProfile = createProfileStub();
     ixChild.stub(IAgentProfileService, childProfile);
     ixChild.stub(ISessionInteractionService, createInteractionStub());
     ixChild.set(IAgentUserToolService, new SyncDescriptor(AgentUserToolService));
 
+    const childWire = registerTestAgentWire(ixChild, testWireScope(SCOPE, 'user-tool-child'), {
+      log: ixChild.get(IAppendLogStore),
+    });
     const child = ixChild.get(IAgentUserToolService);
-    const childWire = ixChild.get(IAgentWireService);
     const childRegistry = ixChild.get(IAgentToolRegistryService);
     child.inheritUserTools(svc);
 
@@ -160,10 +159,10 @@ describe('AgentUserToolService (wire-backed)', () => {
     expect(childProfile.active.has(toolA.name)).toBe(true);
     expect(childProfile.active.has(toolB.name)).toBe(false);
 
-    const childRecords: PersistedRecord[] = [];
+    const childRecords: WireRecord[] = [];
     for await (const record of ixChild
       .get(IAppendLogStore)
-      .read<PersistedRecord>(SCOPE, 'user-tool-child')) {
+      .read<WireRecord>(testWireScope(SCOPE, 'user-tool-child'), AGENT_WIRE_RECORD_KEY)) {
       childRecords.push(record);
     }
     expect(childRecords).toEqual([
@@ -178,7 +177,7 @@ describe('AgentUserToolService (wire-backed)', () => {
     expect(modelOf(wire)).toBe(before);
   });
 
-  it('replay rebuilds the model silently and onRestored re-registers tools after replay', async () => {
+  it('replay rebuilds the model silently and onDidRestore re-registers tools after replay', async () => {
     svc.register(toolA);
     svc.register(toolB);
     const records = await readRecords();
@@ -186,22 +185,25 @@ describe('AgentUserToolService (wire-backed)', () => {
     const ix2 = disposables.add(new TestInstantiationService());
     ix2.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix2.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix2.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: 'user-tool-replay' }]),
-    );
     ix2.set(IAgentToolRegistryService, new SyncDescriptor(AgentToolRegistryService));
     const profile2 = createProfileStub();
     ix2.stub(IAgentProfileService, profile2);
     ix2.stub(ISessionInteractionService, createInteractionStub());
     ix2.set(IAgentUserToolService, new SyncDescriptor(AgentUserToolService));
 
-    const wire2 = ix2.get(IAgentWireService);
+    const wire2 = registerTestAgentWire(ix2, testWireScope(SCOPE, 'user-tool-replay'), {
+      log: ix2.get(IAppendLogStore),
+    });
     const registry2 = ix2.get(IAgentToolRegistryService);
     ix2.get(IAgentUserToolService);
 
     expect(registry2.resolve(toolA.name)).toBeUndefined();
-    await wire2.replay(...records);
+    await restoreTestAgentWire(
+      wire2,
+      ix2.get(IAppendLogStore),
+      testWireScope(SCOPE, 'user-tool-replay'),
+      records,
+    );
 
     expect(modelOf(wire2).get(toolA.name)).toEqual(toolA);
     expect(modelOf(wire2).get(toolB.name)).toEqual(toolB);
@@ -210,12 +212,13 @@ describe('AgentUserToolService (wire-backed)', () => {
     expect(profile2.active.has(toolA.name)).toBe(true);
     expect(profile2.active.has(toolB.name)).toBe(true);
 
-    const written: PersistedRecord[] = [];
+    const written: WireRecord[] = [];
     for await (const record of ix2
       .get(IAppendLogStore)
-      .read<PersistedRecord>(SCOPE, 'user-tool-replay')) {
+      .read<WireRecord>(testWireScope(SCOPE, 'user-tool-replay'), AGENT_WIRE_RECORD_KEY)) {
       written.push(record);
     }
-    expect(written).toEqual([]);
+    expect(written[0]).toMatchObject({ type: 'metadata' });
+    expect(written.slice(1)).toEqual(records);
   });
 });
diff --git a/packages/agent-core-v2/test/app/config/config.test.ts b/packages/agent-core-v2/test/app/config/config.test.ts
index 56542c06a..38f6544e7 100644
--- a/packages/agent-core-v2/test/app/config/config.test.ts
+++ b/packages/agent-core-v2/test/app/config/config.test.ts
@@ -12,7 +12,7 @@ import type { ToolCall } from '#/app/llmProtocol/message';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { IAgentProfileService, type ResolvedAgentProfile } from '#/agent/profile/profile';
-import { AGENT_WIRE_PROTOCOL_VERSION } from '#/agent/wireRecord/wireRecord';
+import { WIRE_PROTOCOL_VERSION } from '#/wire/migration/migration';
 import { createTestAgent, type TestAgentContext } from '../../harness';
 import { DEFAULT_TEST_SYSTEM_PROMPT } from '../../harness/snapshots';
 
@@ -40,8 +40,15 @@ import {
 import {
   KEEP_ALIVE_ON_EXIT_ENV,
   resolveAgentTaskConfig,
+  resolvePrintBackgroundMode,
   type AgentTaskConfig,
 } from '#/agent/task/configSection';
+import '#/session/subagent/configSection';
+import {
+  DEFAULT_SUBAGENT_TIMEOUT_MS,
+  resolveSubagentTimeoutMs,
+  SUBAGENT_TIMEOUT_ENV,
+} from '#/session/subagent/configSection';
 import { ILogService } from '#/_base/log/log';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
@@ -180,7 +187,7 @@ describe('Agent config', () => {
     await ctx.restore([
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
       },
       {
@@ -242,22 +249,25 @@ describe('Agent config', () => {
     expect(await ctx.untilApproval(true)).toMatchInlineSnapshot(`
       [wire] turn.prompt                     { "input": [ { "type": "text", "text": "Look up before config changes" } ], "origin": { "kind": "user" }, "time": "<time>" }
       [emit] turn.started                    { "turnId": 0, "origin": { "kind": "user" } }
-      [wire] context.append_message          { "message": { "role": "user", "content": [ { "type": "text", "text": "Look up before config changes" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
-      [emit] agent.status.updated            { "contextTokens": 9, "rawContextTokens": 9 }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] context.spliced                 { "start": 0, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Look up before config changes" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" } ] }
+      [emit] agent.status.updated            { "contextTokens": 9, "rawContextTokens": 9 }
+      [wire] context.append_message          { "message": { "role": "user", "content": [ { "type": "text", "text": "Look up before config changes" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
       [emit] turn.step.started               { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event       { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
-      [emit] agent.status.updated            { "contextTokens": 9, "rawContextTokens": 12 }
       [wire] llm.tools_snapshot              { "hash": "3bfeb22e61431247933e79f6ab94e7ca14a127f899bc87e7bbd22594ba9cdb66", "tools": [ { "name": "Lookup", "description": "Look up a short test value.", "parameters": { "type": "object", "properties": { "query": { "type": "string" } }, "required": [ "query" ], "additionalProperties": false } } ], "time": "<time>" }
       [wire] llm.request                     { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999991, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "3bfeb22e61431247933e79f6ab94e7ca14a127f899bc87e7bbd22594ba9cdb66", "messageCount": 1, "turnStep": "0.1", "time": "<time>" }
       [emit] assistant.delta                 { "turnId": 0, "delta": "I will look it up." }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] tool.call.delta                 { "turnId": 0, "toolCallId": "call_lookup", "name": "Lookup", "argumentsPart": "{\\"query\\":\\"original\\"}" }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] usage.record                    { "model": "mock-model", "usage": { "inputOther": 9, "output": 22, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
       [emit] agent.status.updated            { "usage": { "byModel": { "mock-model": { "inputOther": 9, "output": 22, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 9, "output": 22, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 9, "output": 22, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] agent.status.updated            { "contextTokens": 31, "rawContextTokens": 34 }
       [wire] context.append_loop_event       { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "I will look it up." } }, "time": "<time>" }
-      [emit] agent.status.updated            { "contextTokens": 31, "rawContextTokens": 40 }
       [emit] permission.approval.requested   { "sessionId": "test-session", "agentId": "main", "turnId": 0, "toolCallId": "call_lookup", "toolName": "Lookup", "action": "Approve Lookup", "display": { "kind": "generic", "summary": "Approve Lookup", "detail": { "query": "original" } }, "toolInput": { "query": "original" } }
+      [emit] agent.activity.updated          { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [ { "approvalId": "call_lookup", "toolCallId": "call_lookup", "since": "<time>" } ], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] requestApproval                 { "turnId": 0, "toolCallId": "call_lookup", "toolName": "Lookup", "action": "Approve Lookup", "display": { "kind": "generic", "summary": "Approve Lookup", "detail": { "query": "original" } } }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -283,26 +293,26 @@ describe('Agent config', () => {
     ctx.mockNextResponse({ type: 'text', text: 'Still using the original turn config.' });
     await toolCallEvents;
     expect(await ctx.untilTurnEnd()).toMatchInlineSnapshot(`
+      [wire] context.append_loop_event   { "event": { "type": "tool.call", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "toolCallId": "call_lookup", "name": "Lookup", "args": { "query": "original" } }, "time": "<time>" }
       [emit] tool.result                 { "turnId": 0, "toolCallId": "call_lookup", "output": "original-result" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event   { "event": { "type": "tool.result", "parentUuid": "<uuid-3>", "toolCallId": "call_lookup", "result": { "output": "original-result" } }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 37, "rawContextTokens": 59 }
-      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 9, "output": 22, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 37, "rawContextTokens": 37 }
       [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 9, "output": 22, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "tool_use", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }
+      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 9, "output": 22, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
       [emit] turn.step.started           { "turnId": 0, "step": 2, "stepId": "<uuid-4>" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-4>", "turnId": "0", "step": 2 }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 40, "rawContextTokens": 43 }
       [wire] llm.tools_snapshot          { "hash": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", "tools": [], "time": "<time>" }
       [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999960, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "systemPrompt": "You are a deterministic test agent.", "toolsHash": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", "messageCount": 3, "turnStep": "0.2", "time": "<time>" }
       [emit] assistant.delta             { "turnId": 0, "delta": "Still using the original turn config." }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 37, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
       [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 46, "output": 35, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 46, "output": 35, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 46, "output": 35, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] agent.status.updated        { "contextTokens": 50, "rawContextTokens": 53 }
-      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "Still using the original turn config." } }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 50, "rawContextTokens": 63 }
-      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 37, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 50, "rawContextTokens": 50 }
       [emit] turn.step.completed         { "turnId": 0, "step": 2, "stepId": "<uuid-4>", "usage": { "inputOther": 37, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "Still using the original turn config." } }, "time": "<time>" }
+      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 37, "output": 13, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
       [emit] turn.ended                  { "turnId": 0, "reason": "completed" }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -317,25 +327,27 @@ describe('Agent config', () => {
     await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Start a fresh turn' }] });
 
     expect(await ctx.untilTurnEnd()).toMatchInlineSnapshot(`
+      [emit] agent.activity.updated      { "lifecycle": "ready", "lastTurn": { "turnId": 0, "reason": "completed", "at": "<time>" }, "background": [] }
       [emit] prompt.completed            { "promptId": "<msg-1>", "finishedAt": "<time>", "reason": "completed" }
       [wire] turn.prompt                 { "input": [ { "type": "text", "text": "Start a fresh turn" } ], "origin": { "kind": "user" }, "time": "<time>" }
       [emit] turn.started                { "turnId": 1, "origin": { "kind": "user" } }
-      [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Start a fresh turn" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-2>" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 56, "rawContextTokens": 56 }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [emit] context.spliced             { "start": 4, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Start a fresh turn" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-2>" } ] }
+      [emit] agent.status.updated        { "contextTokens": 56, "rawContextTokens": 56 }
+      [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Start a fresh turn" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-2>" }, "time": "<time>" }
       [emit] turn.step.started           { "turnId": 1, "step": 1, "stepId": "<uuid-6>" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-6>", "turnId": "1", "step": 1 }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 59, "rawContextTokens": 62 }
       [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "changed-model", "modelAlias": "changed-model", "thinkingEffort": "off", "maxTokens": 999941, "toolSelect": false, "systemPromptHash": "7617cb8b42659214c397a1d7505fce204b673b078a10de8bcccc697d88dcda56", "toolsHash": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", "messageCount": 5, "turnStep": "1.1", "time": "<time>" }
       [emit] assistant.delta             { "turnId": 1, "delta": "Now the changed config is active." }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] usage.record                { "model": "changed-model", "usage": { "inputOther": 56, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
       [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 46, "output": 35, "inputCacheRead": 0, "inputCacheCreation": 0 }, "changed-model": { "inputOther": 56, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 102, "output": 47, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 56, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] agent.status.updated        { "contextTokens": 68, "rawContextTokens": 71 }
-      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-7>", "turnId": "1", "step": 1, "stepUuid": "<uuid-6>", "part": { "type": "text", "text": "Now the changed config is active." } }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 68, "rawContextTokens": 80 }
-      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-6>", "turnId": "1", "step": 1, "finishReason": "end_turn", "usage": { "inputOther": 56, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-3", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-      [emit] agent.status.updated        { "contextTokens": 68, "rawContextTokens": 68 }
       [emit] turn.step.completed         { "turnId": 1, "step": 1, "stepId": "<uuid-6>", "usage": { "inputOther": 56, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+      [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+      [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-7>", "turnId": "1", "step": 1, "stepUuid": "<uuid-6>", "part": { "type": "text", "text": "Now the changed config is active." } }, "time": "<time>" }
+      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-6>", "turnId": "1", "step": 1, "finishReason": "end_turn", "usage": { "inputOther": 56, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-3", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
       [emit] turn.ended                  { "turnId": 1, "reason": "completed" }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -544,6 +556,121 @@ describe('task config section', () => {
 
     disposables.dispose();
   });
+
+  async function createTaskConfig(env: Record<string, string>, toml?: string) {
+    const disposables = new DisposableStore();
+    const ix = disposables.add(new TestInstantiationService());
+    const storage = new InMemoryStorageService();
+    if (toml !== undefined) {
+      await storage.write('', 'config.toml', new TextEncoder().encode(toml));
+    }
+    ix.stub(ILogService, stubLog());
+    ix.stub(IBootstrapService, stubBootstrap('/tmp/kimi-cfg', env));
+    ix.stub(IFileSystemStorageService, storage);
+    ix.set(IAtomicTomlDocumentStore, new SyncDescriptor(TomlAtomicDocumentStore));
+    ix.set(IConfigRegistry, new SyncDescriptor(ConfigRegistry));
+    ix.set(IConfigService, new SyncDescriptor(ConfigService));
+    const config = ix.get(IConfigService);
+    await config.ready;
+    return { config, disposables };
+  }
+
+  it('parses print policy fields and merges legacy background with task overrides', async () => {
+    const { config, disposables } = await createTaskConfig(
+      {},
+      '[background]\nprint_background_mode = "steer"\nprint_wait_ceiling_s = 60\n\n' +
+        '[task]\nprint_max_turns = 5\n',
+    );
+
+    expect(resolveAgentTaskConfig(config)).toEqual({
+      printBackgroundMode: 'steer',
+      printWaitCeilingS: 60,
+      printMaxTurns: 5,
+    });
+
+    disposables.dispose();
+  });
+
+  it('drops the task section with a warning when a print policy value is invalid', async () => {
+    const { config, disposables } = await createTaskConfig(
+      {},
+      '[task]\nprint_background_mode = "wait"\n',
+    );
+    expect(config.get<AgentTaskConfig>('task')?.printBackgroundMode).toBeUndefined();
+    expect(
+      config
+        .diagnostics()
+        .some((d) => d.message.includes("Ignored invalid config section 'task'")),
+    ).toBe(true);
+    disposables.dispose();
+  });
+
+  it('resolvePrintBackgroundMode prefers the explicit mode over keepAliveOnExit', async () => {
+    const { config, disposables } = await createTaskConfig(
+      {},
+      '[task]\nprint_background_mode = "exit"\nkeep_alive_on_exit = true\n',
+    );
+    expect(resolvePrintBackgroundMode(config)).toBe('exit');
+    disposables.dispose();
+  });
+
+  it('resolvePrintBackgroundMode falls back to keepAliveOnExit then exit', async () => {
+    const env: Record<string, string> = {};
+    const { config, disposables } = await createTaskConfig(env);
+
+    expect(resolvePrintBackgroundMode(config)).toBe('exit');
+
+    env[KEEP_ALIVE_ON_EXIT_ENV] = 'true';
+    expect(resolvePrintBackgroundMode(config)).toBe('drain');
+
+    disposables.dispose();
+  });
+});
+
+describe('subagent config section', () => {
+  async function createConfig(env: Record<string, string>, toml?: string) {
+    const disposables = new DisposableStore();
+    const ix = disposables.add(new TestInstantiationService());
+    const storage = new InMemoryStorageService();
+    if (toml !== undefined) {
+      await storage.write('', 'config.toml', new TextEncoder().encode(toml));
+    }
+    ix.stub(ILogService, stubLog());
+    ix.stub(IBootstrapService, stubBootstrap('/tmp/kimi-cfg', env));
+    ix.stub(IFileSystemStorageService, storage);
+    ix.set(IAtomicTomlDocumentStore, new SyncDescriptor(TomlAtomicDocumentStore));
+    ix.set(IConfigRegistry, new SyncDescriptor(ConfigRegistry));
+    ix.set(IConfigService, new SyncDescriptor(ConfigService));
+    const config = ix.get(IConfigService);
+    await config.ready;
+    return { config, disposables };
+  }
+
+  it('defaults to two hours and honours the env override', async () => {
+    const env: Record<string, string> = {};
+    const { config, disposables } = await createConfig(env);
+
+    expect(resolveSubagentTimeoutMs(config)).toBe(DEFAULT_SUBAGENT_TIMEOUT_MS);
+
+    env[SUBAGENT_TIMEOUT_ENV] = 'abc';
+    expect(resolveSubagentTimeoutMs(config)).toBe(DEFAULT_SUBAGENT_TIMEOUT_MS);
+
+    env[SUBAGENT_TIMEOUT_ENV] = '3000';
+    expect(resolveSubagentTimeoutMs(config)).toBe(3000);
+
+    disposables.dispose();
+  });
+
+  it('reads timeout_ms from config.toml and lets the env var win', async () => {
+    const env: Record<string, string> = {};
+    const { config, disposables } = await createConfig(env, '[subagent]\ntimeout_ms = 5000\n');
+    expect(resolveSubagentTimeoutMs(config)).toBe(5000);
+
+    env[SUBAGENT_TIMEOUT_ENV] = '7000';
+    expect(resolveSubagentTimeoutMs(config)).toBe(7000);
+
+    disposables.dispose();
+  });
 });
 
 function toolNames(value: unknown): string[] {
diff --git a/packages/agent-core-v2/test/app/externalHooksRunner/integration.test.ts b/packages/agent-core-v2/test/app/externalHooksRunner/integration.test.ts
index 5900a7abd..df54d14ec 100644
--- a/packages/agent-core-v2/test/app/externalHooksRunner/integration.test.ts
+++ b/packages/agent-core-v2/test/app/externalHooksRunner/integration.test.ts
@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import { describe, expect, it } from 'vitest';
 
 import { SyncDescriptor } from '#/_base/di/descriptors';
-import { DisposableStore } from '#/_base/di/lifecycle';
+import { Disposable, DisposableStore } from '#/_base/di/lifecycle';
 import type { ISessionScopeHandle } from '#/_base/di/scope';
 import {
   createServices,
@@ -58,11 +58,10 @@ import {
 } from '#/session/subagent/subagent';
 import { ISessionExternalHooksService } from '#/session/externalHooks/externalHooks';
 import { SessionExternalHooksService } from '#/session/externalHooks/externalHooksService';
-import { IAgentWireService } from '#/wire/tokens';
-import { WireService } from '#/wire/wireServiceImpl';
 
 import { stubBootstrap } from '../bootstrap/stubs';
 import { stubLoopWithHooks, stubToolExecutor } from '../../agent/loop/stubs';
+import { registerTestAgentWireServices } from '../../wire/stubs';
 
 function nodeCommand(source: string): string {
   return `node -e ${JSON.stringify(source.replaceAll(/\s*\n\s*/g, ' '))}`;
@@ -279,6 +278,7 @@ describe('IExternalHooksRunnerService integration', () => {
       ix = createServices(disposables, {
         strict: true,
         additionalServices: (reg) => {
+          registerTestAgentWireServices(reg, 'wire/external-hooks');
           reg.defineInstance(IBootstrapService, stubBootstrap());
           reg.defineInstance(ISessionContext, stubSessionContext());
           reg.definePartialInstance(IConfigService, {});
@@ -295,10 +295,6 @@ describe('IExternalHooksRunnerService integration', () => {
             hooks: createHooks(['onWillCompact']),
           });
           reg.definePartialInstance(IAgentTaskService, {});
-          reg.defineInstance(
-            IAgentWireService,
-            disposables.add(new WireService({ logScope: 'wire', logKey: 'external-hooks' })),
-          );
         },
       });
       ix.set(IExternalHooksRunnerService, stubHookRunner(hookEngine));
@@ -385,6 +381,7 @@ describe('IExternalHooksRunnerService integration', () => {
       ix = createServices(disposables, {
         strict: true,
         additionalServices: (reg) => {
+          registerTestAgentWireServices(reg, 'wire/external-hooks');
           reg.defineInstance(IBootstrapService, stubBootstrap());
           reg.defineInstance(ISessionContext, stubSessionContext());
           reg.definePartialInstance(IConfigService, {});
@@ -603,10 +600,6 @@ describe('IExternalHooksRunnerService integration', () => {
             hooks: createHooks(['onWillCompact']),
           });
           reg.definePartialInstance(IAgentTaskService, {});
-          reg.defineInstance(
-            IAgentWireService,
-            disposables.add(new WireService({ logScope: 'wire', logKey: 'external-hooks' })),
-          );
           reg.define(IHostProcessService, HostProcessService);
         },
       });
diff --git a/packages/agent-core-v2/test/app/gateway/gateway.test.ts b/packages/agent-core-v2/test/app/gateway/gateway.test.ts
index d97813295..532069915 100644
--- a/packages/agent-core-v2/test/app/gateway/gateway.test.ts
+++ b/packages/agent-core-v2/test/app/gateway/gateway.test.ts
@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { SyncDescriptor } from '#/_base/di/descriptors';
 import type { ServiceIdentifier, ServicesAccessor } from '#/_base/di/instantiation';
-import { DisposableStore } from '#/_base/di/lifecycle';
+import { Disposable, DisposableStore } from '#/_base/di/lifecycle';
 import { type IAgentScopeHandle, type ISessionScopeHandle, LifecycleScope } from '#/_base/di/scope';
 import { TestInstantiationService } from '#/_base/di/test';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
diff --git a/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-context-management.test.ts b/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-context-management.test.ts
index e75b7b0f2..95d352a5a 100644
--- a/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-context-management.test.ts
+++ b/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-context-management.test.ts
@@ -1,12 +1,18 @@
+/**
+ * Scenario: Anthropic context-management requests replay native and compatible-model history.
+ * Responsibilities: emit preserved-thinking controls and normalize required compatible history only.
+ * Wiring: real v2 Anthropic adapter with only the remote SDK client boundary replaced by mocks.
+ * Run: pnpm exec vitest run packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-context-management.test.ts
+ */
 import type { Message } from '#/app/llmProtocol/message';
 import { AnthropicChatProvider } from '#/app/llmProtocol/providers/anthropic';
 import { describe, expect, it, vi } from 'vitest';
 
 const HISTORY: Message[] = [{ role: 'user', content: [{ type: 'text', text: 'Hi' }], toolCalls: [] }];
 
-function createProvider(): AnthropicChatProvider {
+function createProvider(model = 'kimi-for-coding'): AnthropicChatProvider {
   return new AnthropicChatProvider({
-    model: 'kimi-for-coding',
+    model,
     apiKey: 'test-key',
     defaultMaxTokens: 1024,
     stream: false,
@@ -25,7 +31,10 @@ function makeAnthropicResponse() {
   };
 }
 
-async function captureBetaRequestBody(provider: AnthropicChatProvider): Promise<Record<string, unknown>> {
+async function captureBetaRequestBody(
+  provider: AnthropicChatProvider,
+  history: Message[] = HISTORY,
+): Promise<Record<string, unknown>> {
   let capturedParams: Record<string, unknown> | undefined;
   const standardCreate = vi.fn();
 
@@ -36,7 +45,7 @@ async function captureBetaRequestBody(provider: AnthropicChatProvider): Promise<
     });
   (provider as unknown as { _client: { messages: { create: unknown } } })._client.messages.create = standardCreate;
 
-  const stream = await provider.generate('', [], HISTORY);
+  const stream = await provider.generate('', [], history);
   for await (const part of stream) void part;
 
   if (capturedParams === undefined) {
@@ -87,4 +96,155 @@ describe('Anthropic withThinkingKeep context_management parity', () => {
       { type: 'clear_thinking_20251015', keep: 'all' },
     ]);
   });
+
+  it('replays compatible text history without injecting thinking with keep all', async () => {
+    const history: Message[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Hi' }], toolCalls: [] },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello' }],
+        toolCalls: [],
+      },
+      { role: 'user', content: [{ type: 'text', text: 'Continue' }], toolCalls: [] },
+    ];
+    const provider = createProvider('compatible-preserved-thinking-model')
+      .withThinking('max')
+      .withThinkingKeep('all');
+
+    const body = await captureBetaRequestBody(provider, history);
+    const messages = body['messages'] as Array<{ role: string; content: unknown[] }>;
+
+    expect(messages[1]).toEqual({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hello' }],
+    });
+  });
+
+  it('replays a compatible assistant tool call without injecting thinking with keep all', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [],
+        toolCalls: [
+          { type: 'function', id: 'call_1', name: 'lookup', arguments: '{"q":"test"}' },
+        ],
+      },
+    ];
+    const provider = createProvider('compatible-preserved-thinking-model')
+      .withThinking('max')
+      .withThinkingKeep('all');
+
+    const body = await captureBetaRequestBody(provider, history);
+    const messages = body['messages'] as Array<{ role: string; content: unknown[] }>;
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [
+        {
+          type: 'tool_use',
+          id: 'call_1',
+          name: 'lookup',
+          input: { q: 'test' },
+          cache_control: { type: 'ephemeral' },
+        },
+      ],
+    });
+  });
+
+  it('preserves an existing empty thinking block when compatible history uses keep all', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '' },
+          { type: 'text', text: 'Hello' },
+        ],
+        toolCalls: [],
+      },
+    ];
+    const provider = createProvider('compatible-preserved-thinking-model')
+      .withThinking('max')
+      .withThinkingKeep('all');
+
+    const body = await captureBetaRequestBody(provider, history);
+    const messages = body['messages'] as Array<{ role: string; content: unknown[] }>;
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [
+        { type: 'thinking', thinking: '' },
+        { type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } },
+      ],
+    });
+  });
+
+  it('leaves missing compatible thinking absent when keep all is not enabled', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello' }],
+        toolCalls: [],
+      },
+    ];
+    const provider = createProvider('compatible-preserved-thinking-model').withThinking('max');
+
+    let captured: Record<string, unknown> | undefined;
+    (provider as unknown as { _client: { messages: { create: unknown } } })._client.messages.create =
+      vi.fn().mockImplementation((params: unknown) => {
+        captured = params as Record<string, unknown>;
+        return Promise.resolve(makeAnthropicResponse());
+      });
+
+    const stream = await provider.generate('', [], history);
+    for await (const part of stream) void part;
+    const messages = captured?.['messages'] as Array<{ role: string; content: unknown[] }>;
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } }],
+    });
+  });
+
+  it('leaves missing compatible thinking absent when thinking is disabled', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello' }],
+        toolCalls: [],
+      },
+    ];
+    const provider = createProvider('compatible-preserved-thinking-model')
+      .withThinking('off')
+      .withThinkingKeep('all');
+
+    const body = await captureBetaRequestBody(provider, history);
+    const messages = body['messages'] as Array<{ role: string; content: unknown[] }>;
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } }],
+    });
+  });
+
+  it.each(['claude-opus-4-8', 'claude-opus-4-9', 'claude-mythos-preview'])(
+    'does not synthesize unsigned thinking for Claude model %s with keep all',
+    async (model) => {
+      const history: Message[] = [
+        {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Hello' }],
+          toolCalls: [],
+        },
+      ];
+      const provider = createProvider(model).withThinking('max').withThinkingKeep('all');
+
+      const body = await captureBetaRequestBody(provider, history);
+      const messages = body['messages'] as Array<{ role: string; content: unknown[] }>;
+
+      expect(messages[0]).toEqual({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } }],
+      });
+    },
+  );
 });
diff --git a/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-max-tokens.test.ts b/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-max-tokens.test.ts
index 1b01f46a3..ffde69f1c 100644
--- a/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-max-tokens.test.ts
+++ b/packages/agent-core-v2/test/app/llmProtocol/providers/anthropic-max-tokens.test.ts
@@ -1,3 +1,7 @@
+/**
+ * `llmProtocol` domain (L0) — verifies Anthropic request limits and thinking profiles.
+ */
+
 import { describe, expect, it, vi } from 'vitest';
 
 import type { Message } from '#/app/llmProtocol/message';
@@ -5,6 +9,7 @@ import {
   AnthropicChatProvider,
   resolveDefaultMaxTokens,
 } from '#/app/llmProtocol/providers/anthropic';
+import { matchKnownAnthropicModelProfile } from '#/app/llmProtocol/providers/anthropic-profile';
 
 const HISTORY: Message[] = [
   { role: 'user', content: [{ type: 'text', text: 'Hi' }], toolCalls: [] },
@@ -55,6 +60,33 @@ async function maxTokensFor(
   return (await captureRequestBody(provider))['max_tokens'] as number;
 }
 
+describe('Anthropic model profile matching', () => {
+  it.each([
+    ['claude-opus-4-5', 'budget', ['low', 'medium', 'high'], true, true],
+    ['anthropic.claude-opus-4-6-v1:0', 'adaptive', ['low', 'medium', 'high', 'max'], true, true],
+    ['claude-opus-4-7', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, true],
+    ['claude-sonnet-4-6', 'adaptive', ['low', 'medium', 'high', 'max'], true, true],
+    ['claude-sonnet-5', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, true],
+    ['claude-fable-5', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, false],
+    ['claude-mythos-5', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, false],
+    ['claude-mythos-preview', 'adaptive', ['low', 'medium', 'high', 'max'], true, false],
+  ] as const)(
+    'matches %s to the built-in official profile',
+    (model, mode, efforts, supportsEffortParam, canDisableThinking) => {
+      expect(matchKnownAnthropicModelProfile(model)).toEqual({
+        mode,
+        efforts,
+        supportsEffortParam,
+        canDisableThinking,
+      });
+    },
+  );
+
+  it('does not claim an official profile for an unrecognized compatible model', () => {
+    expect(matchKnownAnthropicModelProfile('Example Compatible Model')).toBeUndefined();
+  });
+});
+
 describe('resolveDefaultMaxTokens', () => {
   it('returns per-version Messages-API caps for known Claude 4 models', () => {
     expect(resolveDefaultMaxTokens('claude-fable-5')).toBe(128000);
@@ -62,20 +94,21 @@ describe('resolveDefaultMaxTokens', () => {
     expect(resolveDefaultMaxTokens('claude-opus-4-7')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-opus-4-6')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-opus-4-5-20251101')).toBe(64000);
-    expect(resolveDefaultMaxTokens('claude-sonnet-4-6')).toBe(64000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-5')).toBe(128000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-4-6')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-haiku-4-5')).toBe(64000);
   });
 
   it('matches dotted version separators', () => {
     expect(resolveDefaultMaxTokens('claude-opus-4.8')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-opus-4.7')).toBe(128000);
-    expect(resolveDefaultMaxTokens('claude-sonnet-4.6')).toBe(64000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-4.6')).toBe(128000);
   });
 
   it('falls back to the nearest lower catalogued minor for unknown minors', () => {
     expect(resolveDefaultMaxTokens('claude-opus-4-9')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-opus-4-10')).toBe(128000);
-    expect(resolveDefaultMaxTokens('claude-sonnet-4-9')).toBe(64000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-4-9')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-haiku-4-9')).toBe(64000);
     expect(resolveDefaultMaxTokens('claude-opus-4-3')).toBe(32000);
   });
@@ -85,9 +118,9 @@ describe('resolveDefaultMaxTokens', () => {
     expect(resolveDefaultMaxTokens('claude-opus-4-7', 999999)).toBe(128000);
   });
 
-  it('honors the override for unknown models and falls back to 32000', () => {
+  it('honors the override for unknown models and otherwise falls back to 128k', () => {
     expect(resolveDefaultMaxTokens('unknown-model', 12345)).toBe(12345);
-    expect(resolveDefaultMaxTokens('totally-unknown-model')).toBe(32000);
+    expect(resolveDefaultMaxTokens('totally-unknown-model')).toBe(128000);
   });
 });
 
@@ -95,13 +128,17 @@ describe('AnthropicChatProvider constructor max_tokens', () => {
   it('uses per-version Messages-API caps for known Claude models', async () => {
     expect(await maxTokensFor('claude-opus-4-8')).toBe(128000);
     expect(await maxTokensFor('claude-opus-4-7')).toBe(128000);
-    expect(await maxTokensFor('claude-sonnet-4-6')).toBe(64000);
+    expect(await maxTokensFor('claude-sonnet-4-6')).toBe(128000);
   });
 
   it('honors defaultMaxTokens for unknown models', async () => {
     expect(await maxTokensFor('unknown-model', { defaultMaxTokens: 4321 })).toBe(4321);
   });
 
+  it('uses the 128k fallback for unknown models without an override', async () => {
+    expect(await maxTokensFor('unknown-model')).toBe(128000);
+  });
+
   it('honors a lower defaultMaxTokens on known models', async () => {
     expect(await maxTokensFor('claude-opus-4-7', { defaultMaxTokens: 200 })).toBe(200);
   });
@@ -133,3 +170,139 @@ describe('AnthropicChatProvider constructor max_tokens', () => {
     expect(body['max_tokens']).toBe(128000);
   });
 });
+
+describe('AnthropicChatProvider thinking profiles', () => {
+  it('uses the latest Opus profile for an unrecognized model name', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'compatible-model',
+      apiKey: 'test-key',
+      stream: false,
+    }).withThinking('max');
+
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+    expect(body['output_config']).toEqual({ effort: 'max' });
+  });
+
+  it('lets declared supportEfforts override a legacy model-name profile', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'claude-opus-4-5',
+      apiKey: 'test-key',
+      stream: false,
+      supportEfforts: ['low', 'high', 'max'],
+    }).withThinking('max');
+
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+    expect(body['output_config']).toEqual({ effort: 'max' });
+  });
+
+  it('passes an effort outside declared supportEfforts through unchanged', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'compatible-model',
+      apiKey: 'test-key',
+      stream: false,
+      supportEfforts: ['low', 'high'],
+    }).withThinking('max');
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+    expect(body['output_config']).toEqual({ effort: 'max' });
+  });
+
+  it('keeps a concrete effort when adaptiveThinking is false', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'compatible-model',
+      apiKey: 'test-key',
+      stream: false,
+      adaptiveThinking: false,
+      supportEfforts: ['low', 'high', 'max'],
+    }).withThinking('max');
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'enabled' });
+    expect(body['output_config']).toEqual({ effort: 'max' });
+  });
+
+  it('adaptiveThinking=false omits the effort param for an unversioned model name', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'compatible-model',
+      apiKey: 'test-key',
+      stream: false,
+      adaptiveThinking: false,
+    }).withThinking('high');
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'enabled', budget_tokens: 32000 });
+    expect(body['output_config']).toBeUndefined();
+  });
+
+  it('infers the budget profile for a pre-4.6 Claude model', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'claude-opus-4-5',
+      apiKey: 'test-key',
+      stream: false,
+    }).withThinking('high');
+
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'enabled', budget_tokens: 32000 });
+    expect(body['output_config']).toEqual({ effort: 'high' });
+  });
+
+  it('passes max through without converting it for a pre-4.6 Claude model', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'claude-opus-4-5',
+      apiKey: 'test-key',
+      stream: false,
+    }).withThinking('max');
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'enabled' });
+    expect(body['output_config']).toEqual({ effort: 'max' });
+  });
+
+  it('passes xhigh through for 4.6 without affecting max', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'claude-sonnet-4-6',
+      apiKey: 'test-key',
+      stream: false,
+      adaptiveThinking: true,
+    });
+
+    const xhighBody = await captureRequestBody(provider.withThinking('xhigh'));
+    const body = await captureRequestBody(provider.withThinking('max'));
+    expect(xhighBody['output_config']).toEqual({ effort: 'xhigh' });
+    expect(body['output_config']).toEqual({ effort: 'max' });
+  });
+
+  it.each(['claude-fable-5', 'claude-mythos-5', 'claude-mythos-preview'])(
+    '%s: passes off through for the backend to validate',
+    async (model) => {
+      const provider = new AnthropicChatProvider({
+        model,
+        apiKey: 'test-key',
+        stream: false,
+      }).withThinking('off');
+      const body = await captureRequestBody(provider);
+
+      expect(body['thinking']).toEqual({ type: 'disabled' });
+      expect(body['output_config']).toBeUndefined();
+    },
+  );
+
+  it('represents boolean on with the legacy high token budget', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'claude-sonnet-4-5',
+      apiKey: 'test-key',
+      stream: false,
+    }).withThinking('on');
+
+    const body = await captureRequestBody(provider);
+
+    expect(body['thinking']).toEqual({ type: 'enabled', budget_tokens: 32000 });
+    expect(body['output_config']).toBeUndefined();
+  });
+});
diff --git a/packages/agent-core-v2/test/app/llmProtocol/providers/empty-thinking-roundtrip.test.ts b/packages/agent-core-v2/test/app/llmProtocol/providers/empty-thinking-roundtrip.test.ts
index 184934d80..fb91e0eaa 100644
--- a/packages/agent-core-v2/test/app/llmProtocol/providers/empty-thinking-roundtrip.test.ts
+++ b/packages/agent-core-v2/test/app/llmProtocol/providers/empty-thinking-roundtrip.test.ts
@@ -5,6 +5,7 @@
  * Run: pnpm exec vitest run packages/agent-core-v2/test/app/llmProtocol/providers/empty-thinking-roundtrip.test.ts
  */
 import type { Message, StreamedMessagePart } from '#/app/llmProtocol/message';
+import { generate } from '#/app/llmProtocol/generate';
 import { AnthropicChatProvider } from '#/app/llmProtocol/providers/anthropic';
 import {
   GoogleGenAIChatProvider,
@@ -28,6 +29,16 @@ const EMPTY_THINKING_TOOL_HISTORY: Message[] = [
   },
 ];
 
+const UNSIGNED_THINKING_ONLY_HISTORY: Message[] = [
+  { role: 'user', content: [{ type: 'text', text: 'Start' }], toolCalls: [] },
+  {
+    role: 'assistant',
+    content: [{ type: 'think', think: 'Partial reasoning' }],
+    toolCalls: [],
+  },
+  { role: 'user', content: [{ type: 'text', text: 'Continue' }], toolCalls: [] },
+];
+
 function chatCompletionResponse(message: Record<string, unknown>) {
   return {
     id: 'chatcmpl-test',
@@ -54,7 +65,14 @@ async function captureKimiMessages(
   let captured: Record<string, unknown> | undefined;
   const create = vi.fn().mockImplementation((params: unknown) => {
     captured = params as Record<string, unknown>;
-    return Promise.resolve(chatCompletionResponse({ role: 'assistant', content: 'done' }));
+    return {
+      withResponse: () =>
+        Promise.resolve({
+          data: chatCompletionResponse({ role: 'assistant', content: 'done' }),
+          response: new Response(null),
+          request_id: null,
+        }),
+    };
   });
   let provider = new KimiChatProvider({
     model: 'kimi-k2',
@@ -75,13 +93,71 @@ async function captureKimiMessages(
   return captured['messages'] as Array<Record<string, unknown>>;
 }
 
+async function captureAnthropicMessages(
+  model: string,
+  history: Message[],
+  configure?: (provider: AnthropicChatProvider) => AnthropicChatProvider,
+): Promise<Array<{ role: string; content: unknown[] }>> {
+  let captured: Record<string, unknown> | undefined;
+  const create = vi.fn().mockImplementation((params: unknown) => {
+    captured = params as Record<string, unknown>;
+    return Promise.resolve({
+      id: 'msg_test',
+      content: [{ type: 'text', text: 'done' }],
+      usage: { input_tokens: 1, output_tokens: 1 },
+    });
+  });
+  let provider = new AnthropicChatProvider({
+    model,
+    apiKey: '',
+    defaultMaxTokens: 1024,
+    stream: false,
+    clientFactory: () => ({
+      messages: { create },
+      beta: { messages: { create } },
+    }) as never,
+  });
+  if (configure !== undefined) {
+    provider = configure(provider);
+  }
+
+  const response = await provider.generate('', [], history);
+  await collectParts(response);
+
+  if (captured === undefined) {
+    throw new Error('Expected Anthropic provider to send a request.');
+  }
+  return captured['messages'] as Array<{ role: string; content: unknown[] }>;
+}
+
+function createStreamingAnthropicProvider(
+  events: readonly Record<string, unknown>[],
+) {
+  async function* responseStream() {
+    yield* events;
+  }
+  const create = vi.fn().mockResolvedValue(responseStream());
+  return new AnthropicChatProvider({
+    model: 'compatible-model',
+    apiKey: '',
+    defaultMaxTokens: 1024,
+    clientFactory: () => ({ messages: { create } }) as never,
+  });
+}
+
+async function collectAnthropicStreamParts(
+  events: readonly Record<string, unknown>[],
+): Promise<StreamedMessagePart[]> {
+  return collectParts(await createStreamingAnthropicProvider(events).generate('', [], []));
+}
+
 describe('empty thinking round-trip', () => {
   it('Kimi sends an explicitly empty ThinkPart back as reasoning_content', async () => {
     const messages = await captureKimiMessages(EMPTY_THINKING_TOOL_HISTORY);
     expect(messages[0]).toHaveProperty('reasoning_content', '');
   });
 
-  it('Kimi backfills an assistant tool-call message when preserved thinking is active', async () => {
+  it('Kimi sends empty reasoning_content for an assistant tool-call message when preserved thinking is active', async () => {
     const history: Message[] = [
       {
         role: 'assistant',
@@ -99,7 +175,7 @@ describe('empty thinking round-trip', () => {
     expect(messages[0]).toHaveProperty('reasoning_content', '');
   });
 
-  it('Kimi backfills a text assistant message when keep=all omits thinking.type', async () => {
+  it('Kimi sends empty reasoning_content for a text assistant message when keep=all omits thinking.type', async () => {
     const history: Message[] = [
       {
         role: 'assistant',
@@ -115,27 +191,33 @@ describe('empty thinking round-trip', () => {
     expect(messages[0]).toHaveProperty('reasoning_content', '');
   });
 
-  it.each([
-    ['empty', ''],
-    ['non-empty', 'reasoning text'],
-  ])(
-    'Kimi sends an existing %s ThinkPart verbatim when preserved thinking is active',
-    async (_kind, think) => {
-      const history: Message[] = [
-        {
-          role: 'assistant',
-          content: [{ type: 'think', think }],
-          toolCalls: [],
-        },
-      ];
+  it('Kimi replays an existing empty ThinkPart unchanged when preserved thinking is active', async () => {
+    const messages = await captureKimiMessages(EMPTY_THINKING_TOOL_HISTORY, (provider) =>
+      provider.withExtraBody({ thinking: { type: 'enabled', keep: 'all' } }),
+    );
 
-      const messages = await captureKimiMessages(history, (provider) =>
-        provider.withExtraBody({ thinking: { type: 'enabled', keep: 'all' } }),
-      );
+    expect(messages[0]).toHaveProperty('reasoning_content', '');
+  });
 
-      expect(messages[0]).toHaveProperty('reasoning_content', think);
-    },
-  );
+  it('Kimi sends existing non-empty thinking verbatim when preserved thinking is active', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '' },
+          { type: 'think', think: 'reasoning text' },
+          { type: 'think', think: '' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureKimiMessages(history, (provider) =>
+      provider.withExtraBody({ thinking: { type: 'enabled', keep: 'all' } }),
+    );
+
+    expect(messages[0]).toHaveProperty('reasoning_content', 'reasoning text');
+  });
 
   it.each([
     ['missing', undefined],
@@ -181,6 +263,14 @@ describe('empty thinking round-trip', () => {
     expect(messages[0]).not.toHaveProperty('reasoning_content');
   });
 
+  it('Kimi leaves explicit empty thinking unchanged when thinking is disabled', async () => {
+    const messages = await captureKimiMessages(EMPTY_THINKING_TOOL_HISTORY, (provider) =>
+      provider.withExtraBody({ thinking: { type: 'disabled', keep: 'all' } }),
+    );
+
+    expect(messages[0]).toHaveProperty('reasoning_content', '');
+  });
+
   it('Kimi does not backfill reasoning_content on non-assistant messages', async () => {
     const history: Message[] = [
       { role: 'system', content: [{ type: 'text', text: 'System.' }], toolCalls: [] },
@@ -203,13 +293,18 @@ describe('empty thinking round-trip', () => {
   });
 
   it('Kimi keeps an explicitly empty response reasoning_content as a ThinkPart', async () => {
-    const create = vi.fn().mockResolvedValue(
-      chatCompletionResponse({
-        role: 'assistant',
-        content: null,
-        reasoning_content: '',
-      }),
-    );
+    const create = vi.fn().mockImplementation(() => ({
+      withResponse: () =>
+        Promise.resolve({
+          data: chatCompletionResponse({
+            role: 'assistant',
+            content: null,
+            reasoning_content: '',
+          }),
+          response: new Response(null),
+          request_id: null,
+        }),
+    }));
     const provider = new KimiChatProvider({
       model: 'kimi-k2',
       apiKey: '',
@@ -317,30 +412,271 @@ describe('empty thinking round-trip', () => {
   });
 
   it('Anthropic-compatible providers send unsigned empty thinking blocks back', async () => {
-    let captured: Record<string, unknown> | undefined;
-    const create = vi.fn().mockImplementation((params: unknown) => {
-      captured = params as Record<string, unknown>;
-      return Promise.resolve({
-        id: 'msg_test',
-        content: [{ type: 'text', text: 'done' }],
-        usage: { input_tokens: 1, output_tokens: 1 },
-      });
-    });
-    const provider = new AnthropicChatProvider({
-      model: 'compatible-model',
-      apiKey: '',
-      defaultMaxTokens: 1024,
-      stream: false,
-      clientFactory: () => ({ messages: { create } }) as never,
-    });
-
-    const response = await provider.generate('', [], EMPTY_THINKING_TOOL_HISTORY);
-    await collectParts(response);
-
-    const messages = captured?.['messages'] as Array<{ content: unknown[] }>;
+    const messages = await captureAnthropicMessages(
+      'compatible-model',
+      EMPTY_THINKING_TOOL_HISTORY,
+    );
     expect(messages[0]!.content[0]).toEqual({ type: 'thinking', thinking: '' });
   });
 
+  it('Anthropic-compatible providers preserve an unsigned-only assistant message', async () => {
+    const messages = await captureAnthropicMessages(
+      'compatible-model',
+      UNSIGNED_THINKING_ONLY_HISTORY,
+    );
+
+    expect(messages[1]).toEqual({
+      role: 'assistant',
+      content: [{ type: 'thinking', thinking: 'Partial reasoning' }],
+    });
+  });
+
+  it('Anthropic-compatible providers preserve all empty unsigned thinking blocks unchanged', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '' },
+          { type: 'think', think: '' },
+          { type: 'text', text: 'Done.' },
+        ],
+        toolCalls: [],
+      },
+      {
+        role: 'user',
+        content: [{ type: 'text', text: 'Continue.' }],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      history,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: '' },
+      { type: 'thinking', thinking: '' },
+      { type: 'text', text: 'Done.' },
+    ]);
+  });
+
+  it('Anthropic-compatible providers preserve unsigned blocks when any thinking is non-empty', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: 'reasoning text' },
+          { type: 'think', think: '' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      history,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: 'reasoning text' },
+      { type: 'thinking', thinking: '' },
+    ]);
+  });
+
+  it('Anthropic-compatible providers preserve empty signed thinking byte-for-byte', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'think', think: '', encrypted: 'signed-thinking' }],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      history,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: '', signature: 'signed-thinking' },
+    ]);
+  });
+
+  it('Anthropic-compatible providers preserve an empty unsigned block after empty signed thinking', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '', encrypted: 'signed-thinking' },
+          { type: 'think', think: '' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      history,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: '', signature: 'signed-thinking' },
+      { type: 'thinking', thinking: '' },
+    ]);
+  });
+
+  it('Anthropic-compatible providers do not replace empty unsigned thinking after non-empty signed thinking', async () => {
+    const history: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: 'signed reasoning', encrypted: 'signed-thinking' },
+          { type: 'think', think: '' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      history,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      {
+        type: 'thinking',
+        thinking: 'signed reasoning',
+        signature: 'signed-thinking',
+      },
+      { type: 'thinking', thinking: '' },
+    ]);
+  });
+
+  it('Anthropic normalizes a thinking delta with no thinking field to an empty ThinkPart', async () => {
+    const parts = await collectAnthropicStreamParts([
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'thinking_delta' },
+      },
+    ]);
+
+    expect(parts).toEqual([{ type: 'think', think: '' }]);
+  });
+
+  it('Anthropic normalizes a thinking block start with no thinking field to an empty ThinkPart', async () => {
+    const parts = await collectAnthropicStreamParts([
+      {
+        type: 'content_block_start',
+        index: 0,
+        content_block: { type: 'thinking' },
+      },
+    ]);
+
+    expect(parts).toEqual([{ type: 'think', think: '' }]);
+  });
+
+  it('Anthropic omits a missing thinking delta from the reduced assistant history', async () => {
+    const result = await generate(
+      createStreamingAnthropicProvider([
+        {
+          type: 'content_block_start',
+          index: 0,
+          content_block: { type: 'thinking', thinking: 'Simple request.' },
+        },
+        {
+          type: 'content_block_delta',
+          index: 0,
+          delta: { type: 'thinking_delta' },
+        },
+        {
+          type: 'content_block_start',
+          index: 1,
+          content_block: { type: 'text', text: 'Done' },
+        },
+      ]),
+      '',
+      [],
+      [],
+    );
+
+    expect(result.message.content).toEqual([
+      { type: 'think', think: 'Simple request.' },
+      { type: 'text', text: 'Done' },
+    ]);
+  });
+
+  it('Anthropic preserves a complete thinking delta', async () => {
+    const parts = await collectAnthropicStreamParts([
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'thinking_delta', thinking: 'reasoning' },
+      },
+    ]);
+
+    expect(parts).toEqual([{ type: 'think', think: 'reasoning' }]);
+  });
+
+  it('Anthropic preserves the signature delta immediately following a thinking delta', async () => {
+    const parts = await collectAnthropicStreamParts([
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'thinking_delta', thinking: 'reasoning' },
+      },
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'signature_delta', signature: 'signature' },
+      },
+    ]);
+
+    expect(parts).toEqual([
+      { type: 'think', think: 'reasoning' },
+      { type: 'think', think: '', encrypted: 'signature' },
+    ]);
+  });
+
+  it.each(['claude-opus-4-9', 'opus-4-9', 'claude-mythos-preview'])(
+    'Claude model %s drops unsigned thinking blocks',
+    async (model) => {
+      const messages = await captureAnthropicMessages(model, EMPTY_THINKING_TOOL_HISTORY);
+      expect(messages[0]!.content).toEqual([
+        {
+          type: 'tool_use',
+          id: 'call_1',
+          name: 'lookup',
+          input: { q: 'test' },
+          cache_control: { type: 'ephemeral' },
+        },
+      ]);
+    },
+  );
+
+  it('Claude drops an unsigned-only assistant without leaving an empty wire message', async () => {
+    const messages = await captureAnthropicMessages(
+      'claude-opus-4-9',
+      UNSIGNED_THINKING_ONLY_HISTORY,
+    );
+
+    expect(messages).toEqual([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Start' },
+          { type: 'text', text: 'Continue', cache_control: { type: 'ephemeral' } },
+        ],
+      },
+    ]);
+  });
+
   it('OpenAI Responses sends an explicitly empty ThinkPart as a reasoning item', async () => {
     let captured: Record<string, unknown> | undefined;
     async function* responseStream() {
diff --git a/packages/agent-core-v2/test/app/llmProtocol/providers/openai-legacy.test.ts b/packages/agent-core-v2/test/app/llmProtocol/providers/openai-legacy.test.ts
new file mode 100644
index 000000000..e70b25174
--- /dev/null
+++ b/packages/agent-core-v2/test/app/llmProtocol/providers/openai-legacy.test.ts
@@ -0,0 +1,144 @@
+/**
+ * Scenario: OpenAI-compatible (chat completions) thinking effort encoding.
+ * Responsibilities: encode withThinking onto the wire, keep an explicit 'off'
+ * distinct from "never configured", and report the accurate effort.
+ * Wiring: real v2 OpenAILegacy adapter with only the remote SDK client boundary
+ * replaced by mocks.
+ * Run: pnpm exec vitest run packages/agent-core-v2/test/app/llmProtocol/providers/openai-legacy.test.ts
+ */
+import type { Message } from '#/app/llmProtocol/message';
+import { OpenAILegacyChatProvider } from '#/app/llmProtocol/providers/openai-legacy';
+import { describe, expect, it, vi } from 'vitest';
+
+const USER_TURN: Message = {
+  role: 'user',
+  content: [{ type: 'text', text: 'Think' }],
+  toolCalls: [],
+};
+
+const THINK_HISTORY: Message[] = [
+  { role: 'user', content: [{ type: 'text', text: 'Hello' }], toolCalls: [] },
+  {
+    role: 'assistant',
+    content: [
+      { type: 'think', think: 'Thinking...' },
+      { type: 'text', text: 'Hi!' },
+    ],
+    toolCalls: [],
+  },
+  { role: 'user', content: [{ type: 'text', text: 'How are you?' }], toolCalls: [] },
+];
+
+function createProvider(model = 'gpt-4.1'): OpenAILegacyChatProvider {
+  return new OpenAILegacyChatProvider({
+    model,
+    apiKey: 'test-key',
+    stream: false,
+  });
+}
+
+function makeChatCompletionResponse(model = 'test-model') {
+  return {
+    id: 'chatcmpl-test123',
+    object: 'chat.completion',
+    created: 1234567890,
+    model,
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant', content: 'Hello' },
+        finish_reason: 'stop',
+      },
+    ],
+    usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+  };
+}
+
+async function captureRequestBody(
+  provider: OpenAILegacyChatProvider,
+  history: Message[],
+): Promise<Record<string, unknown>> {
+  let capturedBody: Record<string, unknown> | undefined;
+  (
+    provider as unknown as { _client: { chat: { completions: { create: unknown } } } }
+  )._client.chat.completions.create = vi.fn().mockImplementation((params: unknown) => {
+    capturedBody = params as Record<string, unknown>;
+    return Promise.resolve(makeChatCompletionResponse());
+  });
+
+  const stream = await provider.generate('', [], history);
+  for await (const part of stream) void part;
+
+  if (capturedBody === undefined) {
+    throw new Error('Expected provider.generate() to call chat.completions.create');
+  }
+  return capturedBody;
+}
+
+describe('OpenAILegacyChatProvider withThinking', () => {
+  it('passes a concrete effort through verbatim and reports it', async () => {
+    const provider = createProvider().withThinking('high');
+
+    const body = await captureRequestBody(provider, [USER_TURN]);
+    expect(body['reasoning_effort']).toBe('high');
+    expect(provider.thinkingEffort).toBe('high');
+  });
+
+  it('reports a null thinkingEffort until withThinking is called', () => {
+    expect(createProvider().thinkingEffort).toBeNull();
+  });
+
+  it('sends no reasoning_effort for "on" without ThinkPart history and reports "on"', async () => {
+    const provider = createProvider().withThinking('on');
+
+    const body = await captureRequestBody(provider, [USER_TURN]);
+    expect(body['reasoning_effort']).toBeUndefined();
+    expect(provider.thinkingEffort).toBe('on');
+  });
+
+  it('sends no reasoning_effort for "off" and reports "off"', async () => {
+    const provider = createProvider().withThinking('off');
+
+    const body = await captureRequestBody(provider, [USER_TURN]);
+    expect(body['reasoning_effort']).toBeUndefined();
+    expect(provider.thinkingEffort).toBe('off');
+  });
+
+  it('clears a concrete effort set earlier when turned off', async () => {
+    const provider = createProvider().withThinking('high').withThinking('off');
+    expect(provider.thinkingEffort).toBe('off');
+
+    const body = await captureRequestBody(provider, [USER_TURN]);
+    expect(body['reasoning_effort']).toBeUndefined();
+  });
+
+  it('auto-injects reasoning_effort when ThinkPart history exists and thinking is unconfigured', async () => {
+    // Issue #1616: strict OpenAI-compatible gateways require a paired
+    // reasoning_effort when the history carries reasoning_content.
+    const body = await captureRequestBody(createProvider(), THINK_HISTORY);
+    expect(body['reasoning_effort']).toBe('medium');
+  });
+
+  it('still auto-injects reasoning_effort for an explicit "on"', async () => {
+    const body = await captureRequestBody(createProvider().withThinking('on'), THINK_HISTORY);
+    expect(body['reasoning_effort']).toBe('medium');
+  });
+
+  it('does not auto-inject reasoning_effort when thinking was explicitly turned off', async () => {
+    // An explicit withThinking('off') is not "never configured": with thinking
+    // off, the auto-enable must not switch reasoning back on (or leak the field
+    // to models that reject it).
+    const provider = createProvider().withThinking('off');
+
+    const body = await captureRequestBody(provider, THINK_HISTORY);
+    expect(body['reasoning_effort']).toBeUndefined();
+    expect(provider.thinkingEffort).toBe('off');
+  });
+
+  it('does not overwrite reasoning_effort pinned via withGenerationKwargs', async () => {
+    const provider = createProvider().withGenerationKwargs({ reasoning_effort: 'high' });
+
+    const body = await captureRequestBody(provider, THINK_HISTORY);
+    expect(body['reasoning_effort']).toBe('high');
+  });
+});
diff --git a/packages/agent-core-v2/test/app/llmProtocol/providers/provider-errors.test.ts b/packages/agent-core-v2/test/app/llmProtocol/providers/provider-errors.test.ts
index f1d4bc7b0..6615783cf 100644
--- a/packages/agent-core-v2/test/app/llmProtocol/providers/provider-errors.test.ts
+++ b/packages/agent-core-v2/test/app/llmProtocol/providers/provider-errors.test.ts
@@ -7,7 +7,7 @@ import { APIError as AnthropicAPIError } from '@anthropic-ai/sdk';
 import { APIError as OpenAIAPIError } from 'openai';
 import { describe, expect, it } from 'vitest';
 
-import { APIProviderRateLimitError } from '#/app/llmProtocol/errors';
+import { APIProviderRateLimitError, APIStatusError } from '#/app/llmProtocol/errors';
 import { convertAnthropicError } from '#/app/llmProtocol/providers/anthropic';
 import { convertOpenAIError } from '#/app/llmProtocol/providers/openai-common';
 import { OpenAIResponsesStreamedMessage } from '#/app/llmProtocol/providers/openai-responses';
@@ -37,6 +37,29 @@ describe('provider retry-after conversion', () => {
     expect((error as APIProviderRateLimitError).retryAfterMs).toBe(12_000);
   });
 
+  it('preserves the x-trace-id header on a status error', () => {
+    const source = new OpenAIAPIError(
+      500,
+      undefined,
+      'Internal server error',
+      new Headers({ 'x-trace-id': 'trace-err-1' }),
+    );
+
+    const error = convertOpenAIError(source);
+
+    expect(error).toBeInstanceOf(APIStatusError);
+    expect((error as APIStatusError).traceId).toBe('trace-err-1');
+  });
+
+  it('leaves the trace id null when the error response has no x-trace-id header', () => {
+    const source = new OpenAIAPIError(500, undefined, 'Internal server error', new Headers());
+
+    const error = convertOpenAIError(source);
+
+    expect(error).toBeInstanceOf(APIStatusError);
+    expect((error as APIStatusError).traceId).toBeNull();
+  });
+
   it('preserves Anthropic retry-after seconds on a rate-limit error', () => {
     const source = AnthropicAPIError.generate(
       429,
diff --git a/packages/agent-core-v2/test/app/llmProtocol/select-tools.test.ts b/packages/agent-core-v2/test/app/llmProtocol/select-tools.test.ts
index a0d55ac5f..d38fe0c05 100644
--- a/packages/agent-core-v2/test/app/llmProtocol/select-tools.test.ts
+++ b/packages/agent-core-v2/test/app/llmProtocol/select-tools.test.ts
@@ -7,7 +7,7 @@
  *     normalization and the `$` builtin branch shared with top-level tools);
  *   - `Tool.deferred` stripping in `generate()` (single strip point for every
  *     provider call — the marker itself must never reach the wire);
- *   - the `select_tools` capability bit (unknown/default-off semantics).
+ *   - the `dynamically_loaded_tools` capability bit (unknown/default-off semantics).
  */
 
 import { UNKNOWN_CAPABILITY, isUnknownCapability } from '#/app/llmProtocol/capability';
@@ -74,7 +74,14 @@ async function captureRequestBody(
     .fn()
     .mockImplementation((params: unknown) => {
       capturedBody = params as Record<string, unknown>;
-      return Promise.resolve(makeChatCompletionResponse());
+      return {
+        withResponse: () =>
+          Promise.resolve({
+            data: makeChatCompletionResponse(),
+            response: new Response(null),
+            request_id: null,
+          }),
+      };
     });
   const stream = await provider.generate('system prompt', tools, history);
   for await (const part of stream) {
@@ -160,6 +167,60 @@ describe('Kimi messages[].tools serialization', () => {
   });
 });
 
+describe('Kimi x-trace-id capture', () => {
+  function mockKimiCreate(headers: Record<string, string>) {
+    const provider = new KimiChatProvider({
+      model: 'kimi-test',
+      apiKey: 'test-key',
+      stream: false,
+    });
+    (provider as any)._client.chat.completions.create = vi.fn().mockImplementation(() => ({
+      withResponse: () =>
+        Promise.resolve({
+          data: makeChatCompletionResponse(),
+          response: new Response(null, { headers }),
+          request_id: null,
+        }),
+    }));
+    return provider;
+  }
+
+  it('reads the trace id from the x-trace-id response header', async () => {
+    const stream = await mockKimiCreate({ 'x-trace-id': 'trace-abc-123' }).generate(
+      'system prompt',
+      [],
+      [{ role: 'user', content: [{ type: 'text', text: 'hi' }], toolCalls: [] }],
+    );
+    expect(stream.traceId).toBe('trace-abc-123');
+    for await (const part of stream) void part;
+  });
+
+  it('returns null when the response has no x-trace-id header', async () => {
+    const stream = await mockKimiCreate({}).generate(
+      'system prompt',
+      [],
+      [{ role: 'user', content: [{ type: 'text', text: 'hi' }], toolCalls: [] }],
+    );
+    expect(stream.traceId).toBeNull();
+    for await (const part of stream) void part;
+  });
+
+  it('surfaces the trace id through generate() via onTraceId and the result', async () => {
+    const provider = mockKimiCreate({ 'x-trace-id': 'trace-xyz' });
+    let captured: string | null | undefined;
+    const result = await generate(
+      provider,
+      'system prompt',
+      [],
+      [{ role: 'user', content: [{ type: 'text', text: 'hi' }], toolCalls: [] }],
+      undefined,
+      { onTraceId: (traceId) => (captured = traceId) },
+    );
+    expect(captured).toBe('trace-xyz');
+    expect(result.traceId).toBe('trace-xyz');
+  });
+});
+
 describe('generate() deferred tool stripping', () => {
   function createCapturingProvider(): { provider: ChatProvider; seenTools: () => Tool[] } {
     let captured: Tool[] = [];
@@ -195,6 +256,16 @@ describe('generate() deferred tool stripping', () => {
     expect(seenTools()).toEqual([ADD_TOOL]);
   });
 
+  it('omits trace metadata when the provider does not expose it', async () => {
+    const { provider } = createCapturingProvider();
+    const onTraceId = vi.fn();
+
+    const result = await generate(provider, 'sys', [], [], undefined, { onTraceId });
+
+    expect(onTraceId).not.toHaveBeenCalled();
+    expect(Object.hasOwn(result, 'traceId')).toBe(false);
+  });
+
   it('passes the identical array through when nothing is deferred', async () => {
     const { provider, seenTools } = createCapturingProvider();
     const tools = [ADD_TOOL, BUILTIN_TOOL];
@@ -318,12 +389,12 @@ describe('providers without message-level tool declarations', () => {
   });
 });
 
-describe('select_tools capability bit', () => {
+describe('dynamically_loaded_tools capability bit', () => {
   it('defaults to false on UNKNOWN_CAPABILITY', () => {
-    expect(UNKNOWN_CAPABILITY.select_tools).toBe(false);
+    expect(UNKNOWN_CAPABILITY.dynamically_loaded_tools).toBe(false);
   });
 
-  it('a capability that only has select_tools is not "unknown"', () => {
+  it('a capability that only has dynamically_loaded_tools is not "unknown"', () => {
     expect(
       isUnknownCapability({
         image_in: false,
@@ -332,16 +403,17 @@ describe('select_tools capability bit', () => {
         thinking: false,
         tool_use: false,
         max_context_tokens: 0,
-        select_tools: true,
+        dynamically_loaded_tools: true,
       }),
     ).toBe(false);
   });
 
-  it('catalog entries map select_tools and default it to false', () => {
+  it('catalog entries map dynamically_loaded_tools and default it to false', () => {
     const base = { id: 'm', limit: { context: 1000 } };
-    expect(catalogModelToCapability(base)?.capability.select_tools).toBe(false);
+    expect(catalogModelToCapability(base)?.capability.dynamically_loaded_tools).toBe(false);
     expect(
-      catalogModelToCapability({ ...base, select_tools: true })?.capability.select_tools,
+      catalogModelToCapability({ ...base, dynamically_loaded_tools: true })?.capability
+        .dynamically_loaded_tools,
     ).toBe(true);
   });
 });
diff --git a/packages/agent-core-v2/test/app/llmProtocol/structured-output.test.ts b/packages/agent-core-v2/test/app/llmProtocol/structured-output.test.ts
index 0d9d96b8a..0c6ed0831 100644
--- a/packages/agent-core-v2/test/app/llmProtocol/structured-output.test.ts
+++ b/packages/agent-core-v2/test/app/llmProtocol/structured-output.test.ts
@@ -101,7 +101,14 @@ async function captureKimiBody(options?: GenerateOptions): Promise<Record<string
   let captured: Record<string, unknown> | undefined;
   (Reflect.get(provider, '_client') as { chat: { completions: { create: unknown } } }).chat.completions.create = vi.fn().mockImplementation((params: unknown) => {
     captured = params as Record<string, unknown>;
-    return Promise.resolve(chatCompletionResponse('kimi-k2'));
+    return {
+      withResponse: () =>
+        Promise.resolve({
+          data: chatCompletionResponse('kimi-k2'),
+          response: new Response(null),
+          request_id: null,
+        }),
+    };
   });
 
   const stream = await provider.generate('', [], HISTORY, options);
diff --git a/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts b/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts
index 1ce8dd756..b7b576cdc 100644
--- a/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts
+++ b/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts
@@ -1,11 +1,14 @@
 import { describe, expect, it } from 'vitest';
 
+import { toDisposable } from '#/_base/di/lifecycle';
 import { type IAgentScopeHandle, type ISessionScopeHandle, LifecycleScope } from '#/_base/di/scope';
 import { IAgentBlobService } from '#/agent/blob/agentBlobService';
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
 import type { ContextMessage } from '#/agent/contextMemory/types';
+import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import type { ContentPart } from '#/app/llmProtocol/message';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { type IAppendLogStore } from '#/persistence/interface/appendLogStore';
+import { IWireService } from '#/wire/wire';
 import { ISessionIndex, type SessionSummary } from '#/app/sessionIndex/sessionIndex';
 import { ISessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycle';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
@@ -29,8 +32,11 @@ function buildService(opts: {
     kind: LifecycleScope.Agent,
     accessor: {
       get: (token: unknown): unknown => {
-        if (token === IAgentWireRecordService) {
-          return { getRecords: () => opts.records };
+        if (token === IWireService) {
+          return { flush: async () => {} };
+        }
+        if (token === IAgentScopeContext) {
+          return { scope: () => 'sessions/wd/s1/agents/main' };
         }
         if (token === IAgentContextMemoryService) {
           return { get: () => opts.contextMessages };
@@ -75,7 +81,19 @@ function buildService(opts: {
     get: (sessionId: string) => Promise.resolve(sessionId === opts.summary.id ? opts.summary : undefined),
   } as unknown as ISessionIndex;
 
-  return new MessageLegacyService(lifecycle, index);
+  const appendLog: IAppendLogStore = {
+    _serviceBrand: undefined,
+    append: () => {},
+    read: async function* <R>() {
+      for (const record of opts.records) yield record as R;
+    },
+    rewrite: async () => {},
+    flush: async () => {},
+    close: async () => {},
+    acquire: () => toDisposable(() => {}),
+  };
+
+  return new MessageLegacyService(lifecycle, index, appendLog);
 }
 
 describe('MessageLegacyService', () => {
@@ -87,7 +105,7 @@ describe('MessageLegacyService', () => {
     archived: false,
   };
 
-  it('reduces the transcript from the in-memory record journal (no disk read)', async () => {
+  it('reduces the transcript from the streamed append log', async () => {
     const user = textMessage('user', 'hi');
     const assistant = textMessage('assistant', 'hello');
     const svc = buildService({
diff --git a/packages/agent-core-v2/test/app/model/model.test.ts b/packages/agent-core-v2/test/app/model/model.test.ts
index 858b73ab2..b6c2f5077 100644
--- a/packages/agent-core-v2/test/app/model/model.test.ts
+++ b/packages/agent-core-v2/test/app/model/model.test.ts
@@ -20,6 +20,111 @@ import {
 import { modelsFromToml, modelsToToml } from '#/app/model/configSection';
 import { ModelService } from '#/app/model/modelService';
 import { ENV_MODEL_PROVIDER_KEY } from '#/app/provider/provider';
+import { effectiveModelConfig } from '#/app/model/modelAuth';
+import type { ModelConfig } from '#/app/model/model';
+
+describe('effectiveModelConfig', () => {
+  it('derives the official effort metadata from a Claude model name', () => {
+    expect(
+      effectiveModelConfig({
+        provider: 'anthropic',
+        model: 'claude-opus-4-6',
+        maxContextSize: 200000,
+      }),
+    ).toMatchObject({
+      capabilities: ['thinking'],
+      supportEfforts: ['low', 'medium', 'high', 'max'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('infers Anthropic effort metadata for an unknown model on a non-Kimi Anthropic provider', () => {
+    expect(
+      effectiveModelConfig(
+        {
+          provider: 'custom',
+          model: 'custom-anthropic-model',
+          maxContextSize: 200000,
+          protocol: 'anthropic',
+        },
+        'anthropic',
+      ),
+    ).toMatchObject({
+      capabilities: ['thinking'],
+      supportEfforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('does not infer Anthropic effort metadata for a Kimi provider routed through the Anthropic protocol', () => {
+    const model: ModelConfig = {
+      provider: 'managed:kimi-code',
+      model: 'kimi-for-coding',
+      maxContextSize: 262144,
+      capabilities: ['thinking', 'always_thinking'],
+      protocol: 'anthropic',
+      adaptiveThinking: true,
+    };
+
+    expect(effectiveModelConfig(model, 'kimi')).toEqual(model);
+  });
+
+  it('does not infer the fallback profile without provider context', () => {
+    const model: ModelConfig = {
+      provider: 'custom',
+      model: 'custom-anthropic-model',
+      maxContextSize: 200000,
+      protocol: 'anthropic',
+    };
+
+    expect(effectiveModelConfig(model)).toEqual(model);
+  });
+
+  it('limits an adaptive_thinking=false model to budget efforts', () => {
+    expect(
+      effectiveModelConfig(
+        {
+          provider: 'custom',
+          model: 'custom-anthropic-model',
+          maxContextSize: 200000,
+          protocol: 'anthropic',
+          adaptiveThinking: false,
+        },
+        'anthropic',
+      ),
+    ).toMatchObject({
+      capabilities: ['thinking'],
+      supportEfforts: ['low', 'medium', 'high'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('does not infer Anthropic effort metadata for an unknown model without an Anthropic protocol', () => {
+    const model = {
+      provider: 'custom',
+      model: 'custom-anthropic-model',
+      maxContextSize: 200000,
+    };
+
+    expect(effectiveModelConfig(model)).toEqual(model);
+  });
+
+  it('marks official always-on models while preserving explicit effort metadata', () => {
+    expect(
+      effectiveModelConfig({
+        provider: 'anthropic',
+        model: 'claude-fable-5',
+        maxContextSize: 200000,
+        supportEfforts: ['high', 'max'],
+        defaultEffort: 'max',
+      }),
+    ).toMatchObject({
+      capabilities: ['always_thinking'],
+      supportEfforts: ['high', 'max'],
+      defaultEffort: 'max',
+    });
+  });
+});
 
 describe('ModelService', () => {
   let disposables: DisposableStore;
diff --git a/packages/agent-core-v2/test/app/model/modelResolver.test.ts b/packages/agent-core-v2/test/app/model/modelResolver.test.ts
index f1101da0b..790f715c3 100644
--- a/packages/agent-core-v2/test/app/model/modelResolver.test.ts
+++ b/packages/agent-core-v2/test/app/model/modelResolver.test.ts
@@ -148,16 +148,16 @@ describe('ModelResolverService', () => {
     expect(auth).toEqual({ apiKey: 'sk-model' });
   });
 
-  it('forwards declared select_tools capability to the resolved model', () => {
+  it('forwards declared dynamically_loaded_tools capability to the resolved model', () => {
     providers['p'] = { type: 'kimi', baseUrl: 'https://example.test/v1', apiKey: 'sk-test' };
     models['m'] = {
       provider: 'p',
       model: 'wire-name',
       maxContextSize: 1000,
-      capabilities: ['select_tools'],
+      capabilities: ['dynamically_loaded_tools'],
     };
 
-    expect(ix.get(IModelResolver).resolve('m').capabilities.select_tools).toBe(true);
+    expect(ix.get(IModelResolver).resolve('m').capabilities.dynamically_loaded_tools).toBe(true);
   });
 
   it('returns an OAuth access token as ProviderRequestAuth.apiKey', async () => {
@@ -619,11 +619,11 @@ describe('ModelResolverService', () => {
       expect(model.supportEfforts).toEqual(['low', 'high']);
     });
 
-    it('does not pass supportEfforts through for non-Kimi providers', async () => {
+    it('passes Anthropic supportEfforts through to the protocol adapter', async () => {
       providers['p'] = { type: 'anthropic', baseUrl: 'https://example.test', apiKey: 'sk' };
       models['m'] = {
         provider: 'p',
-        model: 'kimi-for-coding',
+        model: 'compatible-model',
         maxContextSize: 1000,
         supportEfforts: ['low', 'high', 'max'],
       };
@@ -632,11 +632,8 @@ describe('ModelResolverService', () => {
 
       expect(config).toMatchObject({
         protocol: 'anthropic',
+        providerOptions: { supportEfforts: ['low', 'high', 'max'] },
       });
-      const providerOptions = config?.['providerOptions'] as
-        | { readonly supportEfforts?: readonly string[] }
-        | undefined;
-      expect(providerOptions?.supportEfforts).toBeUndefined();
     });
 
     it('marks the Anthropic adapter when it transports a Kimi provider', async () => {
@@ -657,6 +654,35 @@ describe('ModelResolverService', () => {
       });
     });
 
+    it('does not infer fallback effort metadata for an unknown Kimi-managed Anthropic model', () => {
+      providers['p'] = { type: 'kimi', baseUrl: 'https://example.test', apiKey: 'sk' };
+      models['m'] = {
+        provider: 'p',
+        protocol: 'anthropic',
+        model: 'compatible-model',
+        maxContextSize: 1000,
+      };
+
+      const model = ix.get(IModelResolver).resolve('m');
+
+      expect(model.supportEfforts).toBeUndefined();
+      expect(model.defaultEffort).toBeUndefined();
+    });
+
+    it('infers latest Opus metadata for a flat providerless Anthropic model', () => {
+      models['m'] = {
+        model: 'compatible-model',
+        baseUrl: 'https://anthropic.example.test',
+        protocol: 'anthropic',
+        maxContextSize: 1000,
+      };
+
+      const model = ix.get(IModelResolver).resolve('m');
+
+      expect(model.supportEfforts).toEqual(['low', 'medium', 'high', 'xhigh', 'max']);
+      expect(model.defaultEffort).toBe('high');
+    });
+
     it('passes Vertex service-account options and derives location from the baseUrl', async () => {
       providers['p'] = {
         type: 'vertexai',
@@ -727,7 +753,7 @@ describe('ModelResolverService', () => {
         thinking: true,
         tool_use: false,
         max_context_tokens: 1000,
-        select_tools: false,
+        dynamically_loaded_tools: false,
       });
     });
 
@@ -742,7 +768,7 @@ describe('ModelResolverService', () => {
         thinking: false,
         tool_use: true,
         max_context_tokens: 128000,
-        select_tools: false,
+        dynamically_loaded_tools: false,
       });
     });
   });
@@ -803,6 +829,25 @@ describe('ModelResolverService', () => {
       expect(resolveEffort()).toBeNull();
     });
 
+    it('applies explicit off to Anthropic providers like v1', async () => {
+      configValues['thinking'] = { enabled: false };
+      providers['p'] = { type: 'anthropic', baseUrl: 'https://example.test', apiKey: 'sk' };
+      models['m'] = {
+        provider: 'p',
+        model: 'compatible-model',
+        maxContextSize: 1000,
+        capabilities: ['thinking'],
+      };
+
+      const model = ix.get(IModelResolver).resolve('m');
+      for await (const _event of model.request({ systemPrompt: '', tools: [], messages: [] })) {
+        void _event;
+      }
+
+      expect(model.thinkingEffort).toBe('off');
+      expect(appliedThinkingEfforts).toEqual(['off']);
+    });
+
     it('uses the configured thinking.effort', () => {
       configValues['thinking'] = { effort: 'medium' };
       expect(resolveEffort(['thinking'], ['low', 'medium', 'high'])).toBe('medium');
diff --git a/packages/agent-core-v2/test/app/modelCatalog/modelCatalog.test.ts b/packages/agent-core-v2/test/app/modelCatalog/modelCatalog.test.ts
index a5ecc2e4d..3b95dc2a2 100644
--- a/packages/agent-core-v2/test/app/modelCatalog/modelCatalog.test.ts
+++ b/packages/agent-core-v2/test/app/modelCatalog/modelCatalog.test.ts
@@ -173,6 +173,78 @@ describe('ModelCatalogService', () => {
     });
   });
 
+  it('projects official Anthropic effort metadata inferred from the model name', async () => {
+    backing.providers['anthropic'] = { type: 'anthropic' };
+    backing.models['opus'] = {
+      provider: 'anthropic',
+      model: 'claude-opus-4-6',
+      maxContextSize: 200000,
+    };
+
+    const opus = (await catalog().listModels()).find((model) => model.model === 'opus');
+    expect(opus).toMatchObject({
+      capabilities: ['thinking'],
+      support_efforts: ['low', 'medium', 'high', 'max'],
+      default_effort: 'high',
+    });
+  });
+
+  it('projects latest Opus efforts for unknown Anthropic-compatible models', async () => {
+    backing.providers['custom'] = { type: 'anthropic' };
+    backing.models['compatible'] = {
+      provider: 'custom',
+      model: 'compatible-model',
+      maxContextSize: 128000,
+    };
+
+    const compatible = (await catalog().listModels()).find(
+      (model) => model.model === 'compatible',
+    );
+    expect(compatible).toMatchObject({
+      capabilities: ['thinking'],
+      support_efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+      default_effort: 'high',
+    });
+  });
+
+  it('projects latest Opus efforts for a flat providerless Anthropic model', async () => {
+    backing.models['compatible'] = {
+      model: 'compatible-model',
+      baseUrl: 'https://anthropic.example.test',
+      protocol: 'anthropic',
+      maxContextSize: 128000,
+    };
+
+    const compatible = (await catalog().listModels()).find(
+      (model) => model.model === 'compatible',
+    );
+    expect(compatible).toMatchObject({
+      capabilities: ['thinking'],
+      support_efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+      default_effort: 'high',
+    });
+  });
+
+  it('does not project fallback efforts for unknown Kimi-managed Anthropic models', async () => {
+    backing.models['compatible'] = {
+      provider: 'kimi',
+      protocol: 'anthropic',
+      model: 'compatible-model',
+      maxContextSize: 128000,
+    };
+
+    const compatible = (await catalog().listModels()).find(
+      (model) => model.model === 'compatible',
+    );
+    expect(compatible).toMatchObject({
+      provider: 'kimi',
+      model: 'compatible',
+    });
+    expect(compatible?.capabilities).toBeUndefined();
+    expect(compatible?.support_efforts).toBeUndefined();
+    expect(compatible?.default_effort).toBeUndefined();
+  });
+
   it('projects effort fields from overrides when present', async () => {
     backing.models['k2'] = {
       ...backing.models['k2'],
diff --git a/packages/agent-core-v2/test/app/plugin/manager-consumption.test.ts b/packages/agent-core-v2/test/app/plugin/manager-consumption.test.ts
index 8bf4b2487..7b26ab6e7 100644
--- a/packages/agent-core-v2/test/app/plugin/manager-consumption.test.ts
+++ b/packages/agent-core-v2/test/app/plugin/manager-consumption.test.ts
@@ -754,4 +754,60 @@ describe('PluginManager consumption plane', () => {
     await rm(cdnSource, { recursive: true, force: true });
     await rm(ghSource, { recursive: true, force: true });
   });
+
+  it('enabledMcpServers() runs stdio node plugins via the bundled Electron Node under an Electron host', async () => {
+    const home = await makeKimiHome();
+    const root = await makePlugin('demo', {
+      mcpServers: { data: { command: 'node', args: ['./bin/data.mjs'] } },
+    });
+    const manager = new PluginManager({ kimiHomeDir: home });
+    await manager.load();
+    await manager.install(root);
+    const managedRoot = await managedPluginRoot(manager, 'demo');
+
+    const originalElectron = process.versions['electron'];
+    process.versions['electron'] = '33.4.11';
+    try {
+      const server = manager.enabledMcpServers()['plugin-demo:data'];
+      expect(server).toEqual(
+        expect.objectContaining({
+          command: process.execPath,
+          args: ['./bin/data.mjs'],
+          cwd: managedRoot,
+          env: expect.objectContaining({
+            KIMI_CODE_HOME: home,
+            KIMI_PLUGIN_ROOT: managedRoot,
+            ELECTRON_RUN_AS_NODE: '1',
+          }),
+        }),
+      );
+      // An Electron host must not be routed through the CLI's `__plugin_run_node`
+      // subcommand (which only the CLI binary implements).
+      expect(JSON.stringify(server)).not.toContain('__plugin_run_node');
+    } finally {
+      if (originalElectron === undefined) delete process.versions['electron'];
+      else process.versions['electron'] = originalElectron;
+    }
+  });
+
+  it('enabledMcpServers() leaves stdio node plugins on system node outside Electron / CLI binary', async () => {
+    const home = await makeKimiHome();
+    const root = await makePlugin('demo', {
+      mcpServers: { data: { command: 'node', args: ['./bin/data.mjs'] } },
+    });
+    const manager = new PluginManager({ kimiHomeDir: home });
+    await manager.load();
+    await manager.install(root);
+
+    // Plain node host (tests run under node): not Electron, not the CLI native
+    // binary, so the config passes through unchanged (command stays `node`).
+    const server = manager.enabledMcpServers()['plugin-demo:data'];
+    expect(server).toEqual(
+      expect.objectContaining({
+        command: 'node',
+        args: ['./bin/data.mjs'],
+      }),
+    );
+    expect(JSON.stringify(server)).not.toContain('ELECTRON_RUN_AS_NODE');
+  });
 });
diff --git a/packages/agent-core-v2/test/app/protocol/protocolAdapterRegistry.test.ts b/packages/agent-core-v2/test/app/protocol/protocolAdapterRegistry.test.ts
index 7b3be26a2..6865bacb8 100644
--- a/packages/agent-core-v2/test/app/protocol/protocolAdapterRegistry.test.ts
+++ b/packages/agent-core-v2/test/app/protocol/protocolAdapterRegistry.test.ts
@@ -41,6 +41,7 @@ describe('ProtocolAdapterRegistry', () => {
       providerOptions: {
         defaultMaxTokens: 12345,
         adaptiveThinking: false,
+        supportEfforts: ['low', 'high'],
         kimiThinking: true,
         betaApi: true,
         metadata: { user_id: 'session-test' },
@@ -49,6 +50,7 @@ describe('ProtocolAdapterRegistry', () => {
 
     expect(Reflect.get(provider, '_generationKwargs')).toMatchObject({ max_tokens: 12345 });
     expect(Reflect.get(provider, '_adaptiveThinking')).toBe(false);
+    expect(Reflect.get(provider, '_supportEfforts')).toEqual(['low', 'high']);
     expect(Reflect.get(provider, '_kimiThinking')).toBe(true);
     expect(Reflect.get(provider, '_betaApi')).toBe(true);
     expect(Reflect.get(provider, '_metadata')).toEqual({ user_id: 'session-test' });
@@ -90,9 +92,7 @@ describe('ProtocolAdapterRegistry', () => {
       apiKey: 'sk',
     });
 
-    expect(Reflect.get(provider.withThinking('max'), '_reasoningEffort')).toBe('max');
     expect(provider.withThinking('max').thinkingEffort).toBe('max');
-    expect(Reflect.get(provider.withThinking('medium'), '_reasoningEffort')).toBe('medium');
     expect(provider.withThinking('medium').thinkingEffort).toBe('medium');
   });
 
diff --git a/packages/agent-core-v2/test/app/sessionExport/sessionExport.test.ts b/packages/agent-core-v2/test/app/sessionExport/sessionExport.test.ts
index 2fb0f2753..1b567758d 100644
--- a/packages/agent-core-v2/test/app/sessionExport/sessionExport.test.ts
+++ b/packages/agent-core-v2/test/app/sessionExport/sessionExport.test.ts
@@ -8,6 +8,7 @@ import {
   readFile,
   readdir,
   rename,
+  rm,
   stat,
   symlink,
   unlink,
@@ -17,10 +18,10 @@ import { tmpdir } from 'node:os';
 import { Readable } from 'node:stream';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { join } from 'pathe';
+import { basename, dirname, join, resolve } from 'pathe';
 import { open as openZip } from 'yauzl';
 
-import { DisposableStore, type IDisposable } from '#/_base/di/lifecycle';
+import { Disposable, DisposableStore, type IDisposable } from '#/_base/di/lifecycle';
 import {
   createServices,
   type ServiceRegistration,
@@ -29,7 +30,7 @@ import {
 import { LifecycleScope, type IAgentScopeHandle, type ISessionScopeHandle } from '#/_base/di/scope';
 import type { ServiceIdentifier, ServicesAccessor } from '#/_base/di/instantiation';
 import { ILogService, type ILogService as LogService } from '#/_base/log/log';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { IWireService } from '#/wire/wire';
 import { IBootstrapService } from '#/app/bootstrap/bootstrap';
 import { openZipSource, type ZipSource } from '#/app/sessionExport/file-source';
 import {
@@ -54,6 +55,7 @@ import { ISessionMetadata, type SessionMeta } from '#/session/sessionMetadata/se
 
 import { stubBootstrap } from '../bootstrap/stubs';
 import { stubLog } from '../../_base/log/stubs';
+import { stubAgentWire } from '../../wire/stubs';
 
 const fsOpenHook = vi.hoisted(() => ({
   afterOpen: undefined as ((path: string, handle: FileHandle) => Promise<void>) | undefined,
@@ -142,6 +144,54 @@ describe('sessionExport', () => {
     });
   });
 
+  it('uses a timestamped default output path when outputPath is omitted', async () => {
+    const tmp = await mkdtemp(join(tmpdir(), 'session-export-test-'));
+    const sessionDir = join(tmp, 'sessions', 'ws_demo', 'ses_default_output');
+    await mkdir(sessionDir, { recursive: true });
+    await writeFile(join(sessionDir, 'state.json'), '{}\n', 'utf-8');
+
+    const result = await exportSessionDirectory({
+      request: { sessionId: 'ses_default_output', version: '1.0.0-test' },
+      summary: { id: 'ses_default_output', sessionDir },
+    });
+
+    try {
+      expect(dirname(result.zipPath)).toBe(resolve('.'));
+      expect(basename(result.zipPath)).toMatch(/^kimi-debug-ses_defa-\d{8}-\d{6}\.zip$/);
+      await expect(stat(result.zipPath)).resolves.toMatchObject({ size: expect.any(Number) });
+    } finally {
+      await rm(result.zipPath, { force: true });
+    }
+  });
+
+  it('does not overwrite a previous default-path export when run again', async () => {
+    const tmp = await mkdtemp(join(tmpdir(), 'session-export-test-'));
+    const sessionDir = join(tmp, 'sessions', 'ws_demo', 'ses_repeated_export');
+    await mkdir(sessionDir, { recursive: true });
+    await writeFile(join(sessionDir, 'state.json'), '{}\n', 'utf-8');
+    const summary = { id: 'ses_repeated_export', sessionDir };
+
+    const first = await exportSessionDirectory({
+      request: { sessionId: 'ses_repeated_export', version: '1.0.0-test' },
+      summary,
+    });
+    // Cross the next second boundary so the second export gets a distinct timestamp.
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 1100 - (Date.now() % 1000)));
+    const second = await exportSessionDirectory({
+      request: { sessionId: 'ses_repeated_export', version: '1.0.0-test' },
+      summary,
+    });
+
+    try {
+      expect(second.zipPath).not.toBe(first.zipPath);
+      await expect(stat(first.zipPath)).resolves.toMatchObject({ size: expect.any(Number) });
+      await expect(stat(second.zipPath)).resolves.toMatchObject({ size: expect.any(Number) });
+    } finally {
+      await rm(first.zipPath, { force: true });
+      await rm(second.zipPath, { force: true });
+    }
+  });
+
   it('keeps the session log bound when it rotates as wire scanning starts', async () => {
     const tmp = await mkdtemp(join(tmpdir(), 'session-export-test-'));
     const sessionDir = join(tmp, 'sessions', 'ws_demo', 'ses_rotating_log');
@@ -868,7 +918,7 @@ function testAgentHandle(agentWire: Pick<ReturnType<typeof stubAgentWire>, 'flus
   return {
     id: 'main',
     kind: LifecycleScope.Agent,
-    accessor: accessorFrom([[IAgentWireRecordService, stubAgentWire(agentWire.flush)]]),
+    accessor: accessorFrom([[IWireService, stubAgentWire(agentWire.flush)]]),
     dispose: () => {},
   };
 }
@@ -912,17 +962,6 @@ function stubAgentLifecycle(agents: readonly IAgentScopeHandle[]): IAgentLifecyc
     remove: async () => {},
   };
 }
-
-function stubAgentWire(flush: () => Promise<void> = async () => {}): IAgentWireRecordService {
-  return {
-    _serviceBrand: undefined,
-    getRecords: () => [],
-    restore: async () => ({}),
-    flush,
-    close: async () => {},
-  };
-}
-
 function testManifest(sessionId: string): ExportSessionManifest {
   return {
     sessionId,
diff --git a/packages/agent-core-v2/test/app/sessionLegacy/sessionLegacy.test.ts b/packages/agent-core-v2/test/app/sessionLegacy/sessionLegacy.test.ts
index 31a2a62c3..b45a6fefa 100644
--- a/packages/agent-core-v2/test/app/sessionLegacy/sessionLegacy.test.ts
+++ b/packages/agent-core-v2/test/app/sessionLegacy/sessionLegacy.test.ts
@@ -23,9 +23,9 @@ import { UNKNOWN_CAPABILITY } from '#/app/llmProtocol/capability';
 import { ISessionLegacyService } from '#/app/sessionLegacy/sessionLegacy';
 import { SessionLegacyService } from '#/app/sessionLegacy/sessionLegacyService';
 import { ISessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycle';
+import { IAgentActivityView } from '#/agent/activityView/activityView';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { ISessionCronService } from '#/session/cron/sessionCronService';
-import { ISessionActivity } from '#/session/sessionActivity/sessionActivity';
 
 function accessor(
   entries: ReadonlyArray<readonly [ServiceIdentifier<unknown>, unknown]>,
@@ -79,6 +79,10 @@ describe('Session legacy status (best-effort runtime state)', () => {
         [IAgentPermissionModeService, { mode: 'manual' }],
         [IAgentPlanService, { status: () => Promise.resolve(null) }],
         [IAgentSwarmService, { isActive: false }],
+        [
+          IAgentActivityView,
+          { state: () => ({ lifecycle: 'ready', background: [] }) },
+        ],
       ]),
       dispose: () => {},
     };
@@ -87,6 +91,7 @@ describe('Session legacy status (best-effort runtime state)', () => {
       // already exists, so return it as-is (same as whenReady).
       create: () => Promise.resolve(agent),
       whenReady: () => Promise.resolve(agent),
+      list: () => [agent],
     } as unknown as IAgentLifecycleService;
     const session: ISessionScopeHandle = {
       id: 'session-test',
@@ -94,7 +99,6 @@ describe('Session legacy status (best-effort runtime state)', () => {
       accessor: accessor([
         [IAgentLifecycleService, agents],
         [ISessionCronService, { _serviceBrand: undefined }],
-        [ISessionActivity, { status: () => 'idle' }],
       ]),
       dispose: () => {},
     };
@@ -107,7 +111,7 @@ describe('Session legacy status (best-effort runtime state)', () => {
     const status = await ix.get(ISessionLegacyService).status('session-test');
 
     expect(status).toMatchObject({
-      status: 'idle',
+      busy: false,
       model: 'removed-model',
       thinking_level: 'high',
       max_context_tokens: 0,
diff --git a/packages/agent-core-v2/test/app/sessionLifecycle/sessionLifecycle.test.ts b/packages/agent-core-v2/test/app/sessionLifecycle/sessionLifecycle.test.ts
index 605a42189..a82aee93d 100644
--- a/packages/agent-core-v2/test/app/sessionLifecycle/sessionLifecycle.test.ts
+++ b/packages/agent-core-v2/test/app/sessionLifecycle/sessionLifecycle.test.ts
@@ -31,10 +31,8 @@ import { ICronTaskPersistence } from '#/app/cron/cronTaskPersistence';
 import { CRON_SESSION_TAG, type CronTask } from '#/app/cron/cronTask';
 import { ISessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycle';
 import { SessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycleService';
-import { ISessionActivityKernel } from '#/activity/activity';
-import { SessionActivityKernel } from '#/activity/sessionActivityKernel';
+import { IAgentActivityView } from '#/agent/activityView/activityView';
 import { ISessionExternalHooksService } from '#/session/externalHooks/externalHooks';
-import { ISessionActivity } from '#/session/sessionActivity/sessionActivity';
 import { ISessionMetadata } from '#/session/sessionMetadata/sessionMetadata';
 import { ISessionSkillCatalog } from '#/session/sessionSkillCatalog/skillCatalog';
 import { ISessionIndex, type SessionSummary } from '#/app/sessionIndex/sessionIndex';
@@ -48,7 +46,6 @@ import { encodeWorkDirKey } from '#/_base/utils/workdir-slug';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { Error2, ErrorCodes } from '#/errors';
-import { stubSessionActivityKernel } from '../../activity/stubs';
 import { recordingTelemetry, type TelemetryRecord } from '../../app/telemetry/stubs';
 
 function bootstrapStub(): IBootstrapService {
@@ -57,6 +54,8 @@ function bootstrapStub(): IBootstrapService {
     homeDir: '/tmp',
     sessionScope: (workspaceId: string, sessionId: string) =>
       `sessions/${workspaceId}/${sessionId}`,
+    agentScope: (workspaceId: string, sessionId: string, agentId: string) =>
+      `sessions/${workspaceId}/${sessionId}/agents/${agentId}`,
     sessionDir: (workspaceId: string, sessionId: string) =>
       `/tmp/sessions/${workspaceId}/${sessionId}`,
   } as IBootstrapService;
@@ -68,10 +67,10 @@ function tmpBootstrapStub(root: string): IBootstrapService {
     homeDir: root,
     sessionScope: (workspaceId: string, sessionId: string) =>
       `sessions/${workspaceId}/${sessionId}`,
+    agentScope: (workspaceId: string, sessionId: string, agentId: string) =>
+      `sessions/${workspaceId}/${sessionId}/agents/${agentId}`,
     sessionDir: (workspaceId: string, sessionId: string) =>
       join(root, 'sessions', workspaceId, sessionId),
-    agentHomedir: (workspaceId: string, sessionId: string, agentId: string) =>
-      join(root, 'sessions', workspaceId, sessionId, 'agents', agentId),
   } as IBootstrapService;
 }
 
@@ -413,13 +412,6 @@ describe('SessionLifecycleService', () => {
       InstantiationType.Eager,
       'externalHooks',
     );
-    registerScopedService(
-      LifecycleScope.Session,
-      ISessionActivityKernel,
-      SessionActivityKernel,
-      InstantiationType.Delayed,
-      'activity',
-    );
     registerScopedService(
       LifecycleScope.App,
       IHostFileSystem,
@@ -450,7 +442,6 @@ describe('SessionLifecycleService', () => {
       stubPair(ISessionMcpService, sessionMcpServiceStub()),
       stubPair(IConfigService, configStub()),
       stubPair(ISessionCronService, { _serviceBrand: undefined } as unknown as ISessionCronService),
-      stubPair(ISessionActivityKernel, stubSessionActivityKernel()),
       stubPair(IWorkspaceLocalConfigService, workspaceLocalConfigStub()),
       stubPair(ITelemetryService, recordingTelemetry(telemetryRecords)),
       stubPair(ICronTaskPersistence, cronStoreStub()),
@@ -668,6 +659,52 @@ describe('SessionLifecycleService', () => {
     expect(archived).toBe(false);
   });
 
+  it('forks successfully even while the source has a busy agent (crash-equivalent copy)', async () => {
+    const busyAgent = {
+      id: MAIN_AGENT_ID,
+      kind: LifecycleScope.Agent,
+      accessor: {
+        get: (token: unknown) => {
+          if (token === IAgentActivityView) {
+            return {
+              state: () => ({
+                lifecycle: 'ready',
+                turn: { turnId: 0 },
+                background: [],
+              }),
+            };
+          }
+          throw new Error('unexpected service access');
+        },
+      },
+      dispose: () => {},
+    } as unknown as IAgentScopeHandle;
+    const svc = build([
+      stubPair(IWorkspaceRegistry, {
+        ...workspaceRegistryStub(),
+        get: () =>
+          Promise.resolve({
+            id: 'wd_stub',
+            root: '/tmp/proj',
+            name: 'stub',
+            createdAt: 0,
+            lastOpenedAt: 0,
+          }),
+      }),
+      stubPair(IAgentLifecycleService, {
+        ...agentLifecycleStub(),
+        list: () => [busyAgent],
+      }),
+    ]);
+
+    await svc.create({ sessionId: 'src', workDir: '/tmp/proj' });
+
+    // Fork never gates on activity: a mid-work copy is crash-equivalent, and
+    // replay already normalizes that on restore.
+    const target = await svc.fork({ sourceSessionId: 'src', newSessionId: 'dst' });
+    expect(target.id).toBe('dst');
+  });
+
   it('fires onDidCreateSession with the new handle', async () => {
     const svc = build();
     let captured: { readonly sessionId: string } | undefined;
@@ -678,16 +715,16 @@ describe('SessionLifecycleService', () => {
     expect(captured).toMatchObject({ sessionId: 's1', handle: h, source: 'startup' });
   });
 
-  it('emits session_started with resumed: false on create', async () => {
+  it('emits session_started with resumed: false and the bound session id on create', async () => {
     const svc = build();
     await svc.create({ sessionId: 's1', workDir: '/tmp/proj' });
     expect(telemetryRecords).toContainEqual({
       event: 'session_started',
-      properties: { resumed: false },
+      properties: { sessionId: 's1', resumed: false },
     });
   });
 
-  it('emits session_started with resumed: true on resume', async () => {
+  it('emits session_started with resumed: true and the bound session id on resume', async () => {
     const workDir = '/tmp/proj';
     const svc = build([
       stubPair(IWorkspaceRegistry, persistentWorkspaceRegistryStub()),
@@ -699,11 +736,11 @@ describe('SessionLifecycleService', () => {
 
     expect(telemetryRecords).toContainEqual({
       event: 'session_started',
-      properties: { resumed: true },
+      properties: { sessionId: 's1', resumed: true },
     });
   });
 
-  it('emits session_load_failed with the error code when resume fails, then rethrows', async () => {
+  it('emits session_load_failed with the bound session id and the error code when resume fails, then rethrows', async () => {
     const svc = build([
       stubPair(ISessionIndex, {
         ...sessionIndexStub(),
@@ -714,11 +751,11 @@ describe('SessionLifecycleService', () => {
     await expect(svc.resume('s1')).rejects.toMatchObject({ code: ErrorCodes.SESSION_NOT_FOUND });
     expect(telemetryRecords).toContainEqual({
       event: 'session_load_failed',
-      properties: { reason: ErrorCodes.SESSION_NOT_FOUND },
+      properties: { sessionId: 's1', reason: ErrorCodes.SESSION_NOT_FOUND },
     });
   });
 
-  it('emits session_load_failed with the error name for plain errors', async () => {
+  it('emits session_load_failed with the bound session id and the error name for plain errors', async () => {
     const svc = build([
       stubPair(ISessionIndex, {
         ...sessionIndexStub(),
@@ -729,7 +766,7 @@ describe('SessionLifecycleService', () => {
     await expect(svc.resume('s1')).rejects.toBeInstanceOf(TypeError);
     expect(telemetryRecords).toContainEqual({
       event: 'session_load_failed',
-      properties: { reason: 'TypeError' },
+      properties: { sessionId: 's1', reason: 'TypeError' },
     });
   });
 
@@ -919,11 +956,6 @@ describe('SessionLifecycleService', () => {
     it('fork inherits project-local dirs', async () => {
       const svc = build([
         stubPair(IWorkspaceLocalConfigService, workspaceLocalConfigStub(['/tmp/extra'])),
-        stubPair(ISessionActivity, {
-          _serviceBrand: undefined,
-          status: () => 'idle' as const,
-          isIdle: () => true,
-        }),
         stubPair(IWorkspaceRegistry, {
           ...workspaceRegistryStub(),
           get: () =>
@@ -954,11 +986,6 @@ describe('SessionLifecycleService', () => {
 
     it('fork mints a session_-prefixed lowercase id when newSessionId is omitted', async () => {
       const svc = build([
-        stubPair(ISessionActivity, {
-          _serviceBrand: undefined,
-          status: () => 'idle' as const,
-          isIdle: () => true,
-        }),
         stubPair(IWorkspaceRegistry, {
           ...workspaceRegistryStub(),
           get: () =>
@@ -1052,7 +1079,7 @@ describe('SessionLifecycleService', () => {
           ...metadataStub(),
           read: () =>
             Promise.resolve({
-              agents: { main: { homedir: join(srcDir, 'agents', 'main') } },
+              agents: { main: {} },
             } as never),
         }),
       ]);
diff --git a/packages/agent-core-v2/test/app/skillCatalog/plugin-session-start.test.ts b/packages/agent-core-v2/test/app/skillCatalog/plugin-session-start.test.ts
index fc8cc4b3b..64bb554d4 100644
--- a/packages/agent-core-v2/test/app/skillCatalog/plugin-session-start.test.ts
+++ b/packages/agent-core-v2/test/app/skillCatalog/plugin-session-start.test.ts
@@ -11,7 +11,6 @@ import { describe, expect, it } from 'vitest';
 
 import { IAgentContextInjectorService } from '#/agent/contextInjector/contextInjector';
 import type { ContextMessage } from '#/agent/contextMemory/types';
-import { IAgentWireService } from '#/wire/tokens';
 import type { LogContext, LogPayload } from '#/_base/log/log';
 import type { EnabledPluginSessionStart } from '#/app/plugin/types';
 import { InMemorySkillCatalog } from '#/app/skillCatalog/registry';
@@ -184,7 +183,7 @@ describe('plugin session-start dynamic injection', () => {
       skills: [skill('using-superpowers', 'body', { id: 'superpowers' })],
     });
 
-    await ctx.get(IAgentWireService).replay({
+    await ctx.restore([{
       type: 'context.append_message',
       time: 1,
       message: {
@@ -193,7 +192,7 @@ describe('plugin session-start dynamic injection', () => {
         toolCalls: [],
         origin: { kind: 'injection', variant: 'plugin_session_start' },
       },
-    });
+    }]);
 
     await injectDynamic(ctx);
 
diff --git a/packages/agent-core-v2/test/app/telemetry/cloudAppender.test.ts b/packages/agent-core-v2/test/app/telemetry/cloudAppender.test.ts
index 999189043..5ade07025 100644
--- a/packages/agent-core-v2/test/app/telemetry/cloudAppender.test.ts
+++ b/packages/agent-core-v2/test/app/telemetry/cloudAppender.test.ts
@@ -103,6 +103,29 @@ describe('CloudAppender', () => {
     expect(typeof event?.['timestamp']).toBe('number');
   });
 
+  it('applies setContext sessionId and model updates to subsequent events', async () => {
+    const requests: CapturedRequest[] = [];
+    const appender = new CloudAppender(
+      baseOptions({
+        homeDir,
+        deviceId: 'dev123',
+        model: 'initial-model',
+        fetchImpl: makeFetch((req) => {
+          requests.push(req);
+          return okResponse();
+        }),
+      }),
+    );
+
+    appender.setContext({ sessionId: 'sess42', model: 'switched-model' });
+    appender.track('turn_started', {});
+    await appender.flush();
+
+    const event = requests[0]?.body.events[0];
+    expect(event?.['session_id']).toBe('sess42');
+    expect(event?.['context_model']).toBe('switched-model');
+  });
+
   it('sends Authorization header when a token is provided', async () => {
     const requests: CapturedRequest[] = [];
     const appender = new CloudAppender(
diff --git a/packages/agent-core-v2/test/app/web/providers/local-fetch-url.test.ts b/packages/agent-core-v2/test/app/web/providers/local-fetch-url.test.ts
new file mode 100644
index 000000000..07673a727
--- /dev/null
+++ b/packages/agent-core-v2/test/app/web/providers/local-fetch-url.test.ts
@@ -0,0 +1,353 @@
+/**
+ * `web` domain tests — `LocalFetchURLProvider` SSRF guard and redirects.
+ *
+ * Locks in that the provider rejects URLs whose IP literal or resolved
+ * address is private / loopback / link-local (including IPv4-mapped IPv6
+ * forms), fails closed on DNS errors, and follows redirects manually with
+ * every hop re-validated. DNS is mocked so tests stay hermetic.
+ */
+
+import { lookup } from 'node:dns/promises';
+
+import { Agent } from 'undici';
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
+
+import { LocalFetchURLProvider } from '#/app/web/providers/local-fetch-url';
+
+vi.mock('node:dns/promises', () => ({ lookup: vi.fn() }));
+
+const lookupMock = lookup as unknown as Mock;
+
+// The init's dispatcher property is typed by @types/node's bundled
+// undici-types, while the runtime value is the undici package's Agent —
+// convert through unknown to bridge the two declarations.
+function asUndiciAgent(dispatcher: RequestInit['dispatcher']): Agent {
+  return dispatcher as unknown as Agent;
+}
+
+// Keep DNS hermetic: every hostname resolves to a public address unless a
+// test overrides it (mockReset clears per-test overrides first).
+beforeEach(() => {
+  lookupMock.mockReset();
+  lookupMock.mockResolvedValue([{ address: '93.184.216.34', family: 4 }]);
+  // Connection pinning is skipped when a proxy is configured — keep the
+  // environment free of proxy variables so tests stay hermetic anywhere.
+  for (const key of ['http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY', 'all_proxy', 'ALL_PROXY']) {
+    vi.stubEnv(key, '');
+  }
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
+function htmlResponse(body: string, contentType: string): Response {
+  return new Response(body, {
+    status: 200,
+    headers: { 'content-type': contentType },
+  });
+}
+
+describe('LocalFetchURLProvider SSRF guard', () => {
+  it('rejects a loopback IPv4 literal without fetching or resolving DNS', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://127.0.0.1:1337/')).rejects.toThrow(
+      'Refusing to fetch private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+    expect(lookupMock).not.toHaveBeenCalled();
+  });
+
+  it('rejects an IPv4-mapped IPv6 literal', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://[::ffff:127.0.0.1]/')).rejects.toThrow(
+      'Refusing to fetch private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects localhost and *.localhost aliases', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://localhost:1337/')).rejects.toThrow(
+      'Refusing to fetch private host',
+    );
+    await expect(provider.fetch('http://ev1l.localhost/')).rejects.toThrow(
+      'Refusing to fetch private host',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects a hostname that resolves to a loopback address', async () => {
+    lookupMock.mockResolvedValue([
+      { address: '::1', family: 6 },
+      { address: '127.0.0.1', family: 4 },
+    ]);
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://localtest.me/')).rejects.toThrow(
+      'resolves to private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects a hostname that resolves to an IPv4-mapped IPv6 address', async () => {
+    lookupMock.mockResolvedValue([{ address: '::ffff:169.254.169.254', family: 6 }]);
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://sneaky.example.com/')).rejects.toThrow(
+      'resolves to private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('fails closed when DNS resolution fails', async () => {
+    lookupMock.mockRejectedValue(new Error('getaddrinfo ENOTFOUND b0rked.example'));
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://b0rked.example/')).rejects.toThrow('Cannot resolve host');
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects non-http(s) schemes before any network access', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('file:///etc/passwd')).rejects.toThrow('Unsupported URL scheme');
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('fetches public hosts normally', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/');
+
+    expect(result.content).toBe('ok');
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(lookupMock).toHaveBeenCalledWith('example.com', { all: true });
+  });
+
+  it('skips all checks when allowPrivateAddresses is set', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('local', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl, allowPrivateAddresses: true });
+
+    const result = await provider.fetch('http://127.0.0.1:1337/');
+
+    expect(result.content).toBe('local');
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(lookupMock).not.toHaveBeenCalled();
+  });
+});
+
+describe('LocalFetchURLProvider redirects', () => {
+  it('follows a redirect after re-validating the target, fetching manually', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(
+        new Response(null, {
+          status: 302,
+          headers: { location: 'https://cdn.example.com/page' },
+        }),
+      )
+      .mockResolvedValueOnce(htmlResponse('final body', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/start');
+
+    expect(result.content).toBe('final body');
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+    expect(lookupMock).toHaveBeenCalledWith('cdn.example.com', { all: true });
+    const [, firstInit] = fetchImpl.mock.calls[0]!;
+    expect((firstInit as RequestInit).redirect).toBe('manual');
+  });
+
+  it('resolves relative redirect targets against the current URL', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(new Response(null, { status: 301, headers: { location: '/final' } }))
+      .mockResolvedValueOnce(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/start');
+
+    const [secondUrl] = fetchImpl.mock.calls[1]!;
+    expect(secondUrl).toBe('https://example.com/final');
+  });
+
+  it('refuses a redirect to a private IP literal', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(
+      new Response(null, {
+        status: 302,
+        headers: { location: 'http://169.254.169.254/latest/meta-data' },
+      }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/start')).rejects.toThrow(
+      'Refusing to fetch private address',
+    );
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it('refuses a redirect whose target host resolves to a private address', async () => {
+    lookupMock.mockImplementation(async (host: string) =>
+      host === 'internal.example.com'
+        ? [{ address: '10.0.0.7', family: 4 }]
+        : [{ address: '93.184.216.34', family: 4 }],
+    );
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(
+      new Response(null, {
+        status: 302,
+        headers: { location: 'https://internal.example.com/' },
+      }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/')).rejects.toThrow(
+      'resolves to private address',
+    );
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it('gives up after too many redirects', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockImplementation(
+      async () => new Response(null, { status: 302, headers: { location: '/loop' } }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/loop')).rejects.toThrow(
+      'Too many redirects',
+    );
+    expect(fetchImpl).toHaveBeenCalledTimes(11);
+  });
+
+  it('treats a redirect response without a Location header as final', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(
+        new Response('odd', { status: 302, headers: { 'content-type': 'text/plain' } }),
+      );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/odd');
+
+    expect(result.content).toBe('odd');
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('LocalFetchURLProvider connection pinning', () => {
+  it('pins a public-host fetch to the addresses validated by the safety check', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/');
+
+    expect(result.content).toBe('ok');
+    const [, init] = fetchImpl.mock.calls[0]!;
+    const dispatcher = (init as RequestInit).dispatcher;
+    expect(dispatcher).toBeInstanceOf(Agent);
+    // The DNS answer was validated once and reused for the connection.
+    expect(lookupMock).toHaveBeenCalledTimes(1);
+    // The per-hop Agent is closed once the body has been consumed.
+    expect(asUndiciAgent(dispatcher).closed).toBe(true);
+  });
+
+  it('pins every redirect hop to its own validated addresses and closes both Agents', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(new Response(null, { status: 302, headers: { location: '/next' } }))
+      .mockResolvedValueOnce(htmlResponse('done', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/start');
+
+    const first = (fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher;
+    const second = (fetchImpl.mock.calls[1]![1] as RequestInit).dispatcher;
+    expect(first).toBeInstanceOf(Agent);
+    expect(second).toBeInstanceOf(Agent);
+    expect(first).not.toBe(second);
+    expect(asUndiciAgent(first).closed).toBe(true);
+    expect(asUndiciAgent(second).closed).toBe(true);
+    expect(lookupMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('passes no dispatcher for an IP literal', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('http://93.184.216.34/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeUndefined();
+  });
+
+  it('passes no dispatcher when allowPrivateAddresses is set', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl, allowPrivateAddresses: true });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeUndefined();
+  });
+
+  it('passes no dispatcher when an HTTP proxy is configured', async () => {
+    vi.stubEnv('http_proxy', 'http://proxy.example:8080');
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeUndefined();
+  });
+
+  it('still pins when the request bypasses the proxy via NO_PROXY wildcard', async () => {
+    vi.stubEnv('http_proxy', 'http://proxy.example:8080');
+    vi.stubEnv('no_proxy', '*');
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeInstanceOf(Agent);
+  });
+
+  it('still pins when NO_PROXY exempts the target host specifically', async () => {
+    vi.stubEnv('http_proxy', 'http://proxy.example:8080');
+    vi.stubEnv('no_proxy', 'example.com');
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeInstanceOf(Agent);
+  });
+
+  it('rejects oversized responses by content-length and still closes the pinned Agent', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(
+      new Response('short', {
+        status: 200,
+        headers: {
+          'content-type': 'text/plain',
+          'content-length': String(11 * 1024 * 1024),
+        },
+      }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/big')).rejects.toThrow(
+      'Response body too large',
+    );
+
+    const dispatcher = (fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher;
+    expect(asUndiciAgent(dispatcher).closed).toBe(true);
+  });
+});
diff --git a/packages/agent-core-v2/test/app/web/tools/fetch-url.test.ts b/packages/agent-core-v2/test/app/web/tools/fetch-url.test.ts
index 2ad970a04..233833062 100644
--- a/packages/agent-core-v2/test/app/web/tools/fetch-url.test.ts
+++ b/packages/agent-core-v2/test/app/web/tools/fetch-url.test.ts
@@ -7,13 +7,24 @@
  * tool re-throws aborts so the executor can classify user cancellation.
  */
 
-import { describe, expect, it, vi } from 'vitest';
+import { lookup } from 'node:dns/promises';
+
+import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
 
 import type { ExecutableToolContext, ExecutableToolResult, ToolExecution } from '#/tool/toolContract';
 import { LocalFetchURLProvider } from '#/app/web/providers/local-fetch-url';
 import { FetchURLTool } from '#/app/web/tools/fetch-url';
 import type { UrlFetcher, UrlFetchResult } from '#/app/web/tools/fetch-url-types';
 
+vi.mock('node:dns/promises', () => ({ lookup: vi.fn() }));
+
+// LocalFetchURLProvider resolves hostnames before fetching; keep DNS
+// hermetic so provider-level tests never touch the real resolver.
+beforeEach(() => {
+  (lookup as unknown as Mock).mockReset();
+  (lookup as unknown as Mock).mockResolvedValue([{ address: '93.184.216.34', family: 4 }]);
+});
+
 function isPromiseLike(value: ToolExecution | Promise<ToolExecution>): value is Promise<ToolExecution> {
   return typeof (value as Promise<ToolExecution>).then === 'function';
 }
diff --git a/packages/agent-core-v2/test/app/workspaceRegistry/workspaceRegistryService.test.ts b/packages/agent-core-v2/test/app/workspaceRegistry/workspaceRegistryService.test.ts
index 57dbbe0c1..3b242dfe7 100644
--- a/packages/agent-core-v2/test/app/workspaceRegistry/workspaceRegistryService.test.ts
+++ b/packages/agent-core-v2/test/app/workspaceRegistry/workspaceRegistryService.test.ts
@@ -83,14 +83,25 @@ describe('WorkspaceRegistryService (file-backed)', () => {
 
   async function writeWorkspacesJson(
     workspaces: Record<string, PersistedWorkspaceEntry>,
+    extra?: { readonly deleted_workspace_ids?: unknown },
   ): Promise<void> {
     await fsp.writeFile(
       join(homeDir, 'workspaces.json'),
-      JSON.stringify({ version: 1, workspaces }),
+      JSON.stringify({ version: 1, workspaces, ...extra }),
       'utf8',
     );
   }
 
+  async function readWorkspacesJson(): Promise<{
+    workspaces: Record<string, PersistedWorkspaceEntry>;
+    deleted_workspace_ids?: unknown;
+  }> {
+    return JSON.parse(await fsp.readFile(join(homeDir, 'workspaces.json'), 'utf8')) as {
+      workspaces: Record<string, PersistedWorkspaceEntry>;
+      deleted_workspace_ids?: unknown;
+    };
+  }
+
   it('persists the catalog across registry instances', async () => {
     const created = await build().createOrTouch(homeDir, 'proj');
 
@@ -137,8 +148,9 @@ describe('WorkspaceRegistryService (file-backed)', () => {
     expect(await build().list()).toEqual([]);
   });
 
-  it('prefers an existing workspaces.json over the session index', async () => {
+  it('merges session-index workDirs into an existing catalog on load', async () => {
     const work = join(homeDir, 'existing');
+    const fromIndex = join(homeDir, 'from-index');
     await writeWorkspacesJson({
       [encodeWorkDirKey(work)]: {
         root: work,
@@ -150,14 +162,197 @@ describe('WorkspaceRegistryService (file-backed)', () => {
     await seedSessionIndex([
       {
         sessionId: 's9',
-        sessionDir: join(homeDir, 'sessions', encodeWorkDirKey(join(homeDir, 'from-index')), 's9'),
-        workDir: join(homeDir, 'from-index'),
+        sessionDir: join(homeDir, 'sessions', encodeWorkDirKey(fromIndex), 's9'),
+        workDir: fromIndex,
       },
     ]);
 
     const list = await build().list();
-    expect(list.map((w) => w.id)).toEqual([encodeWorkDirKey(work)]);
-    expect(list[0]?.name).toBe('existing');
+    expect(list.map((w) => w.id).toSorted()).toEqual(
+      [encodeWorkDirKey(work), encodeWorkDirKey(fromIndex)].toSorted(),
+    );
+    const existing = list.find((w) => w.id === encodeWorkDirKey(work));
+    // The registered entry keeps its persisted data; the merged entry only
+    // gets a basename-derived name.
+    expect(existing?.name).toBe('existing');
+    expect(existing?.lastOpenedAt).toBe(Date.parse('2024-01-02T00:00:00.000Z'));
+    expect(list.find((w) => w.id === encodeWorkDirKey(fromIndex))?.name).toBe('from-index');
+
+    // The merge is persisted, so a restart sees the same catalog.
+    expect((await restart().list()).map((w) => w.id).toSorted()).toEqual(
+      list.map((w) => w.id).toSorted(),
+    );
+  });
+
+  it('merge skips tombstoned ids and tolerates a dirty deleted_workspace_ids field', async () => {
+    const work = join(homeDir, 'existing');
+    const deleted = join(homeDir, 'deleted');
+    const fresh = join(homeDir, 'fresh');
+    await writeWorkspacesJson(
+      {
+        [encodeWorkDirKey(work)]: {
+          root: work,
+          name: 'existing',
+          created_at: '2024-01-01T00:00:00.000Z',
+          last_opened_at: '2024-01-02T00:00:00.000Z',
+        },
+      },
+      { deleted_workspace_ids: [encodeWorkDirKey(deleted), 42, null] },
+    );
+    await seedSessionIndex([
+      {
+        sessionId: 's1',
+        sessionDir: join(homeDir, 'sessions', encodeWorkDirKey(deleted), 's1'),
+        workDir: deleted,
+      },
+      {
+        sessionId: 's2',
+        sessionDir: join(homeDir, 'sessions', encodeWorkDirKey(fresh), 's2'),
+        workDir: fresh,
+      },
+    ]);
+
+    const list = await build().list();
+    expect(list.map((w) => w.id).toSorted()).toEqual(
+      [encodeWorkDirKey(work), encodeWorkDirKey(fresh)].toSorted(),
+    );
+  });
+
+  it('delete tombstones the id and the merge never resurrects it', async () => {
+    const dirA = join(homeDir, 'dir-a');
+    const dirB = join(homeDir, 'dir-b');
+    await fsp.mkdir(dirA);
+    await fsp.mkdir(dirB);
+    const registry = build();
+    const a = await registry.createOrTouch(dirA);
+    await registry.createOrTouch(dirB);
+
+    await registry.delete(a.id);
+    expect((await registry.list()).map((w) => w.id)).toEqual([encodeWorkDirKey(dirB)]);
+
+    // The tombstone is on disk in the v1-compatible field.
+    const onDisk = await readWorkspacesJson();
+    expect(onDisk.deleted_workspace_ids).toEqual([a.id]);
+    expect(onDisk.workspaces[a.id]).toBeUndefined();
+
+    // Sessions referencing the deleted workDir must not resurrect it.
+    await seedSessionIndex([
+      {
+        sessionId: 's1',
+        sessionDir: join(homeDir, 'sessions', a.id, 's1'),
+        workDir: dirA,
+      },
+    ]);
+    expect((await restart().list()).map((w) => w.id)).toEqual([encodeWorkDirKey(dirB)]);
+  });
+
+  it('createOrTouch clears the deletion tombstone', async () => {
+    const dirA = join(homeDir, 'dir-a');
+    await fsp.mkdir(dirA);
+    const registry = build();
+    const a = await registry.createOrTouch(dirA);
+    await registry.delete(a.id);
+
+    await registry.createOrTouch(dirA);
+    expect((await registry.list()).map((w) => w.id)).toEqual([a.id]);
+    expect(await readWorkspacesJson().then((f) => f.deleted_workspace_ids)).toEqual([]);
+
+    expect((await restart().list()).map((w) => w.id)).toEqual([a.id]);
+  });
+
+  it('createOrTouch preserves external additions and tombstones written after load', async () => {
+    const dirA = join(homeDir, 'dir-a');
+    const dirB = join(homeDir, 'dir-b');
+    const dirC = join(homeDir, 'dir-c');
+    await fsp.mkdir(dirA);
+    await fsp.mkdir(dirC);
+    const registry = build();
+    await registry.createOrTouch(dirA);
+
+    // Simulate a v1 writer touching the file after the v2 registry already
+    // ran an operation: a new workspace entry plus an unrelated tombstone.
+    const onDisk = await readWorkspacesJson();
+    onDisk.workspaces[encodeWorkDirKey(dirB)] = {
+      root: dirB,
+      name: 'dir-b',
+      created_at: '2024-01-01T00:00:00.000Z',
+      last_opened_at: '2024-01-01T00:00:00.000Z',
+    };
+    await fsp.writeFile(
+      join(homeDir, 'workspaces.json'),
+      JSON.stringify({
+        version: 1,
+        workspaces: onDisk.workspaces,
+        deleted_workspace_ids: ['wd_external_tombstone'],
+      }),
+      'utf8',
+    );
+
+    await registry.createOrTouch(dirC);
+
+    const after = await readWorkspacesJson();
+    expect(Object.keys(after.workspaces).toSorted()).toEqual(
+      [encodeWorkDirKey(dirA), encodeWorkDirKey(dirB), encodeWorkDirKey(dirC)].toSorted(),
+    );
+    expect(after.deleted_workspace_ids).toEqual(['wd_external_tombstone']);
+    // Reads also see the external entry without a restart.
+    expect((await registry.list()).map((w) => w.id)).toContain(encodeWorkDirKey(dirB));
+  });
+
+  it('delete adds its tombstone on top of the current file state', async () => {
+    const dirA = join(homeDir, 'dir-a');
+    await fsp.mkdir(dirA);
+    const registry = build();
+    const a = await registry.createOrTouch(dirA);
+
+    const onDisk = await readWorkspacesJson();
+    await fsp.writeFile(
+      join(homeDir, 'workspaces.json'),
+      JSON.stringify({
+        version: 1,
+        workspaces: onDisk.workspaces,
+        deleted_workspace_ids: ['wd_external_tombstone'],
+      }),
+      'utf8',
+    );
+
+    await registry.delete(a.id);
+
+    const after = await readWorkspacesJson();
+    expect(after.workspaces[a.id]).toBeUndefined();
+    expect((after.deleted_workspace_ids as string[]).toSorted()).toEqual(
+      ['wd_external_tombstone', a.id].toSorted(),
+    );
+  });
+
+  it('update renames the current file entry and misses externally removed ids', async () => {
+    const dirA = join(homeDir, 'dir-a');
+    await fsp.mkdir(dirA);
+    const registry = build();
+    const a = await registry.createOrTouch(dirA);
+
+    // External rename on disk: the update must start from it, not stale state.
+    const onDisk = await readWorkspacesJson();
+    const entry = onDisk.workspaces[a.id];
+    if (entry === undefined) throw new Error('seed entry missing');
+    onDisk.workspaces[a.id] = { ...entry, name: 'external-name' };
+    await fsp.writeFile(
+      join(homeDir, 'workspaces.json'),
+      JSON.stringify({ version: 1, workspaces: onDisk.workspaces, deleted_workspace_ids: [] }),
+      'utf8',
+    );
+
+    const renamed = await registry.update(a.id, { name: 'local-name' });
+    expect(renamed?.name).toBe('local-name');
+    expect(renamed?.lastOpenedAt).toBe(Date.parse(entry.last_opened_at));
+
+    // External removal: update reports the id as gone instead of resurrecting.
+    await fsp.writeFile(
+      join(homeDir, 'workspaces.json'),
+      JSON.stringify({ version: 1, workspaces: {}, deleted_workspace_ids: [] }),
+      'utf8',
+    );
+    expect(await registry.update(a.id, { name: 'whatever' })).toBeUndefined();
   });
 
   it('writes through on update and delete', async () => {
@@ -187,6 +382,16 @@ describe('WorkspaceRegistryService (file-backed)', () => {
     expect(await build().list()).toEqual([]);
   });
 
+  it('accepts createOrTouch when the root is given through a symlink', async () => {
+    const real = join(homeDir, 'real-root');
+    await fsp.mkdir(real, { recursive: true });
+    const link = join(homeDir, 'link-root');
+    await fsp.symlink(real, link, 'dir');
+    const ws = await build().createOrTouch(link);
+    expect(ws.root).toBe(link);
+    expect(ws.id).toBe(encodeWorkDirKey(link));
+  });
+
   it('rejects createOrTouch when a parent of the root is not a directory', async () => {
     const file = join(homeDir, 'a-file.txt');
     await fsp.writeFile(file, 'hi', 'utf8');
diff --git a/packages/agent-core-v2/test/harness/agent.ts b/packages/agent-core-v2/test/harness/agent.ts
index 90e6a6c11..1cccd8a8e 100644
--- a/packages/agent-core-v2/test/harness/agent.ts
+++ b/packages/agent-core-v2/test/harness/agent.ts
@@ -36,11 +36,8 @@ import type {
   ExecutableToolOutput as ToolOutput,
   ExecutableToolResult,
 } from '#/tool/toolContract';
-import type {
-  PersistedWireRecord,
-  WireRecordRestoreOptions,
-  WireRecordRestoreResult,
-} from '#/agent/wireRecord/wireRecord';
+import { AGENT_WIRE_RECORD_KEY, wireRecordToPayload, type WireRecord } from '#/wire/record';
+import { OP_REGISTRY } from '#/wire/op';
 import { IOAuthService } from '#/app/auth/auth';
 import { IProtocolAdapterRegistry, type ProtocolAdapterConfig } from '#/app/protocol/protocol';
 import type { SkillCatalog } from '#/app/skillCatalog/types';
@@ -56,12 +53,13 @@ import type { ILogger, LogContext, LogLevel } from '#/_base/log/log';
 import { ILogOptions } from '#/_base/log/logConfig';
 import type { EnabledPluginSessionStart } from '#/app/plugin/types';
 import {
-  AGENT_WIRE_PROTOCOL_VERSION,
+  WIRE_PROTOCOL_VERSION,
   AgentTaskService,
   AgentExternalHooksService,
   FileStorageService,
   InMemoryStorageService,
   AgentFullCompactionService,
+  IAgentActivityView,
   IAgentRPCService,
   IAppendLogStore,
   IFileSystemStorageService,
@@ -98,7 +96,6 @@ import {
   IAgentBuiltinToolsRegistrar,
   IAgentUserToolService,
   IAgentUsageService,
-  IAgentWireRecordService,
   ISessionWorkspaceContext,
   AgentLLMRequesterService,
   IAgentLifecycleService,
@@ -110,7 +107,6 @@ import {
   AgentProfileService,
   SyncDescriptor,
   AgentUserToolService,
-  AgentWireRecordService,
   SessionWorkspaceContextService,
   bootstrap,
   bootstrapSeed,
@@ -122,11 +118,9 @@ import {
   type ScopeSeed,
   type ServiceIdentifier,
 } from '#/index';
-import { IAgentActivityService, ISessionActivityKernel } from '#/activity/activity';
 import { IEventBus } from '#/app/event/eventBus';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { WireService } from '#/wire/wireService';
 import { IModelService } from '#/app/model/model';
 import { type Model } from '#/app/model/modelInstance';
 import { IHostRequestHeaders } from '#/app/model/hostRequestHeaders';
@@ -211,32 +205,32 @@ interface Logger {
 }
 
 export interface WireRecordPersistence {
-  readonly records: readonly PersistedWireRecord[];
-  read(): AsyncIterable<PersistedWireRecord>;
-  append(event: PersistedWireRecord): void;
-  rewrite(records: readonly PersistedWireRecord[]): void;
+  readonly records: readonly WireRecord[];
+  read(): AsyncIterable<WireRecord>;
+  append(event: WireRecord): void;
+  rewrite(records: readonly WireRecord[]): void;
   flush(): Promise<void>;
   close(): Promise<void>;
 }
 
 export class InMemoryWireRecordPersistence implements WireRecordPersistence {
-  readonly records: PersistedWireRecord[];
+  readonly records: WireRecord[];
 
-  constructor(records: readonly PersistedWireRecord[] = []) {
+  constructor(records: readonly WireRecord[] = []) {
     this.records = records.map(cloneRecord);
   }
 
-  async *read(): AsyncIterable<PersistedWireRecord> {
+  async *read(): AsyncIterable<WireRecord> {
     for (const record of this.records) {
       yield cloneRecord(record);
     }
   }
 
-  append(event: PersistedWireRecord): void {
+  append(event: WireRecord): void {
     this.records.push(cloneRecord(event));
   }
 
-  rewrite(records: readonly PersistedWireRecord[]): void {
+  rewrite(records: readonly WireRecord[]): void {
     this.records.splice(0, this.records.length, ...records.map(cloneRecord));
   }
 
@@ -514,7 +508,7 @@ export function configServices(readConfig: () => KimiConfig): TestAgentServiceOv
 
 export function wireRecordPersistenceServices(
   persistence: WireRecordPersistence,
-  onRead: (event: PersistedWireRecord) => void = () => { },
+  onRead: (event: WireRecord) => void = () => { },
 ): TestAgentServiceOverride {
   return appService(IAppendLogStore, new PersistenceAppendLogStore(persistence, () => { }, onRead));
 }
@@ -774,28 +768,31 @@ function collectScopeSeed(
 
 class PersistenceAppendLogStore implements IAppendLogStore {
   declare readonly _serviceBrand: undefined;
+  private readonly history: WireRecord[] = [];
 
   constructor(
     private readonly persistence: WireRecordPersistence,
-    private readonly onAppend: (event: PersistedWireRecord) => void,
-    private readonly onRead: (event: PersistedWireRecord) => void,
+    private readonly onAppend: (event: WireRecord) => void,
+    private readonly onRead: (event: WireRecord) => void,
   ) { }
 
   append<R>(_scope: string, _key: string, record: R): void {
-    const event = record as PersistedWireRecord;
+    const event = record as WireRecord;
     this.onAppend(event);
     this.persistence.append(event);
+    this.history.push(cloneRecord(event));
   }
 
   async *read<R>(_scope: string, _key: string): AsyncIterable<R> {
     for await (const event of this.persistence.read()) {
       this.onRead(event);
+      this.history.push(cloneRecord(event));
       yield event as R;
     }
   }
 
   rewrite<R>(_scope: string, _key: string, records: readonly R[]): Promise<void> {
-    this.persistence.rewrite(records as readonly PersistedWireRecord[]);
+    this.persistence.rewrite(records as readonly WireRecord[]);
     return Promise.resolve();
   }
 
@@ -810,6 +807,14 @@ class PersistenceAppendLogStore implements IAppendLogStore {
   acquire(_scope: string, _key: string): IDisposable {
     return toDisposable(() => { });
   }
+
+  snapshot(): WireRecord[] {
+    return this.persistence.records.map(cloneRecord);
+  }
+
+  historySnapshot(): WireRecord[] {
+    return this.history.map(cloneRecord);
+  }
 }
 
 class ConfigBackedModelResolver extends ModelResolverService {
@@ -861,7 +866,6 @@ export class AgentTestContext {
   private readonly serviceOverrides: readonly TestAgentScopedServiceOverride[];
   private readonly options: TestAgentOptions;
   private readonly scriptedGenerate = createScriptedGenerate();
-  readonly recordHistory: PersistedWireRecord[] = [];
   private readonly root: Scope;
   private readonly session: Scope;
   private readonly agent: Scope;
@@ -903,7 +907,7 @@ export class AgentTestContext {
       persistence.rewrite([
         {
           type: 'metadata',
-          protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+          protocol_version: WIRE_PROTOCOL_VERSION,
           created_at: 1,
         },
         ...persistence.records,
@@ -933,10 +937,8 @@ export class AgentTestContext {
             IAppendLogStore,
             new PersistenceAppendLogStore(
               persistence,
+              (event) => this.captureRecord(event),
               () => { },
-              (event) => {
-                this.recordHistory.push(cloneRecord(event));
-              },
             ),
           );
           reg.defineInstance(ILogService, createLogService(undefined));
@@ -1027,7 +1029,6 @@ export class AgentTestContext {
         'session',
       ),
     });
-    this.session.accessor.get(ISessionActivityKernel).markActive();
     const workspace = this.session.accessor.get(ISessionWorkspaceContext);
 
     this.agent = this.session.createChild(LifecycleScope.Agent, agentId, {
@@ -1035,12 +1036,8 @@ export class AgentTestContext {
         [
           (reg) => {
             reg.defineDescriptor(
-              IAgentWireRecordService,
-              new SyncDescriptor(AgentWireRecordService),
-            );
-            reg.defineDescriptor(
-              IAgentWireService,
-              new SyncDescriptor(WireService, [{ logScope: 'wire', logKey: agentId }]),
+              IWireService,
+              new SyncDescriptor(WireService),
             );
             reg.defineDescriptor(IAgentBlobService, new SyncDescriptor(AgentBlobServiceImpl));
             reg.defineDescriptor(IAgentProfileService, new SyncDescriptor(AgentProfileService));
@@ -1094,14 +1091,10 @@ export class AgentTestContext {
     });
 
     this.initializeRestorableServices();
-    this.get(IAgentActivityService).markReady();
+    // Resolve the activity view so its constructor subscriptions publish
+    // `agent.activity.updated` — production ignites it in agentLifecycle.
+    this.get(IAgentActivityView);
 
-    const wire = this.get(IAgentWireService);
-    this.disposables.push(
-      wire.onEmission((e) => {
-        this.captureRecord(e.record as PersistedWireRecord);
-      }),
-    );
     const eventBus = this.get(IEventBus);
     this.disposables.push(
       eventBus.subscribe((e) => {
@@ -1160,31 +1153,38 @@ export class AgentTestContext {
     return this.get(IAgentContextSizeService);
   }
 
-  get wireRecord(): IAgentWireRecordService {
-    return this.get(IAgentWireRecordService);
+  get wire(): IWireService {
+    return this.get(IWireService);
   }
 
-  async restorePersisted(options?: WireRecordRestoreOptions): Promise<WireRecordRestoreResult> {
-    const restoredStart = this.wireRecord.getRecords().length;
-    const result = await this.wireRecord.restore(undefined, options);
-    await this.replayRestoredRecordsSince(restoredStart);
-    return result;
+  async restorePersisted(): Promise<void> {
+    await this.wire.restore();
   }
 
-  private async restoreRecordsOnly(records: readonly PersistedWireRecord[]): Promise<void> {
-    const restoredStart = this.wireRecord.getRecords().length;
-    await this.wireRecord.restore(records);
-    await this.replayRestoredRecordsSince(restoredStart);
+  private async restoreRecordsOnly(records: readonly WireRecord[]): Promise<void> {
+    const scope = this.get(IAgentScopeContext).scope();
+    const log = this.get(IAppendLogStore);
+    await log.rewrite(scope, AGENT_WIRE_RECORD_KEY, records);
+    await this.wire.restore();
   }
 
-  private async replayRestoredRecordsSince(restoredStart: number): Promise<void> {
-    const restored = this.wireRecord.getRecords().slice(restoredStart);
-    await this.get(IAgentWireService).replay(...(restored as readonly PersistedRecord[]));
+  private async dispatchRecordsOnly(records: readonly WireRecord[]): Promise<void> {
+    for (const record of records) {
+      const descriptor = OP_REGISTRY.get(record.type);
+      if (descriptor === undefined) {
+        throw new Error(`Unknown wire record type in test harness: ${record.type}`);
+      }
+      this.wire.dispatch({
+        type: record.type,
+        payload: wireRecordToPayload(record),
+        descriptor,
+      });
+    }
+    await this.wire.flush();
   }
 
-  private async closeWireRecord(): Promise<void> {
-    await this.wireRecord.flush();
-    await this.wireRecord.close();
+  private async closeWire(): Promise<void> {
+    await this.wire.flush();
   }
 
   private initializeRestorableServices(): void {
@@ -1388,26 +1388,22 @@ export class AgentTestContext {
     return events;
   }
 
-  async dispatch(event: PersistedWireRecord): Promise<void> {
+  async dispatch(event: WireRecord): Promise<void> {
     this.suppressWireSnapshot = true;
     try {
-      await this.restoreRecordsOnly([event]);
-      this.captureRecord(event);
+      await this.dispatchRecordsOnly([event]);
     } finally {
       this.suppressWireSnapshot = false;
     }
   }
 
-  async restore(records: readonly PersistedWireRecord[]): Promise<void> {
+  async restore(records: readonly WireRecord[]): Promise<void> {
     this.suppressWireSnapshot = true;
     try {
       await this.restoreRecordsOnly(records);
     } finally {
       this.suppressWireSnapshot = false;
     }
-    for (const record of records) {
-      this.captureRecord(record);
-    }
   }
 
   once(type: string): Promise<void> {
@@ -1539,14 +1535,15 @@ export class AgentTestContext {
     await this.drainWirePersistence();
     const profile = this.get(IAgentProfileService);
     const configSnapshot = structuredClone(this.get(IConfigService).getAll() as KimiConfig);
-    let resumedThroughRecord = this.recordHistory.length;
+    let wireHistory = await this.wireHistory();
+    let resumedThroughRecord = wireHistory.length;
     const resumed = createTestAgent(
       { autoConfigure: false, cwd: profile.data().cwd },
       ...this.serviceOverrides,
       configServices(() => configSnapshot),
       llmGenerateServices(failOnResumeGenerate),
       wireRecordPersistenceServices(
-        new InMemoryWireRecordPersistence(withMetadata(this.recordHistory.map(cloneRecord))),
+        new InMemoryWireRecordPersistence(withMetadata(wireHistory)),
       ),
     );
 
@@ -1555,10 +1552,11 @@ export class AgentTestContext {
       await resumed.waitForSessionMetadata();
       for (let i = 0; i < 5; i += 1) {
         await this.drainWirePersistence();
-        if (this.recordHistory.length === resumedThroughRecord) break;
-        const nextRecords = this.recordHistory.slice(resumedThroughRecord).map(cloneRecord);
-        resumedThroughRecord = this.recordHistory.length;
-        await resumed.restore(nextRecords);
+        wireHistory = await this.wireHistory();
+        if (wireHistory.length === resumedThroughRecord) break;
+        const nextRecords = wireHistory.slice(resumedThroughRecord);
+        resumedThroughRecord = wireHistory.length;
+        await resumed.dispatchRecordsOnly(nextRecords);
       }
 
       // oxlint-disable-next-line jest/no-standalone-expect
@@ -1574,31 +1572,50 @@ export class AgentTestContext {
   }
 
   private async drainWirePersistence(): Promise<void> {
-    const wireRecord = this.get(IAgentWireRecordService);
+    const wire = this.get(IWireService);
     let lastRecordCount = -1;
     for (let i = 0; i < 25; i += 1) {
       for (let j = 0; j < 5; j += 1) {
         await Promise.resolve();
       }
       await new Promise<void>((resolve) => setImmediate(resolve));
-      await wireRecord.flush();
+      await wire.flush();
+      const persistedRecords = await this.persistedRecords();
       if (
-        this.recordHistory.length === lastRecordCount &&
-        pendingTaskNotificationKeys(this.recordHistory).length === 0
+        persistedRecords.length === lastRecordCount &&
+        pendingTaskNotificationKeys(persistedRecords).length === 0
       ) {
         return;
       }
-      lastRecordCount = this.recordHistory.length;
+      lastRecordCount = persistedRecords.length;
     }
   }
 
+  async persistedRecords(): Promise<WireRecord[]> {
+    const log = this.get(IAppendLogStore);
+    if (log instanceof PersistenceAppendLogStore) return log.snapshot();
+    const scope = this.get(IAgentScopeContext).scope();
+    const records: WireRecord[] = [];
+    for await (const record of log.read<WireRecord>(scope, AGENT_WIRE_RECORD_KEY)) {
+      records.push(cloneRecord(record));
+    }
+    return records;
+  }
+
+  async wireHistory(): Promise<WireRecord[]> {
+    const log = this.get(IAppendLogStore);
+    return log instanceof PersistenceAppendLogStore
+      ? log.historySnapshot()
+      : this.persistedRecords();
+  }
+
   async close(_reason = 'Agent runtime test closed'): Promise<void> {
     if (this.closed) return;
     this.closed = true;
     for (const disposable of this.disposables.splice(0)) {
       disposable.dispose();
     }
-    await this.closeWireRecord();
+    await this.closeWire();
     this.root.dispose();
   }
 
@@ -1613,7 +1630,7 @@ export class AgentTestContext {
     return this.snapshots.take(method);
   }
 
-  private recordWire(event: PersistedWireRecord): WireSnapshotEntry {
+  private recordWire(event: WireRecord): WireSnapshotEntry {
     const entry = this.snapshots.recordWire(event);
     this.emitter.emit(entry.event, entry);
     this.emitter.emit('event', entry);
@@ -1774,9 +1791,8 @@ export class AgentTestContext {
     };
   }
 
-  private captureRecord(event: PersistedWireRecord): void {
+  private captureRecord(event: WireRecord): void {
     const cloned = cloneRecord(event);
-    this.recordHistory.push(cloned);
     if (this.suppressWireSnapshot) return;
 
     this.recordWire(cloned);
@@ -1990,7 +2006,7 @@ function isSystemReminderMessage(message: ContextMessage): boolean {
   return text.startsWith('<system-reminder>');
 }
 
-function pendingTaskNotificationKeys(records: readonly PersistedWireRecord[]): readonly string[] {
+function pendingTaskNotificationKeys(records: readonly WireRecord[]): readonly string[] {
   const terminal = new Set<string>();
   const delivered = new Set<string>();
   for (const record of records) {
@@ -2011,7 +2027,7 @@ function pendingTaskNotificationKeys(records: readonly PersistedWireRecord[]): r
   return [...terminal].filter((key) => !delivered.has(key));
 }
 
-function contextMessagesFromRecord(record: PersistedWireRecord): readonly ContextMessage[] {
+function contextMessagesFromRecord(record: WireRecord): readonly ContextMessage[] {
   if (record.type === 'context.append_message') {
     const message = record['message'];
     return isContextMessageLike(message) ? [message] : [];
@@ -2271,7 +2287,7 @@ function capabilityNames(capabilities: ModelCapability | undefined): string[] {
     capabilities.audio_in ? 'audio_in' : undefined,
     capabilities.thinking ? 'thinking' : undefined,
     capabilities.tool_use ? 'tool_use' : undefined,
-    capabilities.select_tools ? 'select_tools' : undefined,
+    capabilities.dynamically_loaded_tools ? 'dynamically_loaded_tools' : undefined,
   ].filter((capability): capability is string => capability !== undefined);
 }
 
@@ -2429,6 +2445,10 @@ async function generateBackedResponse(
     {
       signal: options?.signal,
       auth: options?.auth,
+      // Forward the early-capture hook so a GenerateFn can fire the trace id
+      // as soon as its (simulated) response headers arrive — e.g. before a
+      // mid-stream failure — mirroring real kosong generate() behavior.
+      onTraceId: options?.onTraceId,
     },
   );
   return createStreamedMessage(
@@ -2440,6 +2460,7 @@ async function generateBackedResponse(
       usage: result.usage,
       finishReason: result.finishReason,
       rawFinishReason: result.rawFinishReason,
+      traceId: result.traceId,
     },
   );
 }
@@ -2508,13 +2529,17 @@ function normalizeProviderStreamParts(
 
 function createStreamedMessage(
   parts: readonly StreamedMessagePart[],
-  meta: Pick<Awaited<ReturnType<GenerateFn>>, 'id' | 'usage' | 'finishReason' | 'rawFinishReason'>,
+  meta: Pick<
+    Awaited<ReturnType<GenerateFn>>,
+    'id' | 'usage' | 'finishReason' | 'rawFinishReason' | 'traceId'
+  >,
 ): StreamedMessage {
   return {
     id: meta.id,
     usage: meta.usage,
     finishReason: meta.finishReason ?? null,
     rawFinishReason: meta.rawFinishReason ?? null,
+    traceId: meta.traceId ?? null,
     async *[Symbol.asyncIterator]() {
       for (const part of parts) {
         yield structuredClone(part);
@@ -2540,16 +2565,16 @@ function writeLog(
   logger[level](message, mergedPayload);
 }
 
-function cloneRecord<T extends PersistedWireRecord>(event: T): T {
+function cloneRecord<T extends WireRecord>(event: T): T {
   return structuredClone(event);
 }
 
-function withMetadata(events: readonly PersistedWireRecord[]): readonly PersistedWireRecord[] {
+function withMetadata(events: readonly WireRecord[]): readonly WireRecord[] {
   if (events.length === 0 || events[0]?.type === 'metadata') return events;
   return [
     {
       type: 'metadata',
-      protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+      protocol_version: WIRE_PROTOCOL_VERSION,
       created_at: 1,
     },
     ...events,
diff --git a/packages/agent-core-v2/test/harness/scripted-generate.ts b/packages/agent-core-v2/test/harness/scripted-generate.ts
index 12751ff43..552c99d6f 100644
--- a/packages/agent-core-v2/test/harness/scripted-generate.ts
+++ b/packages/agent-core-v2/test/harness/scripted-generate.ts
@@ -16,6 +16,7 @@ interface ScriptedResponse {
   readonly parts: readonly StreamedMessagePart[];
   readonly finishReason?: FinishReason | null | undefined;
   readonly rawFinishReason?: string | null | undefined;
+  readonly traceId?: string | null | undefined;
 }
 
 export function createScriptedGenerate() {
@@ -31,11 +32,13 @@ export function createScriptedGenerate() {
     readonly parts?: readonly StreamedMessagePart[] | undefined;
     readonly finishReason?: FinishReason | null | undefined;
     readonly rawFinishReason?: string | null | undefined;
+    readonly traceId?: string | null | undefined;
   }) {
     responses.push({
       parts: structuredClone(input.parts ?? []),
       ...(input.finishReason !== undefined ? { finishReason: input.finishReason } : {}),
       ...(input.rawFinishReason !== undefined ? { rawFinishReason: input.rawFinishReason } : {}),
+      ...(input.traceId !== undefined ? { traceId: input.traceId } : {}),
     });
   }
 
@@ -47,6 +50,7 @@ export function createScriptedGenerate() {
     if (response === undefined) {
       throw new Error(`Unexpected generate call #${String(calls.length + 1)}`);
     }
+    options?.onTraceId?.(response.traceId ?? null);
 
     const input = normalizeGenerateInput({
       systemPrompt,
@@ -86,6 +90,7 @@ export function createScriptedGenerate() {
       },
       finishReason,
       rawFinishReason: response.rawFinishReason ?? defaultRawFinishReason(finishReason),
+      traceId: response.traceId ?? null,
     };
   };
 
diff --git a/packages/agent-core-v2/test/harness/snapshots.ts b/packages/agent-core-v2/test/harness/snapshots.ts
index 4a4f732d9..f14b43d4b 100644
--- a/packages/agent-core-v2/test/harness/snapshots.ts
+++ b/packages/agent-core-v2/test/harness/snapshots.ts
@@ -2,7 +2,7 @@ import type { Message } from '#/app/llmProtocol/message';
 import type { Tool as LLMTool } from '#/app/llmProtocol/tool';
 import { expect } from 'vitest';
 
-import { AGENT_WIRE_PROTOCOL_VERSION } from '#/agent/wireRecord/migration/migration';
+import { WIRE_PROTOCOL_VERSION } from '#/wire/migration/migration';
 
 const IS_EVENT_ARRAY = Symbol('isEventArray');
 const IS_GENERATE_INPUT_SNAPSHOT = Symbol('isGenerateInputSnapshot');
@@ -282,9 +282,14 @@ function normalizeValue(value: unknown, labels: SnapshotLabels): unknown {
 }
 
 function normalizeObjectField(key: string, value: unknown, labels: SnapshotLabels): unknown {
-  if ((key === 'time' || key === 'created_at') && typeof value === 'number') return '<time>';
+  if (
+    (key === 'time' || key === 'created_at' || key === 'since' || key === 'at') &&
+    typeof value === 'number'
+  ) {
+    return '<time>';
+  }
   if ((key === 'finishedAt' || key === 'abortedAt' || key === 'steeredAt') && typeof value === 'string') return '<time>';
-  if (key === 'protocol_version' && value === AGENT_WIRE_PROTOCOL_VERSION) {
+  if (key === 'protocol_version' && value === WIRE_PROTOCOL_VERSION) {
     return '<protocol-version>';
   }
   if (key === 'cwd' && typeof value === 'string') return '<cwd>';
diff --git a/packages/agent-core-v2/test/index.test.ts b/packages/agent-core-v2/test/index.test.ts
index 503cdce8d..b01adf1c1 100644
--- a/packages/agent-core-v2/test/index.test.ts
+++ b/packages/agent-core-v2/test/index.test.ts
@@ -1,12 +1,12 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import {
-  AGENT_WIRE_PROTOCOL_VERSION,
+  WIRE_PROTOCOL_VERSION,
   IAgentContextMemoryService,
   IAgentContextSizeService,
   IAgentGoalService,
   type ContextMessage,
-  type PersistedWireRecord,
+  type WireRecord,
 } from '#/index';
 import {
   InMemoryWireRecordPersistence,
@@ -17,18 +17,15 @@ import {
 import { SyncDescriptor } from '#/_base/di/descriptors';
 import { DisposableStore } from '#/_base/di/lifecycle';
 import { TestInstantiationService } from '#/_base/di/test';
-import { setRuntimePhase } from '#/agent/runtime/runtimeOps';
-import { contextAppendMessage } from '#/agent/contextMemory/contextOps';
-import { wireMetadata } from '#/agent/wireRecord/metadataOps';
 import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { todoSet, TodoModel } from '#/session/todo/todoOps';
 import { OP_REGISTRY } from '#/wire/op';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY } from '#/wire/record';
+import { registerTestAgentWire, restoreTestAgentWire } from './wire/stubs';
 
 const V1_RECORD_TYPES: ReadonlySet<string> = new Set([
   'metadata',
@@ -73,10 +70,9 @@ const V1_RECORD_TYPES: ReadonlySet<string> = new Set([
 
 describe('v1 wire vocabulary', () => {
   const SCOPE = 'wire';
-  const KEY = 'v1-vocabulary-test';
 
   let disposables: DisposableStore;
-  let wire: WireService;
+  let wire: IWireService;
   let log: IAppendLogStore;
 
   beforeEach(() => {
@@ -84,17 +80,16 @@ describe('v1 wire vocabulary', () => {
     const ix = disposables.add(new TestInstantiationService());
     ix.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: KEY }]));
-    wire = ix.get(IAgentWireService) as WireService;
     log = ix.get(IAppendLogStore);
+    wire = registerTestAgentWire(ix, SCOPE, { log });
   });
 
   afterEach(() => disposables.dispose());
 
-  async function readRecords(): Promise<PersistedRecord[]> {
+  async function readRecords(): Promise<WireRecord[]> {
     await wire.flush();
-    const out: PersistedRecord[] = [];
-    for await (const record of log.read<PersistedRecord>(SCOPE, KEY)) {
+    const out: WireRecord[] = [];
+    for await (const record of log.read<WireRecord>(SCOPE, AGENT_WIRE_RECORD_KEY)) {
       out.push(record);
     }
     return out;
@@ -108,12 +103,16 @@ describe('v1 wire vocabulary', () => {
   });
 
   it('stamps persisted records with time, except the metadata envelope', async () => {
-    wire.dispatch(wireMetadata({ protocol_version: '1.4', created_at: 123 }));
+    await wire.restore();
     wire.dispatch(todoSet({ key: 'todo', value: [{ title: 'x', status: 'pending' }] }));
 
     const records = await readRecords();
     expect(records).toEqual([
-      { type: 'metadata', protocol_version: '1.4', created_at: 123 },
+      {
+        type: 'metadata',
+        protocol_version: WIRE_PROTOCOL_VERSION,
+        created_at: expect.any(Number),
+      },
       {
         type: 'tools.update_store',
         key: 'todo',
@@ -123,20 +122,6 @@ describe('v1 wire vocabulary', () => {
     ]);
   });
 
-  it('never persists nor emits persist:false ops, but still applies them', async () => {
-    const emissions: PersistedRecord[] = [];
-    disposables.add(wire.onEmission((e) => emissions.push(e.record)));
-
-    wire.dispatch(
-      setRuntimePhase({
-        phase: { kind: 'running', turnId: 0, step: 1, stepId: 's-1', since: Date.now() },
-      }),
-    );
-
-    expect(await readRecords()).toEqual([]);
-    expect(emissions).toEqual([]);
-  });
-
   it('round-trips the todo list through the persisted tools.update_store record', async () => {
     wire.dispatch(
       todoSet({ key: 'todo', value: [{ title: 'restore me', status: 'in_progress' }] }),
@@ -148,13 +133,10 @@ describe('v1 wire vocabulary', () => {
     const ix2 = store.add(new TestInstantiationService());
     ix2.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix2.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix2.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: 'todo-roundtrip' }]),
-    );
-    const fresh = ix2.get(IAgentWireService);
+    const log2 = ix2.get(IAppendLogStore);
+    const fresh = registerTestAgentWire(ix2, SCOPE, { log: log2 });
 
-    await fresh.replay(...records);
+    await restoreTestAgentWire(fresh, log2, SCOPE, records);
 
     expect(fresh.getModel(TodoModel)).toEqual([{ title: 'restore me', status: 'in_progress' }]);
   });
@@ -208,7 +190,7 @@ describe('AgentRecords persistence metadata', () => {
     ]);
     expect(persistence.records[0]).toMatchObject({
       type: 'metadata',
-      protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+      protocol_version: WIRE_PROTOCOL_VERSION,
     });
     // And the orphaned message landed in the restored context.
     expect(ctx.context.get()).toHaveLength(1);
@@ -218,7 +200,7 @@ describe('AgentRecords persistence metadata', () => {
     persistence.records.push(
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
       },
       {
@@ -261,7 +243,7 @@ describe('AgentRecords persistence metadata', () => {
             },
           ],
         },
-      } as unknown as PersistedWireRecord,
+      } as unknown as WireRecord,
     );
 
     await ctx.restorePersisted();
@@ -269,7 +251,7 @@ describe('AgentRecords persistence metadata', () => {
     expect(persistence.rewrites).toHaveLength(1);
     expect(persistence.records[0]).toMatchObject({
       type: 'metadata',
-      protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+      protocol_version: WIRE_PROTOCOL_VERSION,
     });
     const migrated = persistence.records[1] as unknown as {
       readonly message: {
@@ -284,7 +266,7 @@ describe('AgentRecords persistence metadata', () => {
     expect(migrated.message.toolCalls[0]?.['function']).toBeUndefined();
   });
 
-  it('warns but continues when replaying records from a newer wire version', async () => {
+  it('replays a newer wire version without rewriting its metadata', async () => {
     persistence.records.push(
       {
         type: 'metadata',
@@ -293,9 +275,11 @@ describe('AgentRecords persistence metadata', () => {
       },
     );
 
-    const result = await ctx.restorePersisted();
-    expect(result.warning).toContain('9.9');
-    expect(result.warning).toContain(AGENT_WIRE_PROTOCOL_VERSION);
+    await expect(ctx.restorePersisted()).resolves.toBeUndefined();
+    expect(persistence.records[0]).toMatchObject({
+      type: 'metadata',
+      protocol_version: '9.9',
+    });
   });
 
   it('rejects replaying records without a registered migration path', async () => {
@@ -313,7 +297,7 @@ describe('AgentRecords persistence metadata', () => {
 
   it('restores goal.* records during replay', async () => {
     persistence.records.push(
-      { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
+      { type: 'metadata', protocol_version: WIRE_PROTOCOL_VERSION, created_at: 1 },
       {
         type: 'goal.create',
         goalId: 'g1',
@@ -326,7 +310,7 @@ describe('AgentRecords persistence metadata', () => {
       { type: 'goal.update', status: 'blocked', reason: 'needs credentials', actor: 'model' },
     );
 
-    await expect(ctx.restorePersisted()).resolves.toEqual({});
+    await expect(ctx.restorePersisted()).resolves.toBeUndefined();
     expect(context.get()).toHaveLength(0);
     expect(ctx.get(IAgentGoalService).getGoal().goal).toMatchObject({
       goalId: 'g1',
@@ -341,7 +325,7 @@ describe('AgentRecords persistence metadata', () => {
 
   it('restores forked records as fork boundaries that clear copied goals', async () => {
     persistence.records.push(
-      { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
+      { type: 'metadata', protocol_version: WIRE_PROTOCOL_VERSION, created_at: 1 },
       {
         type: 'goal.create',
         goalId: 'source-goal',
@@ -350,7 +334,7 @@ describe('AgentRecords persistence metadata', () => {
       { type: 'forked', time: 2 },
     );
 
-    await expect(ctx.restorePersisted()).resolves.toEqual({});
+    await expect(ctx.restorePersisted()).resolves.toBeUndefined();
     expect(persistence.records.slice(0, 3).map((record) => record.type)).toEqual([
       'metadata',
       'goal.create',
@@ -364,7 +348,7 @@ describe('AgentRecords persistence metadata', () => {
 
   it('keeps goals created after the forked boundary', async () => {
     persistence.records.push(
-      { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
+      { type: 'metadata', protocol_version: WIRE_PROTOCOL_VERSION, created_at: 1 },
       {
         type: 'goal.create',
         goalId: 'source-goal',
@@ -378,7 +362,7 @@ describe('AgentRecords persistence metadata', () => {
       },
     );
 
-    await expect(ctx.restorePersisted()).resolves.toEqual({});
+    await expect(ctx.restorePersisted()).resolves.toBeUndefined();
     expect(ctx.get(IAgentGoalService).getGoal().goal).toMatchObject({
       goalId: 'fork-goal',
       objective: 'fork work',
@@ -391,17 +375,17 @@ describe('AgentRecords persistence metadata', () => {
 
   it('does not add a fork-cleared reminder when a forked record has no copied goal', async () => {
     persistence.records.push(
-      { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
+      { type: 'metadata', protocol_version: WIRE_PROTOCOL_VERSION, created_at: 1 },
       { type: 'forked', time: 2 },
     );
 
-    await expect(ctx.restorePersisted()).resolves.toEqual({});
+    await expect(ctx.restorePersisted()).resolves.toBeUndefined();
     expect(context.get()).toHaveLength(0);
   });
 
   it('preconstructs context size restore handlers during runtime activation', async () => {
     await ctx.restore([
-      { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
+      { type: 'metadata', protocol_version: WIRE_PROTOCOL_VERSION, created_at: 1 },
       {
         type: 'context.append_message',
         message: {
@@ -437,51 +421,13 @@ describe('AgentRecords persistence metadata', () => {
   });
 });
 
-describe('IAgentWireRecordService.records()', () => {
-  it('returns restored records in order, excluding metadata', async () => {
-    const persistence = new InMemoryWireRecordPersistence([
-      { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
-      { type: 'context.append_message', message: userMessage('restored') },
-    ]);
-    const records = createTestAgent({ persistence, autoConfigure: false }).wireRecord;
-    await records.restore();
-
-    const snapshot = records.getRecords();
-    const types = snapshot
-      .map((record) => record.type)
-      .filter((type) => type !== 'config.update');
-    expect(types).toEqual(['context.append_message']);
-    const lengthBefore = records.getRecords().length;
-    (snapshot as unknown as PersistedWireRecord[]).pop();
-    expect(records.getRecords()).toHaveLength(lengthBefore);
-  });
-
-  it('appends live-dispatched records after the restored journal', async () => {
-    const persistence = new InMemoryWireRecordPersistence([
-      { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
-      { type: 'context.append_message', message: userMessage('restored') },
-    ]);
-    const ctx = createTestAgent({ persistence, autoConfigure: false });
-    await ctx.wireRecord.restore();
-    const restoredLength = ctx.wireRecord.getRecords().length;
-
-    ctx.get(IAgentWireService).dispatch(contextAppendMessage({ message: userMessage('live') }));
-
-    const after = ctx.wireRecord.getRecords();
-    expect(after).toHaveLength(restoredLength + 1);
-    const last = after[after.length - 1] as { type: string; message?: ContextMessage };
-    expect(last.type).toBe('context.append_message');
-    expect(last.message?.content[0]).toEqual({ type: 'text', text: 'live' });
-  });
-});
-
 describe.skip('agent replay range build', () => {
 });
 
 class RecordingInMemoryWireRecordPersistence extends InMemoryWireRecordPersistence {
-  readonly rewrites: PersistedWireRecord[][] = [];
+  readonly rewrites: WireRecord[][] = [];
 
-  override rewrite(records: readonly PersistedWireRecord[]): void {
+  override rewrite(records: readonly WireRecord[]): void {
     this.rewrites.push([...records]);
     super.rewrite(records);
   }
diff --git a/packages/agent-core-v2/test/os/backends/node-local/tools/bash.test.ts b/packages/agent-core-v2/test/os/backends/node-local/tools/bash.test.ts
index dac7067db..6994c01cc 100644
--- a/packages/agent-core-v2/test/os/backends/node-local/tools/bash.test.ts
+++ b/packages/agent-core-v2/test/os/backends/node-local/tools/bash.test.ts
@@ -28,6 +28,7 @@ import {
   type RegisterAgentTaskOptions,
 } from '#/agent/task/task';
 import type { AgentTaskSettlement } from '#/agent/task/types';
+import { userCancellationReason } from '#/_base/utils/abort';
 import type { IConfigService } from '#/app/config/config';
 import { ProcessTask } from '#/os/backends/node-local/tools/process-task';
 import type { IHostEnvironment } from '#/os/interface/hostEnvironment';
@@ -313,7 +314,6 @@ const TERMINAL_STATUSES: ReadonlySet<AgentTaskStatus> = new Set([
   'lost',
 ]);
 const SIGTERM_GRACE_MS = 5_000;
-const USER_INTERRUPT_REASON = 'Interrupted by user';
 const TASK_ID_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
 
 interface ForegroundRelease {
@@ -542,7 +542,7 @@ function createFakeTaskService(options: { maxRunningTasks?: number } = {}): {
         const signal = registerOptions.signal;
         const abortFromSignal = (): void => {
           if (entry.foregroundRelease === undefined) return;
-          void stopEntry(entry, USER_INTERRUPT_REASON);
+          void stopEntry(entry, userCancellationReason().message);
         };
         if (signal.aborted) {
           abortFromSignal();
@@ -612,6 +612,10 @@ function createFakeTaskService(options: { maxRunningTasks?: number } = {}): {
       return stopEntry(entry, reason);
     },
 
+    async stopByUser(taskId: string): Promise<AgentTaskInfo | undefined> {
+      return service.stop(taskId, userCancellationReason().message);
+    },
+
     async stopAll(reason?: string): Promise<readonly AgentTaskInfo[]> {
       const results = await Promise.all(
         Array.from(tasks.keys()).map((taskId) => service.stop(taskId, reason)),
@@ -823,7 +827,6 @@ describe('BashTool', () => {
     expect(result).toMatchObject({
       output: 'ok\n',
       isError: false,
-      message: 'Command executed successfully.',
     });
   });
 
@@ -863,7 +866,6 @@ describe('BashTool', () => {
     expect(result).toMatchObject({
       output: 'ok\n',
       isError: false,
-      message: 'Command executed successfully.',
     });
   });
 
@@ -875,7 +877,6 @@ describe('BashTool', () => {
 
     expect(result).toMatchObject({
       isError: true,
-      message: 'Command failed with exit code: 2.',
       brief: 'Failed with exit code: 2',
     });
     expect(result.output).toContain('boom\n');
@@ -891,7 +892,6 @@ describe('BashTool', () => {
     expect(result).toMatchObject({
       output: 'out\nwarn\n',
       isError: false,
-      message: 'Command executed successfully.',
     });
   });
 
@@ -905,7 +905,6 @@ describe('BashTool', () => {
 
     expect(result).toMatchObject({
       isError: true,
-      message: 'Command failed with exit code: 2.',
       brief: 'Failed with exit code: 2',
     });
     expect(result.output).toContain('partial\nboom\n');
@@ -928,7 +927,6 @@ describe('BashTool', () => {
 
     expect(result).toMatchObject({
       isError: true,
-      message: 'wait failed',
       brief: 'wait failed',
     });
     expect(result.output).toContain('partial output\nwait failed');
@@ -953,7 +951,6 @@ describe('BashTool', () => {
       expect(result).toMatchObject({
         isError: false,
         output: 'err-first\nout-second\nerr-third\n',
-        message: 'Command executed successfully.',
       });
     } finally {
       vi.useRealTimers();
@@ -986,7 +983,6 @@ describe('BashTool', () => {
       expect(proc.kill).not.toHaveBeenCalled();
       expect(result).toMatchObject({
         isError: false,
-        message: expect.stringContaining('timed out and moved to background'),
       });
       expect(result.output).toContain('task_id: bash-');
       resolveWait(0);
@@ -1120,7 +1116,6 @@ describe('BashTool', () => {
 
     expect(result.output).toContain('[...truncated]');
     expect(result.output).toContain('Output is truncated');
-    expect((result as { message?: string }).message).toContain('Output is truncated');
   });
 
   it('marks the truncated output buffer with a "[...truncated]" sentinel at the cut point', async () => {
@@ -1330,7 +1325,6 @@ describe('BashTool background mode', () => {
     expect(result.output).toContain(`task_id: ${task.taskId}`);
     expect(result.output).toContain('automatic_notification: true');
     expect(result.output).toContain('do NOT wait, poll, or call TaskOutput');
-    expect(result).toMatchObject({ message: 'Task moved to background.' });
     expect((result as { brief?: string }).brief).toBe(`Backgrounded ${task.taskId}`);
     expect(service.getTask(task.taskId)).toMatchObject({ detached: true });
     await vi.waitFor(async () => {
@@ -1404,7 +1398,6 @@ describe('BashTool background mode', () => {
       expect(proc.kill).not.toHaveBeenCalled();
       expect(result).toMatchObject({
         isError: false,
-        message: expect.stringContaining('timed out and moved to background'),
         brief: expect.stringContaining('after timeout'),
       });
       const taskId = /^task_id: (\S+)/m.exec(result.output as string)?.[1];
@@ -1532,7 +1525,6 @@ describe('BashTool background mode', () => {
 
     expect(result.output).toMatch(/task_id: bash-[0-9a-z]{8}/);
     expect(result.output).toContain('automatic_notification: true');
-    expect(result).toMatchObject({ message: 'Background task started.' });
     expect((result as { brief?: string }).brief).toMatch(/^Started bash-[0-9a-z]{8}$/);
     expect(result.output).toContain('do NOT wait, poll, or call TaskOutput on it');
     expect(result.output).not.toContain('block=false');
diff --git a/packages/agent-core-v2/test/os/backends/node-local/tools/grep.test.ts b/packages/agent-core-v2/test/os/backends/node-local/tools/grep.test.ts
index a6d89464c..b5c69f2a9 100644
--- a/packages/agent-core-v2/test/os/backends/node-local/tools/grep.test.ts
+++ b/packages/agent-core-v2/test/os/backends/node-local/tools/grep.test.ts
@@ -142,6 +142,7 @@ function createTestFs(kaos: FakeKaos): IHostFileSystem {
     readdir: () => notImplemented('readdir'),
     mkdir: () => notImplemented('mkdir'),
     remove: () => notImplemented('remove'),
+    realpath: () => notImplemented('realpath'),
   };
 }
 
@@ -1745,7 +1746,6 @@ describe('GrepTool', () => {
     expect(dataLines).toHaveLength(3);
     expect(output).toContain('Found 30 total occurrences across 10 files.');
     expect(output).toContain('Results truncated to 3 lines (total: 10). Use offset=3 to see more.');
-    expect((result as { message?: string }).message ?? '').not.toContain('Found');
   });
 
   it('truncates extremely long rg output with a byte-level safety cap message', async () => {
@@ -1758,9 +1758,7 @@ describe('GrepTool', () => {
       context({ pattern: 'match', output_mode: 'content', head_limit: 0 }),
     );
 
-    const message = (result as { message?: unknown }).message;
-    expect(typeof message).toBe('string');
-    expect(message).toContain('Output is truncated');
+    expect(result.output).toContain('Output is truncated');
   });
 
   it('matches a pattern spanning a newline when multiline is set', async () => {
diff --git a/packages/agent-core-v2/test/replayBuilder/replayProjection.test.ts b/packages/agent-core-v2/test/replayBuilder/replayProjection.test.ts
deleted file mode 100644
index 2bd844f50..000000000
--- a/packages/agent-core-v2/test/replayBuilder/replayProjection.test.ts
+++ /dev/null
@@ -1,316 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { projectReplayTimeline } from '#/agent/replayBuilder/replayProjection';
-import type { ReplayTimeline } from '#/agent/replayBuilder/replayTimelineModel';
-
-/** Test entries are partial payloads cast into the op-native timeline shape. */
-function timeline(entries: readonly unknown[]): ReplayTimeline {
-  return entries as ReplayTimeline;
-}
-
-function userEntry(text: string): unknown {
-  return {
-    type: 'context.append_message',
-    payload: { message: { role: 'user', content: [{ type: 'text', text }], toolCalls: [] } },
-  };
-}
-
-function loopEntry(event: Record<string, unknown>): unknown {
-  return { type: 'context.append_loop_event', payload: { event } };
-}
-
-describe('projectReplayTimeline', () => {
-  it('projects message and plan ops to v1-shaped replay records', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        {
-          type: 'context.append_message',
-          payload: {
-            message: { role: 'user', content: [{ type: 'text', text: 'hi' }], toolCalls: [] },
-          },
-        },
-        { type: 'plan_mode.enter', payload: { id: 'p1' } },
-        { type: 'plan_mode.exit', payload: { id: 'p1' } },
-      ]),
-    );
-    expect(records).toEqual([
-      expect.objectContaining({ type: 'message', message: expect.objectContaining({ role: 'user' }) }),
-      expect.objectContaining({ type: 'plan_updated', enabled: true }),
-      expect.objectContaining({ type: 'plan_updated', enabled: false }),
-    ]);
-  });
-
-  it('folds goal ops into per-record snapshots and change records', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        { type: 'goal.create', payload: { goalId: 'g1', objective: 'ship it' } },
-        { type: 'goal.update', payload: { status: 'paused', reason: 'wait' } },
-        { type: 'goal.update', payload: { turnsUsed: 3 } },
-        { type: 'goal.update', payload: { status: 'complete', reason: 'done' } },
-      ]),
-    );
-    // The counter-only update (turnsUsed) is not a transcript event.
-    expect(records).toHaveLength(3);
-    expect(records[0]).toMatchObject({
-      type: 'goal_updated',
-      change: { kind: 'created' },
-      snapshot: { goalId: 'g1', objective: 'ship it', status: 'active' },
-    });
-    expect(records[1]).toMatchObject({
-      type: 'goal_updated',
-      change: { kind: 'lifecycle', status: 'paused', reason: 'wait' },
-      snapshot: { status: 'paused' },
-    });
-    expect(records[2]).toMatchObject({
-      type: 'goal_updated',
-      change: { kind: 'completion', status: 'complete', stats: { turnsUsed: 3 } },
-      snapshot: { status: 'complete', turnsUsed: 3 },
-    });
-  });
-
-  it('drops goal state on clear so later updates produce no records', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        { type: 'goal.create', payload: { goalId: 'g1', objective: 'x' } },
-        { type: 'goal.clear', payload: {} },
-        { type: 'goal.update', payload: { status: 'paused' } },
-      ]),
-    );
-    expect(records).toHaveLength(1);
-    expect(records[0]).toMatchObject({ change: { kind: 'created' } });
-  });
-
-  it('projects compaction ops into begin/result/cancelled records', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        { type: 'full_compaction.begin', payload: { instruction: 'keep facts', source: 'manual' } },
-        {
-          type: 'context.apply_compaction',
-          payload: { summary: 'condensed', compactedCount: 4, tokensBefore: 1000, tokensAfter: 200 },
-        },
-        { type: 'full_compaction.complete', payload: {} },
-        { type: 'full_compaction.cancel', payload: {} },
-      ]),
-    );
-    expect(records).toEqual([
-      expect.objectContaining({ type: 'compaction', instruction: 'keep facts' }),
-      expect.objectContaining({
-        type: 'compaction',
-        result: expect.objectContaining({
-          summary: 'condensed',
-          compactedCount: 4,
-          tokensBefore: 1000,
-          tokensAfter: 200,
-        }),
-      }),
-      expect.objectContaining({ type: 'compaction', result: 'cancelled' }),
-    ]);
-  });
-
-  it('projects permission, approval, and config ops', () => {
-    const approval = { toolCallId: 't1', toolName: 'Bash', action: 'run', result: { decision: 'approved' } };
-    const records = projectReplayTimeline(
-      timeline([
-        { type: 'permission.set_mode', payload: { mode: 'yolo' } },
-        { type: 'permission.record_approval_result', payload: approval },
-        { type: 'config.update', payload: { modelAlias: 'k2' } },
-      ]),
-    );
-    expect(records).toEqual([
-      expect.objectContaining({ type: 'permission_updated', mode: 'yolo' }),
-      expect.objectContaining({ type: 'approval_result', record: approval }),
-      expect.objectContaining({ type: 'config_updated', config: { modelAlias: 'k2' } }),
-    ]);
-  });
-
-  it('folds loop events into assistant and tool message records in stream order', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        userEntry('hi'),
-        loopEntry({ type: 'step.begin', uuid: 's1' }),
-        loopEntry({ type: 'content.part', stepUuid: 's1', part: { type: 'text', text: 'hello ' } }),
-        loopEntry({ type: 'content.part', stepUuid: 's1', part: { type: 'text', text: 'world' } }),
-        loopEntry({ type: 'tool.call', stepUuid: 's1', toolCallId: 'tc1', name: 'Bash', args: { command: 'ls' } }),
-        loopEntry({ type: 'step.end', uuid: 's1' }),
-        loopEntry({ type: 'tool.result', toolCallId: 'tc1', result: { output: 'file.txt' } }),
-        loopEntry({ type: 'step.begin', uuid: 's2' }),
-        loopEntry({ type: 'content.part', stepUuid: 's2', part: { type: 'text', text: 'done' } }),
-        loopEntry({ type: 'step.end', uuid: 's2' }),
-      ]),
-    );
-    expect(records).toEqual([
-      expect.objectContaining({ type: 'message', message: expect.objectContaining({ role: 'user' }) }),
-      expect.objectContaining({
-        type: 'message',
-        message: {
-          role: 'assistant',
-          content: [
-            { type: 'text', text: 'hello ' },
-            { type: 'text', text: 'world' },
-          ],
-          toolCalls: [
-            { type: 'function', id: 'tc1', name: 'Bash', arguments: '{"command":"ls"}' },
-          ],
-        },
-      }),
-      expect.objectContaining({
-        type: 'message',
-        message: expect.objectContaining({
-          role: 'tool',
-          toolCallId: 'tc1',
-          content: [{ type: 'text', text: 'file.txt' }],
-        }),
-      }),
-      expect.objectContaining({
-        type: 'message',
-        message: {
-          role: 'assistant',
-          content: [{ type: 'text', text: 'done' }],
-          toolCalls: [],
-        },
-      }),
-    ]);
-  });
-
-  it('defers user messages while a tool exchange is open and flushes after it closes', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        userEntry('first'),
-        loopEntry({ type: 'step.begin', uuid: 's1' }),
-        loopEntry({ type: 'tool.call', stepUuid: 's1', toolCallId: 'tc1', name: 'Bash' }),
-        loopEntry({ type: 'step.end', uuid: 's1' }),
-        userEntry('second'),
-        loopEntry({ type: 'tool.result', toolCallId: 'tc1', result: { output: 'ok' } }),
-      ]),
-    );
-    expect(
-      records.map((record) => ('message' in record ? record.message.role : record.type)),
-    ).toEqual(['user', 'assistant', 'tool', 'user']);
-    expect(records[3]).toMatchObject({
-      message: { content: [{ type: 'text', text: 'second' }] },
-    });
-  });
-
-  it('closes a trailing interrupted exchange with synthetic tool results', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        userEntry('hi'),
-        loopEntry({ type: 'step.begin', uuid: 's1' }),
-        loopEntry({ type: 'content.part', stepUuid: 's1', part: { type: 'text', text: 'partial' } }),
-        loopEntry({ type: 'tool.call', stepUuid: 's1', toolCallId: 'tc1', name: 'Bash' }),
-      ]),
-    );
-    expect(records).toEqual([
-      expect.objectContaining({ type: 'message', message: expect.objectContaining({ role: 'user' }) }),
-      expect.objectContaining({
-        type: 'message',
-        message: expect.objectContaining({
-          role: 'assistant',
-          content: [{ type: 'text', text: 'partial' }],
-          toolCalls: [expect.objectContaining({ id: 'tc1' })],
-        }),
-      }),
-      expect.objectContaining({
-        type: 'message',
-        message: expect.objectContaining({
-          role: 'tool',
-          toolCallId: 'tc1',
-          isError: true,
-        }),
-      }),
-    ]);
-  });
-
-  it('closes a mid-history tool gap at the next step boundary', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        loopEntry({ type: 'step.begin', uuid: 's1' }),
-        loopEntry({ type: 'tool.call', stepUuid: 's1', toolCallId: 'tc1', name: 'Bash' }),
-        loopEntry({ type: 'step.end', uuid: 's1' }),
-        loopEntry({ type: 'step.begin', uuid: 's2' }),
-        loopEntry({ type: 'content.part', stepUuid: 's2', part: { type: 'text', text: 'recovered' } }),
-        loopEntry({ type: 'step.end', uuid: 's2' }),
-        loopEntry({ type: 'tool.result', toolCallId: 'tc1', result: { output: 'late' } }),
-      ]),
-    );
-    expect(
-      records.map((record) =>
-        'message' in record ? [record.message.role, record.message.toolCallId] : [record.type],
-      ),
-    ).toEqual([
-      ['assistant', undefined],
-      ['tool', 'tc1'],
-      ['assistant', undefined],
-    ]);
-    // The gap-closing result is the synthetic interrupted one; the stale late
-    // result is dropped, so no second `tc1` record appears.
-    expect(records[1]).toMatchObject({ message: { isError: true } });
-  });
-
-  it('pairs a tool result with a call that arrived outside an open step', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        loopEntry({ type: 'tool.call', stepUuid: 's0', toolCallId: 'tc1', name: 'Bash', args: { command: 'ls' } }),
-        loopEntry({ type: 'tool.result', toolCallId: 'tc1', result: { output: 'file.txt' } }),
-      ]),
-    );
-    // Live fold marks the call pending even with no open assistant, so the
-    // result still produces a tool message on resume.
-    expect(records).toEqual([
-      expect.objectContaining({
-        type: 'message',
-        message: expect.objectContaining({ role: 'tool', toolCallId: 'tc1' }),
-      }),
-    ]);
-  });
-
-  it('keeps buffering the open step assistant across a compaction reset', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        loopEntry({ type: 'step.begin', uuid: 's1' }),
-        loopEntry({ type: 'content.part', stepUuid: 's1', part: { type: 'text', text: 'before ' } }),
-        { type: 'context.apply_compaction', payload: { summary: 'condensed', compactedCount: 3 } },
-        loopEntry({ type: 'content.part', stepUuid: 's1', part: { type: 'text', text: 'after' } }),
-        loopEntry({ type: 'step.end', uuid: 's1' }),
-      ]),
-    );
-    expect(records).toEqual([
-      expect.objectContaining({ type: 'compaction' }),
-      expect.objectContaining({
-        type: 'message',
-        message: {
-          role: 'assistant',
-          content: [
-            { type: 'text', text: 'before ' },
-            { type: 'text', text: 'after' },
-          ],
-          toolCalls: [],
-        },
-      }),
-    ]);
-  });
-
-  it('forgets pending calls at a compaction reset without synthesizing interrupted results', () => {
-    const records = projectReplayTimeline(
-      timeline([
-        loopEntry({ type: 'step.begin', uuid: 's1' }),
-        loopEntry({ type: 'tool.call', stepUuid: 's1', toolCallId: 'tc1', name: 'Bash' }),
-        { type: 'context.apply_compaction', payload: { summary: 'condensed', compactedCount: 3 } },
-        loopEntry({ type: 'tool.result', toolCallId: 'tc1', result: { output: 'late' } }),
-        loopEntry({ type: 'step.end', uuid: 's1' }),
-      ]),
-    );
-    // The late result pairs with nothing (live `resetFold` forgets pending the
-    // same way); the assistant keeps the dangling call.
-    expect(records).toEqual([
-      expect.objectContaining({ type: 'compaction' }),
-      expect.objectContaining({
-        type: 'message',
-        message: expect.objectContaining({
-          role: 'assistant',
-          toolCalls: [expect.objectContaining({ id: 'tc1' })],
-        }),
-      }),
-    ]);
-  });
-});
diff --git a/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts b/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts
index 48ff1fb30..6cced97a0 100644
--- a/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts
+++ b/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts
@@ -10,7 +10,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { SyncDescriptor } from '#/_base/di/descriptors';
-import { DisposableStore } from '#/_base/di/lifecycle';
+import { Disposable, DisposableStore } from '#/_base/di/lifecycle';
 import { type ISessionScopeHandle, LifecycleScope } from '#/_base/di/scope';
 import { TestInstantiationService } from '#/_base/di/test';
 import { Event } from '#/_base/event';
@@ -18,6 +18,7 @@ import { type McpServerConfig } from '#/agent/mcp/config-schema';
 import { IAgentMcpService } from '#/agent/mcp/mcp';
 import { McpConnectionManager } from '#/agent/mcp/connection-manager';
 import { IAgentPermissionModeService } from '#/agent/permissionMode/permissionMode';
+import '#/agent/permissionMode/permissionModeOps';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { AgentLifecycleService } from '#/session/agentLifecycle/agentLifecycleService';
 import { ensureMainAgent } from '#/session/agentLifecycle/mainAgent';
@@ -25,15 +26,15 @@ import { ISessionMcpService } from '#/session/mcp/sessionMcp';
 import { SessionMcpService } from '#/session/mcp/sessionMcpService';
 import { ISessionSubagentService } from '#/session/subagent/subagent';
 import { SessionSubagentService } from '#/session/subagent/subagentService';
-import '#/activity/agentActivityService';
 import '#/agent/mcp/mcpService';
-import '#/agent/wireRecord/agentWireService';
+import '#/wire/wireService';
 import { IAgentTaskService } from '#/agent/task/task';
 import { ISessionCronService } from '#/session/cron/sessionCronService';
 import '#/agent/toolDedupe/toolDedupeService';
-import { IAgentActivityService, ISessionActivityKernel } from '#/activity/activity';
+import { ISessionLifecycleService } from '#/app/sessionLifecycle/sessionLifecycle';
 import { IBootstrapService } from '#/app/bootstrap/bootstrap';
 import { IConfigService } from '#/app/config/config';
+import '#/app/event/eventBusService';
 import { IAgentBlobService } from '#/agent/blob/agentBlobService';
 import { IAgentPluginService } from '#/agent/plugin/agentPlugin';
 import { ILogService } from '#/_base/log/log';
@@ -42,9 +43,10 @@ import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IAtomicDocumentStore } from '#/persistence/interface/atomicDocumentStore';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import { ISessionMetadata } from '#/session/sessionMetadata/sessionMetadata';
-import { type PersistedWireRecord } from '#/agent/wireRecord/wireRecord';
+import { createWireMetadataRecord, type WireRecord } from '#/wire/record';
 import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
 import { IAgentLoopService } from '#/agent/loop/loop';
+import { IAgentFullCompactionService } from '#/agent/fullCompaction/fullCompaction';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { _clearToolContributionsForTests } from '#/agent/toolRegistry/toolContribution';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
@@ -52,8 +54,6 @@ import { IAgentMediaToolsRegistrar } from '#/agent/media/mediaTools';
 import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceContext';
 import type { OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
 
-import { stubSessionActivityKernel } from '../../activity/stubs';
-
 const noopLog = {
   _serviceBrand: undefined,
   level: 'off',
@@ -86,18 +86,18 @@ const pluginServiceStub = {
   enabledHooks: async () => [],
 } as unknown as IPluginService;
 
-function recordingAppendLog(initial: readonly PersistedWireRecord[] = []): {
-  readonly appended: PersistedWireRecord[];
+function recordingAppendLog(initial: readonly WireRecord[] = []): {
+  readonly appended: WireRecord[];
   readonly store: IAppendLogStore;
-  rewritten?: readonly PersistedWireRecord[];
+  rewritten?: readonly WireRecord[];
 } {
   const records = [...initial];
-  const appended: PersistedWireRecord[] = [];
-  const state: { rewritten?: readonly PersistedWireRecord[] } = {};
+  const appended: WireRecord[] = [];
+  const state: { rewritten?: readonly WireRecord[] } = {};
   const store: IAppendLogStore = {
     _serviceBrand: undefined,
     append: <R>(_scope: string, _key: string, record: R) => {
-      const persisted = record as unknown as PersistedWireRecord;
+      const persisted = record as unknown as WireRecord;
       records.push(persisted);
       appended.push(persisted);
     },
@@ -107,7 +107,7 @@ function recordingAppendLog(initial: readonly PersistedWireRecord[] = []): {
       }
     },
     rewrite: <R>(_scope: string, _key: string, next: readonly R[]) => {
-      const persisted = next as readonly PersistedWireRecord[];
+      const persisted = next as readonly WireRecord[];
       state.rewritten = persisted;
       records.splice(0, records.length, ...persisted);
       return Promise.resolve();
@@ -142,6 +142,10 @@ describe('AgentLifecycleService', () => {
   let atomicDocs: Map<string, unknown>;
   let permissionModeSetMode: ReturnType<typeof vi.fn>;
   let stopAllOnExit: ReturnType<typeof vi.fn>;
+  let loopActiveTurnId: number | undefined;
+  let loopPendingTurnIds: number[];
+  let loopCancel: ReturnType<typeof vi.fn<IAgentLoopService['cancel']>>;
+  let loopSettled: ReturnType<typeof vi.fn<IAgentLoopService['settled']>>;
   let beforeExecuteHookIds: string[];
   let didExecuteHookIds: string[];
 
@@ -150,7 +154,6 @@ describe('AgentLifecycleService', () => {
     disposables = new DisposableStore();
     ix = disposables.add(new TestInstantiationService());
     ix.stub(IAppendLogStore, recordingAppendLog().store);
-    ix.stub(ISessionActivityKernel, stubSessionActivityKernel());
     stubBlobPassThrough(ix);
     registerAgent = vi.fn<ISessionMetadata['registerAgent']>().mockResolvedValue(undefined);
     atomicDocs = new Map();
@@ -175,10 +178,10 @@ describe('AgentLifecycleService', () => {
       _serviceBrand: undefined,
       homeDir: '/tmp/kimi-agentLifecycle-home',
       cwd: '/tmp/kimi-agentLifecycle-home',
-      agentHomedir: (_ws: string, _session: string, agentId: string) =>
-        `/tmp/kimi-agentLifecycle-test/agents/${agentId}`,
       agentScope: (_ws: string, _session: string, agentId: string) =>
         `test/agents/${agentId}`,
+      agentHomedir: (workspaceId: string, sessionId: string, agentId: string) =>
+        `/tmp/kimi-agentLifecycle-home/sessions/${workspaceId}/${sessionId}/agents/${agentId}`,
     } as unknown as IBootstrapService);
     ix.stub(ISessionWorkspaceContext, {
       _serviceBrand: undefined,
@@ -240,6 +243,21 @@ describe('AgentLifecycleService', () => {
         },
       },
     } as unknown as IAgentToolExecutorService);
+    loopActiveTurnId = undefined;
+    loopPendingTurnIds = [];
+    loopCancel = vi.fn<IAgentLoopService['cancel']>((turnId) => {
+      if (turnId === undefined) {
+        loopActiveTurnId = undefined;
+      } else {
+        loopPendingTurnIds = loopPendingTurnIds.filter((id) => id !== turnId);
+      }
+      return true;
+    });
+    loopSettled = vi.fn<IAgentLoopService['settled']>(async () => {
+      if (loopActiveTurnId !== undefined || loopPendingTurnIds.length > 0) {
+        throw new Error('Agent loop did not settle');
+      }
+    });
     ix.stub(IAgentLoopService, {
       _serviceBrand: undefined,
       hooks: {
@@ -247,6 +265,14 @@ describe('AgentLifecycleService', () => {
         onDidFinishStep: { register: () => ({ dispose: () => {} }) },
       },
       registerLoopErrorHandler: () => ({ dispose: () => {} }),
+      status: () => ({
+        state: loopActiveTurnId === undefined ? 'idle' : 'running',
+        activeTurnId: loopActiveTurnId,
+        pendingTurnIds: loopPendingTurnIds,
+        hasPendingRequests: loopActiveTurnId !== undefined || loopPendingTurnIds.length > 0,
+      }),
+      cancel: loopCancel,
+      settled: loopSettled,
     } as unknown as IAgentLoopService);
     ix.stub(ITelemetryService, {
       _serviceBrand: undefined,
@@ -265,6 +291,10 @@ describe('AgentLifecycleService', () => {
       _serviceBrand: undefined,
       stopAllOnExit,
     } as unknown as IAgentTaskService);
+    ix.stub(IAgentFullCompactionService, {
+      _serviceBrand: undefined,
+      compacting: null,
+    } as unknown as IAgentFullCompactionService);
     ix.set(IAgentLifecycleService, new SyncDescriptor(AgentLifecycleService));
   });
   afterEach(() => {
@@ -291,6 +321,58 @@ describe('AgentLifecycleService', () => {
     expect(stopAllOnExit).toHaveBeenCalledWith('Session closed');
   });
 
+  it('remove cancels queued turns before waiting for the active turn to settle', async () => {
+    loopActiveTurnId = 1;
+    loopPendingTurnIds = [2, 3];
+    const svc = ix.get(IAgentLifecycleService);
+    await svc.create({ agentId: 'main' });
+
+    await svc.remove('main');
+
+    expect(loopCancel.mock.calls.map(([turnId]) => turnId)).toEqual([2, 3, undefined]);
+    expect(loopSettled).toHaveBeenCalledOnce();
+  });
+
+  it('remove waits for an active full compaction to reject after aborting it', async () => {
+    const abortController = new AbortController();
+    let rejectCompaction!: (reason: unknown) => void;
+    const promise = new Promise<never>((_resolve, reject) => {
+      rejectCompaction = reject;
+    });
+    const aborted = new Promise<void>((resolve) => {
+      abortController.signal.addEventListener(
+        'abort',
+        () => {
+          resolve();
+        },
+        { once: true },
+      );
+    });
+    ix.stub(IAgentFullCompactionService, {
+      _serviceBrand: undefined,
+      compacting: {
+        abortController,
+        promise,
+        trigger: 'manual',
+        tokenCount: 100,
+      },
+    } as unknown as IAgentFullCompactionService);
+    const svc = ix.get(IAgentLifecycleService);
+    await svc.create({ agentId: 'main' });
+
+    let removed = false;
+    const removal = svc.remove('main').then(() => {
+      removed = true;
+    });
+    await aborted;
+    await Promise.resolve();
+    expect(removed).toBe(false);
+
+    rejectCompaction(abortController.signal.reason);
+    await removal;
+    expect(removed).toBe(true);
+  });
+
   it('ignites the self-wiring toolDedupe plugin so its hooks exist before the first turn', async () => {
     const svc = ix.get(IAgentLifecycleService);
     await svc.create({ agentId: 'main' });
@@ -305,7 +387,7 @@ describe('AgentLifecycleService', () => {
     expect(a.id).not.toBe(b.id);
   });
 
-  it('persists provenance and labels when creating an agent', async () => {
+  it('persists complete agent metadata when creating a child', async () => {
     const svc = ix.get(IAgentLifecycleService);
 
     const child = await svc.create({
@@ -316,7 +398,7 @@ describe('AgentLifecycleService', () => {
 
     expect(child.id).toBe('child');
     expect(registerAgent).toHaveBeenCalledWith('child', {
-      homedir: '/tmp/kimi-agentLifecycle-test/agents/child',
+      homedir: '/tmp/kimi-agentLifecycle-home/sessions/ws_test/sess_test/agents/child',
       type: 'sub',
       parentAgentId: 'main',
       forkedFrom: 'main',
@@ -324,6 +406,34 @@ describe('AgentLifecycleService', () => {
     });
   });
 
+  it('seals a fresh wire log with the metadata envelope as the first record', async () => {
+    const log = recordingAppendLog();
+    ix.stub(IAppendLogStore, log.store);
+    const svc = ix.get(IAgentLifecycleService);
+
+    await svc.create({ agentId: 'main' });
+
+    expect(log.appended[0]).toMatchObject({
+      type: 'metadata',
+      protocol_version: createWireMetadataRecord().protocol_version,
+    });
+  });
+
+  it('does not re-seal a wire log that already has records', async () => {
+    const existing: WireRecord = {
+      type: 'turn.prompt',
+      input: [{ type: 'text', text: 'existing' }],
+      origin: { kind: 'user' },
+    };
+    const log = recordingAppendLog([existing]);
+    ix.stub(IAppendLogStore, log.store);
+    const svc = ix.get(IAgentLifecycleService);
+
+    await svc.create({ agentId: 'main' });
+
+    expect(log.appended.some((record) => record.type === 'metadata')).toBe(false);
+  });
+
   it('leaves permission mode at the default when permissionMode is omitted', async () => {
     const svc = ix.get(IAgentLifecycleService);
 
@@ -331,6 +441,35 @@ describe('AgentLifecycleService', () => {
     expect(permissionModeSetMode).not.toHaveBeenCalled();
   });
 
+  it('applies the configured permission mode when the Agent has no persisted mode', async () => {
+    ix.stub(IConfigService, {
+      ready: Promise.resolve(),
+      get: (() => 'auto') as IConfigService['get'],
+      onDidSectionChange: (() => ({ dispose: () => {} })) as IConfigService['onDidSectionChange'],
+    } as unknown as IConfigService);
+
+    await ix.get(IAgentLifecycleService).create({ agentId: 'main' });
+
+    expect(permissionModeSetMode).toHaveBeenCalledOnce();
+    expect(permissionModeSetMode).toHaveBeenCalledWith('auto');
+  });
+
+  it('keeps the restored permission mode instead of overwriting it with the default', async () => {
+    ix.stub(IAppendLogStore, recordingAppendLog([
+      createWireMetadataRecord(1),
+      { type: 'permission.set_mode', mode: 'manual', time: 2 },
+    ]).store);
+    ix.stub(IConfigService, {
+      ready: Promise.resolve(),
+      get: (() => 'auto') as IConfigService['get'],
+      onDidSectionChange: (() => ({ dispose: () => {} })) as IConfigService['onDidSectionChange'],
+    } as unknown as IConfigService);
+
+    await ix.get(IAgentLifecycleService).create({ agentId: 'main' });
+
+    expect(permissionModeSetMode).not.toHaveBeenCalled();
+  });
+
   it('wires MCP OAuth credentials through the session atomic document store', async () => {
     const svc = ix.get(IAgentLifecycleService);
     const main = await svc.create({ agentId: 'main' });
@@ -440,27 +579,32 @@ describe('AgentLifecycleService', () => {
     expect(connectAll).toHaveBeenCalledTimes(1);
   });
 
-  it('exposes the in-flight handle and yields it idle after bootstrap', async () => {
+  it('exposes the in-flight handle and joins it after bootstrap', async () => {
     let releaseRegister!: () => void;
-    registerAgent.mockImplementationOnce(
-      () =>
-        new Promise<void>((resolve) => {
-          releaseRegister = resolve;
-        }),
-    );
+    let registerStarted!: () => void;
+    const registerCalled = new Promise<void>((resolve) => {
+      registerStarted = resolve;
+    });
+    registerAgent.mockImplementationOnce(() => {
+      registerStarted();
+      return new Promise<void>((resolve) => {
+        releaseRegister = resolve;
+      });
+    });
     const svc = ix.get(IAgentLifecycleService);
     const create = svc.create({ agentId: 'main' });
 
     const early = svc.get('main');
     expect(early).toBeDefined();
-    expect(early!.accessor.get(IAgentActivityService).lane()).toBe('initializing');
 
     const joined = svc.create({ agentId: 'main' });
+    // doCreate awaits the wire-log seal before registerAgent, so the mock is
+    // invoked a few microtasks after create() — wait for the actual call.
+    await registerCalled;
     releaseRegister();
     const handle = await joined;
     await create;
     expect(handle).toBe(early);
-    expect(handle!.accessor.get(IAgentActivityService).lane()).toBe('idle');
   });
 
   it('ensureMainAgent returns one handle when calls start concurrently', async () => {
diff --git a/packages/agent-core-v2/test/session/approval/approval.test.ts b/packages/agent-core-v2/test/session/approval/approval.test.ts
index 24bd41b2b..86d0770d5 100644
--- a/packages/agent-core-v2/test/session/approval/approval.test.ts
+++ b/packages/agent-core-v2/test/session/approval/approval.test.ts
@@ -1,4 +1,4 @@
-import type { ToolInputDisplay } from '@moonshot-ai/protocol';
+import type { ToolInputDisplay } from '#/tool/toolInputDisplay';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { SyncDescriptor } from '#/_base/di/descriptors';
diff --git a/packages/agent-core-v2/test/session/cron/cron-tools.test.ts b/packages/agent-core-v2/test/session/cron/cron-tools.test.ts
index 8cc76fd64..e329ecfa3 100644
--- a/packages/agent-core-v2/test/session/cron/cron-tools.test.ts
+++ b/packages/agent-core-v2/test/session/cron/cron-tools.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import type { CronJobOrigin } from '@moonshot-ai/protocol';
+import type { CronJobOrigin } from '#/agent/contextMemory/types';
 
 import type {
   ExecutableTool,
diff --git a/packages/agent-core-v2/test/session/cron/manual-tick.test.ts b/packages/agent-core-v2/test/session/cron/manual-tick.test.ts
index e483efdcb..455aaa988 100644
--- a/packages/agent-core-v2/test/session/cron/manual-tick.test.ts
+++ b/packages/agent-core-v2/test/session/cron/manual-tick.test.ts
@@ -131,11 +131,15 @@ describe('SessionCronService — P1.8 manual tick + SIGUSR1', () => {
       let cron: ISessionCronService;
       let listenerCountBeforeCreate: number;
 
-      beforeEach(() => {
+      beforeEach(async () => {
         vi.stubEnv('KIMI_CRON_MANUAL_TICK', '1');
         listenerCountBeforeCreate = process.listenerCount('SIGUSR1');
         ctx = createTestAgent(cronServices());
         ctx.announceMain();
+        // Upstream gates `SessionCronService.start()` (and with it the
+        // SIGUSR1 binding) on the main wire's `onDidRestore` hook, so trigger
+        // a restore here for the binding to land before the test observes it.
+        await ctx.restorePersisted();
         cron = ctx.get(ISessionCronService);
       });
 
@@ -205,11 +209,15 @@ describe('SessionCronService — P1.8 manual tick + SIGUSR1', () => {
       let ctx: TestAgentContext;
       let cron: ISessionCronService;
 
-      beforeEach(() => {
+      beforeEach(async () => {
         vi.stubEnv('KIMI_CRON_MANUAL_TICK', '1');
         vi.stubEnv('KIMI_CRON_DEBUG', '1');
         ctx = createTestAgent(cronServices());
         ctx.announceMain();
+        // Upstream gates `SessionCronService.start()` (and with it the
+        // SIGUSR1 binding) on the main wire's `onDidRestore` hook, so trigger
+        // a restore here for the binding to land before the test observes it.
+        await ctx.restorePersisted();
         cron = ctx.get(ISessionCronService);
       });
 
diff --git a/packages/agent-core-v2/test/session/cron/resume.test.ts b/packages/agent-core-v2/test/session/cron/resume.test.ts
index 500420329..739f2ef01 100644
--- a/packages/agent-core-v2/test/session/cron/resume.test.ts
+++ b/packages/agent-core-v2/test/session/cron/resume.test.ts
@@ -130,7 +130,10 @@ describe('SessionCronService — persistence and resume', () => {
       } finally {
         vi.unstubAllEnvs();
         vi.restoreAllMocks();
-        await rm(sessionDir, { recursive: true, force: true });
+        // Cron persistence can still be draining its final post-dispose write
+        // when cleanup starts (parallel load widens the window) — let rm ride
+        // out transient ENOTEMPTY instead of flaking the suite.
+        await rm(sessionDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
       }
     }
   });
diff --git a/packages/agent-core-v2/test/session/cron/subagent-skip.test.ts b/packages/agent-core-v2/test/session/cron/subagent-skip.test.ts
index 593f49ada..3d3dbe060 100644
--- a/packages/agent-core-v2/test/session/cron/subagent-skip.test.ts
+++ b/packages/agent-core-v2/test/session/cron/subagent-skip.test.ts
@@ -79,10 +79,14 @@ describe('Agent + Cron — subagent suppression', () => {
     let profile: IAgentProfileService;
     let listenerCountBeforeCreate: number;
 
-    beforeEach(() => {
+    beforeEach(async () => {
       listenerCountBeforeCreate = process.listenerCount('SIGUSR1');
       ctx = createTestAgent();
       ctx.announceMain();
+      // Upstream gates `SessionCronService.start()` (and with it the SIGUSR1
+      // binding) on the main wire's `onDidRestore` hook, so trigger a restore
+      // here for the binding to land before the test observes it.
+      await ctx.restorePersisted();
       profile = ctx.get(IAgentProfileService);
     });
 
@@ -112,10 +116,14 @@ describe('Agent + Cron — subagent suppression', () => {
     let profile: IAgentProfileService;
     let listenerCountBeforeCreate: number;
 
-    beforeEach(() => {
+    beforeEach(async () => {
       listenerCountBeforeCreate = process.listenerCount('SIGUSR1');
       ctx = createTestAgent();
       ctx.announceMain();
+      // Upstream gates `SessionCronService.start()` (and with it the SIGUSR1
+      // binding) on the main wire's `onDidRestore` hook, so trigger a restore
+      // here for the binding to land before the test observes it.
+      await ctx.restorePersisted();
       profile = ctx.get(IAgentProfileService);
     });
 
diff --git a/packages/agent-core-v2/test/session/sessionActivity/sessionActivity.test.ts b/packages/agent-core-v2/test/session/sessionActivity/sessionActivity.test.ts
deleted file mode 100644
index c21678790..000000000
--- a/packages/agent-core-v2/test/session/sessionActivity/sessionActivity.test.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { SyncDescriptor } from '#/_base/di/descriptors';
-import type { ServiceIdentifier, ServicesAccessor } from '#/_base/di/instantiation';
-import { DisposableStore } from '#/_base/di/lifecycle';
-import { type IAgentScopeHandle, LifecycleScope } from '#/_base/di/scope';
-import { TestInstantiationService } from '#/_base/di/test';
-import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
-import { ISessionInteractionService, type Interaction, type InteractionKind } from '#/session/interaction/interaction';
-import { ISessionActivity } from '#/session/sessionActivity/sessionActivity';
-import { SessionActivity } from '#/session/sessionActivity/sessionActivityService';
-import { IAgentLoopService } from '#/agent/loop/loop';
-import { stubLoopWithHooks } from '../../agent/loop/stubs';
-
-function makeTurnService(active: boolean): IAgentLoopService {
-  const base = stubLoopWithHooks({ hasActiveTurn: active });
-  if (active) base.startTurn();
-  return base;
-}
-
-function makeAccessor(turn: IAgentLoopService): ServicesAccessor {
-  return {
-    get<T>(id: ServiceIdentifier<T>): T {
-      if (id === (IAgentLoopService as unknown as ServiceIdentifier<T>)) {
-        return turn as unknown as T;
-      }
-      throw new Error(`unexpected service request: ${String(id)}`);
-    },
-  };
-}
-
-function handle(id: string, active: boolean): IAgentScopeHandle {
-  const turn = makeTurnService(active);
-  return {
-    id,
-    kind: LifecycleScope.Agent,
-    accessor: makeAccessor(turn),
-    dispose: () => {},
-  };
-}
-
-function lifecycle(handles: readonly IAgentScopeHandle[]): IAgentLifecycleService {
-  return {
-    _serviceBrand: undefined,
-    onDidCreate: () => ({ dispose: () => {} }),
-    onDidDispose: () => ({ dispose: () => {} }),
-    create: () => Promise.resolve(handles[0]!),
-    fork: () => Promise.resolve(handles[0]!),
-    get: () => undefined,
-    list: () => handles,
-    remove: () => Promise.resolve(),
-  };
-}
-
-function interactions(
-  pending: { approval?: number; question?: number },
-): Partial<ISessionInteractionService> {
-  const items: Interaction[] = [];
-  for (let i = 0; i < (pending.approval ?? 0); i++) {
-    items.push({ id: `a${i}`, kind: 'approval', payload: {}, origin: {}, createdAt: 0 });
-  }
-  for (let i = 0; i < (pending.question ?? 0); i++) {
-    items.push({ id: `q${i}`, kind: 'question', payload: {}, origin: {}, createdAt: 0 });
-  }
-  return {
-    listPending: (kind?: InteractionKind) =>
-      kind === undefined ? items : items.filter((i) => i.kind === kind),
-  };
-}
-
-describe('SessionActivity', () => {
-  let disposables: DisposableStore;
-  let ix: TestInstantiationService;
-
-  beforeEach(() => {
-    disposables = new DisposableStore();
-    ix = disposables.add(new TestInstantiationService());
-    ix.set(ISessionActivity, new SyncDescriptor(SessionActivity));
-    ix.stub(ISessionInteractionService, interactions({}));
-  });
-  afterEach(() => disposables.dispose());
-
-  it('idle when no agents', () => {
-    ix.stub(IAgentLifecycleService, lifecycle([]));
-    expect(ix.get(ISessionActivity).isIdle()).toBe(true);
-  });
-
-  it('idle when all agents idle', () => {
-    ix.stub(IAgentLifecycleService, lifecycle([handle('a', false)]));
-    expect(ix.get(ISessionActivity).isIdle()).toBe(true);
-  });
-
-  it('not idle when any agent has an active turn', () => {
-    ix.stub(
-      IAgentLifecycleService,
-      lifecycle([handle('a', false), handle('b', true)]),
-    );
-    expect(ix.get(ISessionActivity).isIdle()).toBe(false);
-  });
-
-  describe('status', () => {
-    it('idle when nothing is pending and no turn is active', () => {
-      ix.stub(IAgentLifecycleService, lifecycle([handle('a', false)]));
-      expect(ix.get(ISessionActivity).status()).toBe('idle');
-    });
-
-    it('running when an agent has an active turn', () => {
-      ix.stub(IAgentLifecycleService, lifecycle([handle('a', true)]));
-      expect(ix.get(ISessionActivity).status()).toBe('running');
-    });
-
-    it('awaiting_approval when an approval interaction is pending', () => {
-      ix.stub(IAgentLifecycleService, lifecycle([handle('a', false)]));
-      ix.stub(ISessionInteractionService, interactions({ approval: 1 }));
-      expect(ix.get(ISessionActivity).status()).toBe('awaiting_approval');
-    });
-
-    it('awaiting_question when a question interaction is pending', () => {
-      ix.stub(IAgentLifecycleService, lifecycle([handle('a', false)]));
-      ix.stub(ISessionInteractionService, interactions({ question: 1 }));
-      expect(ix.get(ISessionActivity).status()).toBe('awaiting_question');
-    });
-
-    it('approval takes priority over question', () => {
-      ix.stub(IAgentLifecycleService, lifecycle([handle('a', false)]));
-      ix.stub(ISessionInteractionService, interactions({ approval: 1, question: 1 }));
-      expect(ix.get(ISessionActivity).status()).toBe('awaiting_approval');
-    });
-
-    it('question takes priority over running', () => {
-      ix.stub(IAgentLifecycleService, lifecycle([handle('a', true)]));
-      ix.stub(ISessionInteractionService, interactions({ question: 1 }));
-      expect(ix.get(ISessionActivity).status()).toBe('awaiting_question');
-    });
-  });
-});
diff --git a/packages/agent-core-v2/test/session/sessionFs/fsService.test.ts b/packages/agent-core-v2/test/session/sessionFs/fsService.test.ts
index 089cd27b2..7349ebc2b 100644
--- a/packages/agent-core-v2/test/session/sessionFs/fsService.test.ts
+++ b/packages/agent-core-v2/test/session/sessionFs/fsService.test.ts
@@ -39,7 +39,11 @@ function stubWorkspace(): ISessionWorkspaceContext {
   };
 }
 
-function fakeFs(files: Record<string, string>, symlinks: readonly string[] = []): IHostFileSystem {
+function fakeFs(
+  files: Record<string, string>,
+  symlinks: readonly string[] = [],
+  symlinkTargets: Record<string, string> = {},
+): IHostFileSystem {
   const fileMap = new Map<string, string>();
   const dirSet = new Set<string>([WORK_DIR]);
   const addAncestors = (rel: string): void => {
@@ -57,6 +61,13 @@ function fakeFs(files: Record<string, string>, symlinks: readonly string[] = [])
     symlinkSet.add(join(WORK_DIR, rel));
     addAncestors(rel);
   }
+  const symlinkTargetMap = new Map<string, string>();
+  for (const [rel, target] of Object.entries(symlinkTargets)) {
+    const abs = join(WORK_DIR, rel);
+    symlinkTargetMap.set(abs, target);
+    symlinkSet.add(abs);
+    addAncestors(rel);
+  }
   const isDir = (p: string): boolean => p === WORK_DIR || dirSet.has(p);
   const enoent = (p: string): NodeJS.ErrnoException => {
     const err = new Error(`ENOENT: ${p}`) as NodeJS.ErrnoException;
@@ -162,6 +173,29 @@ function fakeFs(files: Record<string, string>, symlinks: readonly string[] = [])
       dirSet.add(p);
     },
     remove: async () => {},
+    realpath: async (p) => {
+      let current = p;
+      for (let i = 0; i < 40; i++) {
+        let longest: string | undefined;
+        for (const linkPath of symlinkTargetMap.keys()) {
+          if (
+            (current === linkPath || current.startsWith(`${linkPath}/`)) &&
+            (longest === undefined || linkPath.length > longest.length)
+          ) {
+            longest = linkPath;
+          }
+        }
+        if (longest === undefined) {
+          if (current === p) {
+            if (p === WORK_DIR || fileMap.has(p) || isDir(p) || symlinkSet.has(p)) return p;
+            throw enoent(p);
+          }
+          return current;
+        }
+        current = symlinkTargetMap.get(longest)! + current.slice(longest.length);
+      }
+      return current;
+    },
   };
 }
 
@@ -291,11 +325,12 @@ function makeSession(
   git: IGitService = defaultGitStub(),
   symlinks: readonly string[] = [],
   runner?: ISessionProcessRunner,
+  symlinkTargets: Record<string, string> = {},
 ): ISessionFsService {
   host = createScopedTestHost();
   const session = host.child(LifecycleScope.Session, 's1', [
     stubPair(ISessionWorkspaceContext, stubWorkspace()),
-    stubPair(IHostFileSystem, fakeFs(files, symlinks)),
+    stubPair(IHostFileSystem, fakeFs(files, symlinks, symlinkTargets)),
     stubPair(ISessionProcessRunner, runner ?? fakeRunner(handler)),
     stubPair(ITelemetryService, telemetryStub(events)),
     stubPair(IGitService, git),
@@ -711,3 +746,84 @@ describe('SessionFsService.resolveDownload', () => {
     await expect(fs.resolveDownload('src')).rejects.toMatchObject({ code: 'fs.is_directory' });
   });
 });
+
+describe('SessionFsService symlink confinement', () => {
+  const escapeTargets = { docs: '/outside' };
+
+  function escapeSession(): ISessionFsService {
+    return makeSession(
+      { 'src/a.ts': '' },
+      emptyHandler,
+      [],
+      defaultGitStub(),
+      [],
+      undefined,
+      escapeTargets,
+    );
+  }
+
+  it('rejects reads that escape through a symlinked directory', async () => {
+    const fs = escapeSession();
+    await expect(
+      fs.read({ path: 'docs/secret.txt', offset: 0, length: 1024, encoding: 'utf-8' }),
+    ).rejects.toMatchObject({ code: 'fs.path_escapes' });
+  });
+
+  it('rejects list through a symlinked directory', async () => {
+    const fs = escapeSession();
+    await expect(
+      fs.list({
+        path: 'docs',
+        depth: 1,
+        limit: 200,
+        show_hidden: false,
+        follow_gitignore: false,
+        sort: 'name_asc',
+        include_git_status: false,
+      }),
+    ).rejects.toMatchObject({ code: 'fs.path_escapes' });
+  });
+
+  it('rejects stat, mkdir, resolvePath and resolveDownload through a symlinked directory', async () => {
+    const fs = escapeSession();
+    await expect(fs.stat({ path: 'docs/secret.txt' })).rejects.toMatchObject({
+      code: 'fs.path_escapes',
+    });
+    await expect(fs.mkdir({ path: 'docs/newdir', recursive: true })).rejects.toMatchObject({
+      code: 'fs.path_escapes',
+    });
+    await expect(fs.resolvePath('docs/secret.txt')).rejects.toMatchObject({
+      code: 'fs.path_escapes',
+    });
+    await expect(fs.resolveDownload('docs/secret.txt')).rejects.toMatchObject({
+      code: 'fs.path_escapes',
+    });
+  });
+
+  it('rejects statMany when any path escapes through a symlinked directory', async () => {
+    const fs = escapeSession();
+    await expect(fs.statMany({ paths: ['docs/secret.txt'] })).rejects.toMatchObject({
+      code: 'fs.path_escapes',
+    });
+  });
+
+  it('still allows a symlink whose target stays inside the workspace', async () => {
+    const fs = makeSession(
+      { 'real/a.txt': 'hi' },
+      emptyHandler,
+      [],
+      defaultGitStub(),
+      [],
+      undefined,
+      { link: '/repo/real' },
+    );
+    const entry = await fs.stat({ path: 'link' });
+    expect(entry.kind).toBe('symlink');
+  });
+
+  it('still resolves ordinary in-workspace paths', async () => {
+    const fs = makeSession({ 'src/a.ts': 'content' }, emptyHandler);
+    const res = await fs.read({ path: 'src/a.ts', offset: 0, length: 1024, encoding: 'utf-8' });
+    expect(res.content).toBe('content');
+  });
+});
diff --git a/packages/agent-core-v2/test/session/sessionFs/fsWatchService.test.ts b/packages/agent-core-v2/test/session/sessionFs/fsWatchService.test.ts
index 507764b21..08868dd71 100644
--- a/packages/agent-core-v2/test/session/sessionFs/fsWatchService.test.ts
+++ b/packages/agent-core-v2/test/session/sessionFs/fsWatchService.test.ts
@@ -17,7 +17,7 @@ import {
   IHostFsWatchService,
 } from '#/os/interface/hostFsWatch';
 import { ISessionWorkspaceContext } from '#/session/workspaceContext/workspaceContext';
-import type { FsChangeEvent } from '@moonshot-ai/protocol';
+import type { FsChangeEvent } from '#/session/sessionFs/fsWatch';
 
 import { ISessionFsWatchService } from '#/session/sessionFs/fsWatch';
 import { SessionFsWatchService } from '#/session/sessionFs/fsWatchService';
diff --git a/packages/agent-core-v2/test/session/sessionInit/sessionInit.test.ts b/packages/agent-core-v2/test/session/sessionInit/sessionInit.test.ts
index 78e8e2e76..81f9918af 100644
--- a/packages/agent-core-v2/test/session/sessionInit/sessionInit.test.ts
+++ b/packages/agent-core-v2/test/session/sessionInit/sessionInit.test.ts
@@ -13,7 +13,7 @@ import { IAgentContextSizeService } from '#/agent/contextSize/contextSize';
 import { IAgentPermissionModeService } from '#/agent/permissionMode/permissionMode';
 import { IAgentProfileService } from '#/agent/profile/profile';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
+import { IWireService } from '#/wire/wire';
 import { ErrorCodes, Error2 } from '#/errors';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { ISessionInitService } from '#/session/sessionInit/sessionInit';
@@ -77,7 +77,7 @@ describe('SessionInitService', () => {
           if (id === IAgentProfileService) return profile;
           if (id === IAgentPermissionModeService) return permissionMode;
           if (id === IAgentSystemReminderService) return { appendSystemReminder };
-          if (id === IAgentWireRecordService) return { flush };
+          if (id === IWireService) return { flush };
           if (id === IEventBus) return eventBus;
           if (id === ITelemetryService) return telemetry;
           return undefined;
diff --git a/packages/agent-core-v2/test/session/sessionMetadata/sessionMetadata.test.ts b/packages/agent-core-v2/test/session/sessionMetadata/sessionMetadata.test.ts
index eb590436b..b98e6b7c8 100644
--- a/packages/agent-core-v2/test/session/sessionMetadata/sessionMetadata.test.ts
+++ b/packages/agent-core-v2/test/session/sessionMetadata/sessionMetadata.test.ts
@@ -51,7 +51,14 @@ describe('SessionMetadata', () => {
 
   it('creates an initial document on first read', async () => {
     const meta = ix.get(ISessionMetadata);
-    expect(await meta.read()).toMatchObject({ id: 's1', archived: false });
+    expect(await meta.read()).toMatchObject({
+      id: 's1',
+      archived: false,
+      // Seeded so released v1 builds can open a v2-created state.json
+      // (v1's Session.resume() indexes `agents` unconditionally).
+      agents: {},
+      custom: {},
+    });
     expect((await meta.read()).createdAt).toBeGreaterThan(0);
   });
 
@@ -81,6 +88,49 @@ describe('SessionMetadata', () => {
     expect(await fresh.read()).toMatchObject({ id: 's1', title: 'persisted' });
   });
 
+  it('backfills and persists missing agents/custom maps on a pre-fix document', async () => {
+    // Written by a v2 build predating the create-path map seeding: no
+    // agents / custom keys at all.
+    const store = ix.get(IAtomicDocumentStore);
+    await store.set(META_SCOPE, 'state.json', {
+      id: 's1',
+      version: 2,
+      createdAt: 1700000000000,
+      updatedAt: 1700000000000,
+      archived: false,
+    });
+
+    const meta = ix.get(ISessionMetadata);
+    expect(await meta.read()).toMatchObject({ agents: {}, custom: {} });
+
+    // The heal is persisted: a fresh instance reads the maps from disk, and
+    // updatedAt is untouched so session listings keep their order.
+    const fresh = ix.createInstance(SessionMetadata);
+    const healed = await fresh.read();
+    expect(healed.agents).toEqual({});
+    expect(healed.custom).toEqual({});
+    expect(healed.updatedAt).toBe(1700000000000);
+  });
+
+  it('leaves existing agents/custom maps untouched', async () => {
+    const store = ix.get(IAtomicDocumentStore);
+    await store.set(META_SCOPE, 'state.json', {
+      id: 's1',
+      version: 2,
+      createdAt: 1700000000000,
+      updatedAt: 1700000000000,
+      archived: false,
+      agents: { main: { homedir: '/tmp/sessions/wd_test/s1/agents/main', type: 'main' } },
+      custom: { cwd: '/tmp/work' },
+    });
+
+    const meta = ix.get(ISessionMetadata);
+    expect(await meta.read()).toMatchObject({
+      agents: { main: { homedir: '/tmp/sessions/wd_test/s1/agents/main', type: 'main' } },
+      custom: { cwd: '/tmp/work' },
+    });
+  });
+
   it('fires onDidChangeMetadata with the changed keys after update', async () => {
     const meta = ix.get(ISessionMetadata);
     await meta.ready;
@@ -101,11 +151,9 @@ describe('SessionMetadata', () => {
 
     await Promise.all([
       meta.registerAgent('agent-0', {
-        homedir: '/tmp/sessions/wd_test/s1/agents/agent-0',
         labels: { swarmItem: 'src/a.ts' },
       }),
       meta.registerAgent('agent-1', {
-        homedir: '/tmp/sessions/wd_test/s1/agents/agent-1',
         labels: { swarmItem: 'src/b.ts' },
       }),
     ]);
@@ -115,4 +163,88 @@ describe('SessionMetadata', () => {
       'agent-1',
     ]);
   });
+
+  it('treats re-registering an unchanged agent as a no-op', async () => {
+    const meta = ix.get(ISessionMetadata);
+    await meta.registerAgent('main', {
+      homedir: '/tmp/sessions/wd_test/s1/agents/main',
+      type: 'main',
+      parentAgentId: undefined,
+      forkedFrom: undefined,
+      labels: undefined,
+    });
+
+    const before = (await meta.read()).updatedAt;
+    await new Promise((r) => setTimeout(r, 2));
+
+    // A resumed session re-registers its materialized agents; with identical
+    // metadata that must not write, bump updatedAt, or fire an event.
+    let fired = 0;
+    const sub = meta.onDidChangeMetadata(() => {
+      fired++;
+    });
+    await meta.registerAgent('main', {
+      homedir: '/tmp/sessions/wd_test/s1/agents/main',
+      type: 'main',
+      parentAgentId: undefined,
+      forkedFrom: undefined,
+      labels: undefined,
+    });
+
+    expect(fired).toBe(0);
+    expect((await meta.read()).updatedAt).toBe(before);
+    sub.dispose();
+  });
+
+  it('stays a no-op when re-registering against a persisted document', async () => {
+    // The document as it lands on disk: keys with undefined values are gone,
+    // and a legacy writer stored parentAgentId: null. A server restart then
+    // re-registers `main` with explicit undefineds — still no update.
+    const store = ix.get(IAtomicDocumentStore);
+    await store.set(META_SCOPE, 'state.json', {
+      id: 's1',
+      version: 2,
+      createdAt: 1700000000000,
+      updatedAt: 1700000000000,
+      archived: false,
+      agents: {
+        main: {
+          homedir: '/tmp/sessions/wd_test/s1/agents/main',
+          type: 'main',
+          parentAgentId: null,
+        },
+      },
+    });
+
+    const meta = ix.get(ISessionMetadata);
+    await meta.registerAgent('main', {
+      homedir: '/tmp/sessions/wd_test/s1/agents/main',
+      type: 'main',
+      parentAgentId: undefined,
+      forkedFrom: undefined,
+      labels: undefined,
+    });
+
+    expect((await meta.read()).updatedAt).toBe(1700000000000);
+  });
+
+  it('updates when re-registering with changed fields', async () => {
+    const meta = ix.get(ISessionMetadata);
+    await meta.registerAgent('main', {
+      homedir: '/tmp/sessions/wd_test/s1/agents/main',
+      type: 'main',
+    });
+    const before = (await meta.read()).updatedAt;
+    await new Promise((r) => setTimeout(r, 2));
+
+    await meta.registerAgent('main', {
+      homedir: '/tmp/sessions/wd_test/s1/agents/main',
+      type: 'main',
+      labels: { swarmItem: 'src/a.ts' },
+    });
+
+    const next = await meta.read();
+    expect(next.agents?.['main']?.labels).toEqual({ swarmItem: 'src/a.ts' });
+    expect(next.updatedAt).toBeGreaterThan(before);
+  });
 });
diff --git a/packages/agent-core-v2/test/session/swarm/sessionSwarm.test.ts b/packages/agent-core-v2/test/session/swarm/sessionSwarm.test.ts
index f65ebe7f7..b65a6351e 100644
--- a/packages/agent-core-v2/test/session/swarm/sessionSwarm.test.ts
+++ b/packages/agent-core-v2/test/session/swarm/sessionSwarm.test.ts
@@ -911,17 +911,14 @@ describe('SessionSwarmService metadata compatibility', () => {
 
   it('reads swarm items from caller-owned v2 labels and legacy v1 metadata', async () => {
     agents['v2-child'] = {
-      homedir: '/tmp/kimi/s1/agents/v2-child',
       labels: { parentAgentId: 'main', swarmItem: 'src/a.ts' },
     };
     agents['legacy-child'] = {
-      homedir: '/tmp/kimi/s1/agents/legacy-child',
       type: 'sub',
       parentAgentId: 'main',
       swarmItem: 'src/legacy.ts',
     };
     agents['other-child'] = {
-      homedir: '/tmp/kimi/s1/agents/other-child',
       labels: { parentAgentId: 'other', swarmItem: 'src/other.ts' },
     };
 
@@ -943,7 +940,6 @@ describe('SessionSwarmService metadata compatibility', () => {
 
   it('prefers labels over legacy metadata fields when both are present', async () => {
     agents['mixed-child'] = {
-      homedir: '/tmp/kimi/s1/agents/mixed-child',
       labels: { parentAgentId: 'main', swarmItem: 'src/labels.ts' },
       type: 'sub',
       parentAgentId: 'other',
@@ -963,7 +959,6 @@ describe('SessionSwarmService metadata compatibility', () => {
   it('normalizes legacy subagent metadata into labels for new writes', () => {
     expect(
       labelsFromAgentMeta({
-        homedir: '/tmp/kimi/s1/agents/legacy-child',
         type: 'sub',
         parentAgentId: 'main',
         swarmItem: 'src/legacy.ts',
@@ -971,7 +966,6 @@ describe('SessionSwarmService metadata compatibility', () => {
     ).toEqual({ parentAgentId: 'main', swarmItem: 'src/legacy.ts' });
     expect(
       labelsFromAgentMeta({
-        homedir: '/tmp/kimi/s1/agents/mixed-child',
         labels: { parentAgentId: 'main', swarmItem: 'src/labels.ts', custom: 'kept' },
         type: 'sub',
         parentAgentId: 'other',
@@ -1047,7 +1041,6 @@ describe('SessionSwarmService metadata compatibility', () => {
 
   it('keeps v1 resume ownership errors inside the per-subagent result', async () => {
     agents['other-child'] = {
-      homedir: '/tmp/kimi/s1/agents/other-child',
       labels: { parentAgentId: 'other', swarmItem: 'src/other.ts' },
     };
     handles.set('other-child', agentHandle('other-child', lifecycle, eventBusStub()));
@@ -1070,7 +1063,6 @@ describe('SessionSwarmService metadata compatibility', () => {
 
   it('realigns resumed children to the caller current model', async () => {
     agents['agent-existing'] = {
-      homedir: '/tmp/kimi/s1/agents/agent-existing',
       labels: { parentAgentId: 'main' },
     };
     const child = agentHandle('agent-existing', lifecycle, eventBus, {
@@ -1099,11 +1091,9 @@ describe('SessionSwarmService metadata compatibility', () => {
     vi.useFakeTimers();
     try {
       agents['agent-retry'] = {
-        homedir: '/tmp/kimi/s1/agents/agent-retry',
         labels: { parentAgentId: 'main' },
       };
       agents['agent-blocker'] = {
-        homedir: '/tmp/kimi/s1/agents/agent-blocker',
         labels: { parentAgentId: 'main' },
       };
       handles.set('agent-retry', agentHandle('agent-retry', lifecycle, eventBus));
@@ -1160,7 +1150,6 @@ describe('SessionSwarmService metadata compatibility', () => {
 
   it('rejects resume of an already running child before launching or emitting spawned', async () => {
     agents['agent-existing'] = {
-      homedir: '/tmp/kimi/s1/agents/agent-existing',
       labels: { parentAgentId: 'main' },
     };
     handles.set(
diff --git a/packages/agent-core-v2/test/session/todo/sessionTodo.test.ts b/packages/agent-core-v2/test/session/todo/sessionTodo.test.ts
index f53527b84..a18e5770f 100644
--- a/packages/agent-core-v2/test/session/todo/sessionTodo.test.ts
+++ b/packages/agent-core-v2/test/session/todo/sessionTodo.test.ts
@@ -9,17 +9,18 @@ import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory'
 import type { ContextMessage } from '#/agent/contextMemory/types';
 import { IAgentProfileService } from '#/agent/profile/profile';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
+import { createHooks } from '#/hooks';
 import { ISessionTodoService } from '#/session/todo/sessionTodo';
 import { makeLifecycleStub } from '../agentLifecycle/stubs';
 import { SessionTodoService } from '#/session/todo/sessionTodoService';
 import { readTodoItems, type TodoItem } from '#/session/todo/todoItem';
 import { TODO_LIST_REMINDER_VARIANT } from '#/session/todo/todoListReminder';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
 import { parseBooleanEnv } from '#/_base/utils/env';
 import { IFlagService } from '#/app/flag/flag';
 import type { FlagId } from '#/app/flag/flagRegistry';
 import { SPINE_FLAG_ENV, SPINE_FLAG_ID } from '#/agent/spine/flag';
+import { IWireService, type WireHooks } from '#/wire/wire';
+import type { WireRecord } from '#/wire/record';
 
 // Mirrors `FlagService` env resolution for the spine flag: the real service
 // reads the env through bootstrap on every `enabled` call, so stubbing the env
@@ -47,8 +48,7 @@ interface FakeAgent {
   readonly registeredVariants: string[];
   readonly reminderProviders: Map<string, () => string | undefined>;
   readonly appended: RecordedTodoSet[];
-  readonly subscribed: () => number;
-  readonly replay: (records: readonly PersistedRecord[]) => Promise<void>;
+  readonly restore: (records: readonly WireRecord[]) => Promise<void>;
 }
 
 function makeFakeAgent(agentId: string, options: FakeAgentOptions = {}): FakeAgent {
@@ -59,10 +59,6 @@ function makeFakeAgent(agentId: string, options: FakeAgentOptions = {}): FakeAge
   const appended: RecordedTodoSet[] = [];
 
   let todoState: readonly TodoItem[] = [];
-  type Subscriber = (state: readonly TodoItem[], prev: readonly TodoItem[]) => void;
-  const subscribers: Subscriber[] = [];
-  const restoredHandlers: Array<() => void> = [];
-  let subscribedCount = 0;
 
   const registryStub = {
     _serviceBrand: undefined,
@@ -98,8 +94,17 @@ function makeFakeAgent(agentId: string, options: FakeAgentOptions = {}): FakeAge
     isToolActive: () => toolActive,
   };
 
+  const restore = async (records: readonly WireRecord[]): Promise<void> => {
+    for (const record of records) {
+      if (record.type === 'tools.update_store' && record['key'] === 'todo') {
+        todoState = readTodoItems(record['value']);
+      }
+    }
+  };
+
   const wireStub: IWireService = {
     _serviceBrand: undefined,
+    hooks: createHooks<WireHooks, keyof WireHooks>(['onDidRestore']),
     dispatch: (...ops: unknown[]) => {
       for (const raw of ops) {
         const op = raw as { type: string; payload: unknown };
@@ -110,40 +115,13 @@ function makeFakeAgent(agentId: string, options: FakeAgentOptions = {}): FakeAge
             : { payload };
         appended.push({ type: op.type, ...record } as unknown as RecordedTodoSet);
         if (op.type === 'tools.update_store' && record['key'] === 'todo') {
-          const prev = todoState;
-          todoState = readTodoItems(record['value']);
-          if (prev !== todoState) {
-            for (const h of [...subscribers]) h(todoState, prev);
-          }
-        }
-      }
-    },
-    replay: async (...records: PersistedRecord[]) => {
-      for (const record of records) {
-        if (record.type === 'tools.update_store' && record['key'] === 'todo') {
           todoState = readTodoItems(record['value']);
         }
       }
-      for (const h of restoredHandlers) h();
-      return { unknownRecords: 0 };
     },
-    signal: () => {},
+    restore: async () => {},
     flush: async () => {},
-    attach: () => toDisposable(() => {}),
     getModel: () => todoState,
-    subscribe: (_model: unknown, handler: unknown) => {
-      subscribedCount += 1;
-      subscribers.push(handler as Subscriber);
-      return toDisposable(() => {
-        const i = subscribers.indexOf(handler as Subscriber);
-        if (i >= 0) subscribers.splice(i, 1);
-      });
-    },
-    onEmission: () => toDisposable(() => {}),
-    onRestored: (handler: () => void) => {
-      restoredHandlers.push(handler);
-      return toDisposable(() => {});
-    },
   } as unknown as IWireService;
 
   const accessor: ServicesAccessor = {
@@ -153,7 +131,7 @@ function makeFakeAgent(agentId: string, options: FakeAgentOptions = {}): FakeAge
       if (id === IInstantiationService) return instantiationStub as unknown as T;
       if (id === IAgentContextMemoryService) return memoryStub as unknown as T;
       if (id === IAgentProfileService) return profileStub as unknown as T;
-      if (id === IAgentWireService) return wireStub as unknown as T;
+      if (id === IWireService) return wireStub as unknown as T;
       throw new Error(`unexpected service request in fake agent: ${String(id)}`);
     },
   };
@@ -171,10 +149,7 @@ function makeFakeAgent(agentId: string, options: FakeAgentOptions = {}): FakeAge
     registeredVariants,
     reminderProviders,
     appended,
-    subscribed: () => subscribedCount,
-    replay: async (records) => {
-      await wireStub.replay(...records);
-    },
+    restore,
   };
 }
 
@@ -259,15 +234,17 @@ describe('SessionTodoService', () => {
     expect(sub.registeredVariants).toContain(TODO_LIST_REMINDER_VARIANT);
   });
 
-  it('subscribes to TodoModel only on the main agent', () => {
+  it('routes todo reads and writes only through the main agent', () => {
     const main = makeFakeAgent('main');
     const sub = makeFakeAgent('agent-1');
     const lifecycle = makeLifecycleStub([main.handle, sub.handle]);
     const service = new SessionTodoService(lifecycle.service, makeFlagsStub());
-    void service;
 
-    expect(main.subscribed()).toBe(1);
-    expect(sub.subscribed()).toBe(0);
+    service.setTodos([{ title: 'main only', status: 'pending' }]);
+
+    expect(main.appended).toHaveLength(1);
+    expect(sub.appended).toHaveLength(0);
+    expect(service.getTodos()).toEqual([{ title: 'main only', status: 'pending' }]);
   });
 
   it('rebuilds the list when a todo tools.update_store record is replayed', async () => {
@@ -275,7 +252,7 @@ describe('SessionTodoService', () => {
     const lifecycle = makeLifecycleStub([main.handle]);
     const service = new SessionTodoService(lifecycle.service, makeFlagsStub());
 
-    await main.replay([
+    await main.restore([
       { type: 'tools.update_store', key: 'todo', value: [{ title: 'restored', status: 'done' }] },
     ]);
 
@@ -332,7 +309,7 @@ describe('SessionTodoService', () => {
     const lifecycle = makeLifecycleStub([main.handle]);
     const service = new SessionTodoService(lifecycle.service, makeFlagsStub());
 
-    await main.replay([
+    await main.restore([
       {
         type: 'tools.update_store',
         key: 'todo',
@@ -343,7 +320,7 @@ describe('SessionTodoService', () => {
           'garbage',
           { title: 'bad status', status: 'wip' },
         ],
-      } as unknown as PersistedRecord,
+      } as unknown as WireRecord,
     ]);
 
     expect(service.getTodos()).toEqual([{ title: 'valid', status: 'done' }]);
@@ -354,8 +331,8 @@ describe('SessionTodoService', () => {
     const lifecycle = makeLifecycleStub([main.handle]);
     const service = new SessionTodoService(lifecycle.service, makeFlagsStub());
 
-    await main.replay([
-      { type: 'tools.update_store', key: 'todo', value: 'not-an-array' } as unknown as PersistedRecord,
+    await main.restore([
+      { type: 'tools.update_store', key: 'todo', value: 'not-an-array' } as unknown as WireRecord,
     ]);
 
     expect(service.getTodos()).toEqual([]);
diff --git a/packages/agent-core-v2/test/session/workspaceCommand/workspaceCommand.test.ts b/packages/agent-core-v2/test/session/workspaceCommand/workspaceCommand.test.ts
index fe1c7c3ee..5354a54e3 100644
--- a/packages/agent-core-v2/test/session/workspaceCommand/workspaceCommand.test.ts
+++ b/packages/agent-core-v2/test/session/workspaceCommand/workspaceCommand.test.ts
@@ -133,6 +133,11 @@ class MemoryHostFs implements IHostFileSystem {
     this.files.delete(path);
     this.dirs.delete(path);
   }
+
+  async realpath(path: string): Promise<string> {
+    if (this.files.has(path) || this.dirs.has(path)) return path;
+    throw enoent(path);
+  }
 }
 
 function enoent(path: string): NodeJS.ErrnoException {
diff --git a/packages/agent-core-v2/test/snapshot/events.ts b/packages/agent-core-v2/test/snapshot/events.ts
index 3c0b863cc..06267edb5 100644
--- a/packages/agent-core-v2/test/snapshot/events.ts
+++ b/packages/agent-core-v2/test/snapshot/events.ts
@@ -4,7 +4,7 @@ import {
   type EventSnapshotEntry,
   type WireSnapshotEntry,
 } from '../harness/snapshots';
-import type { PersistedWireRecord } from '#/agent/wireRecord/wireRecord';
+import type { WireRecord } from '#/wire/record';
 
 export interface RpcPromiseLike {
   resolve(value: unknown): void;
@@ -137,7 +137,7 @@ export function recordAgentEvents() {
       });
     },
 
-    recordWire(record: PersistedWireRecord): WireSnapshotEntry {
+    recordWire(record: WireRecord): WireSnapshotEntry {
       const { type, ...args } = record;
       return emit({ type: '[wire]', event: type, args }) as WireSnapshotEntry;
     },
diff --git a/packages/agent-core-v2/test/spine/archive.test.ts b/packages/agent-core-v2/test/spine/archive.test.ts
index ded1a9603..c72488b71 100644
--- a/packages/agent-core-v2/test/spine/archive.test.ts
+++ b/packages/agent-core-v2/test/spine/archive.test.ts
@@ -2,10 +2,10 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { MASTER_ENV } from '#/app/flag/flagService';
 import {
-  AGENT_WIRE_PROTOCOL_VERSION,
+  WIRE_PROTOCOL_VERSION,
   IAgentSpineService,
-  IAgentWireService,
-  type PersistedWireRecord,
+  IWireService,
+  type WireRecord,
 } from '#/index';
 
 import {
@@ -83,12 +83,10 @@ describe('Spine archive + resume', () => {
     await ctx.rpc.prompt({ input: [{ type: 'text', text: 'start' }] });
     await ctx.untilTurnEnd();
 
-    // Upstream's wire persists through an async persistQueue (blob dehydrate
-    // hop runs even without blobs) that only drains on the wire service's own
-    // flush; the wireRecord service flush no longer covers it, so cloning the
-    // persistence before an `IAgentWireService` flush misses the records.
-    await ctx.get(IAgentWireService).flush();
-    await ctx.wireRecord.flush();
+    // The wire persists through an async persistQueue (the blob dehydrate hop
+    // runs even without blobs) that only drains on the service's own flush, so
+    // cloning the persistence before an `IWireService` flush misses records.
+    await ctx.wire.flush();
 
     const before = readSpine(ctx);
     const resumed = testAgent(
@@ -140,10 +138,10 @@ function cloneRecords<T>(records: readonly T[]): T[] {
   return records.map((record) => structuredClone(record));
 }
 
-function withMetadata(records: readonly PersistedWireRecord[]): PersistedWireRecord[] {
+function withMetadata(records: readonly WireRecord[]): WireRecord[] {
   if (records[0]?.type === 'metadata') return [...records];
   return [
-    { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
+    { type: 'metadata', protocol_version: WIRE_PROTOCOL_VERSION, created_at: 1 },
     ...records,
   ];
 }
diff --git a/packages/agent-core-v2/test/spine/compaction.test.ts b/packages/agent-core-v2/test/spine/compaction.test.ts
index 65bab1fff..6d9b750ab 100644
--- a/packages/agent-core-v2/test/spine/compaction.test.ts
+++ b/packages/agent-core-v2/test/spine/compaction.test.ts
@@ -60,7 +60,7 @@ describe('Spine / compaction interaction', () => {
     await ctx.rpc.beginCompaction({});
     await completed;
 
-    const recordTypes = ctx.recordHistory.map((record) => record.type);
+    const recordTypes = (await ctx.wireHistory()).map((record) => record.type);
     // The derivation reads the boundary from the summary message itself — no
     // tree op is dispatched for a root compaction any more.
     expect(recordTypes).not.toContain('spine.root_compact');
@@ -133,7 +133,7 @@ describe('Spine / compaction interaction', () => {
     await ctx.rpc.beginCompaction({});
     await completed;
 
-    const recordTypes = ctx.recordHistory.map((record) => record.type);
+    const recordTypes = (await ctx.wireHistory()).map((record) => record.type);
     expect(recordTypes).not.toContain('spine.root_compact');
     expect(recordTypes).toContain('full_compaction.complete');
     // The failed epoch archive write is tracked, so the tree view publishes no
diff --git a/packages/agent-core-v2/test/spine/fold.test.ts b/packages/agent-core-v2/test/spine/fold.test.ts
index eff633e36..9b8fc8ef5 100644
--- a/packages/agent-core-v2/test/spine/fold.test.ts
+++ b/packages/agent-core-v2/test/spine/fold.test.ts
@@ -9,7 +9,7 @@ import { collectSpanUserRequests } from '#/agent/spine/spineFold';
 import { MASTER_ENV } from '#/app/flag/flagService';
 import {
   ACCEPTED_OUTPUT,
-  AGENT_WIRE_PROTOCOL_VERSION,
+  WIRE_PROTOCOL_VERSION,
   appendSpineView,
   assembleMemoryBody,
   closedChildMemories,
@@ -18,14 +18,14 @@ import {
   IAgentLLMRequesterService,
   IAgentProfileService,
   IAgentSpineService,
-  IAgentWireService,
+  IWireService,
   loadSpineViewOverride,
   spineClose,
   SpineModel,
   spineNext,
   spineOpen,
   spineRootCompact,
-  type PersistedWireRecord,
+  type WireRecord,
 } from '#/index';
 
 import {
@@ -718,8 +718,7 @@ describe('Spine legacy-op restore compat', () => {
       { kind: 'spine_close', id: '2.1.2', memory: 'mem C' },
       { kind: 'user', text: 'tail' },
     ]);
-    await ctx.get(IAgentWireService).flush();
-    await ctx.wireRecord.flush();
+    await ctx.wire.flush();
 
     const resumed = testAgent(
       execEnvServices({ hostFs: recordingHostFs(new Map()) }),
@@ -733,7 +732,7 @@ describe('Spine legacy-op restore compat', () => {
     // the same tree the persisted legacy ops replay into: the derivation is
     // the single source of truth and the ops are now inert records.
     expect(resumed.get(IAgentSpineService).currentState()).toEqual(
-      resumed.get(IAgentWireService).getModel(SpineModel),
+      resumed.get(IWireService).getModel(SpineModel),
     );
   });
 });
@@ -751,10 +750,10 @@ function cloneRecords<T>(records: readonly T[]): T[] {
   return records.map((record) => structuredClone(record));
 }
 
-function withMetadata(records: readonly PersistedWireRecord[]): PersistedWireRecord[] {
+function withMetadata(records: readonly WireRecord[]): WireRecord[] {
   if (records[0]?.type === 'metadata') return [...records];
   return [
-    { type: 'metadata', protocol_version: AGENT_WIRE_PROTOCOL_VERSION, created_at: 1 },
+    { type: 'metadata', protocol_version: WIRE_PROTOCOL_VERSION, created_at: 1 },
     ...records,
   ];
 }
@@ -938,7 +937,7 @@ type LogicalEvent =
   | { readonly kind: 'root_compact'; readonly epoch: number; readonly summary: string };
 
 function replaySession(ctx: TestAgentContext, events: readonly LogicalEvent[]): void {
-  const wire = ctx.get(IAgentWireService);
+  const wire = ctx.get(IWireService);
   for (const event of events) {
     switch (event.kind) {
       case 'user':
@@ -1032,7 +1031,7 @@ function assembleClosingMemory(
   closedAt: number,
   nodeMemory: string,
 ): string {
-  const state = ctx.get(IAgentWireService).getModel(SpineModel);
+  const state = ctx.get(IWireService).getModel(SpineModel);
   const node = state.nodes[nodeId];
   if (node === undefined) return nodeMemory;
   return assembleMemoryBody({
@@ -1047,7 +1046,7 @@ function assembleClosingMemory(
 // the equivalence the reducer rewrite must preserve.
 function expectDerivationMatchesOps(ctx: TestAgentContext): void {
   expect(deriveSpineState(ctx.context.get())).toEqual(
-    ctx.get(IAgentWireService).getModel(SpineModel),
+    ctx.get(IWireService).getModel(SpineModel),
   );
 }
 
diff --git a/packages/agent-core-v2/test/spine/spine.test.ts b/packages/agent-core-v2/test/spine/spine.test.ts
index f4864b101..64e78efb3 100644
--- a/packages/agent-core-v2/test/spine/spine.test.ts
+++ b/packages/agent-core-v2/test/spine/spine.test.ts
@@ -19,7 +19,7 @@ import type { ServicesAccessor } from '#/_base/di/instantiation';
 import type { ContextMessage } from '#/agent/contextMemory/types';
 import {
   IAgentSpineService,
-  IAgentWireService,
+  IWireService,
   SPINE_VOID_OPENED_AT,
   SpineModel,
   spineClose,
@@ -100,7 +100,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('opens a child under the cursor and tracks parent linkage', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
 
     wire.dispatch(spineOpen({ id: '1.1.1', summary: 'task A', parentId: '1.1', openedAt: 0 }));
 
@@ -113,7 +113,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('closes the cursor and pops the open stack', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     wire.dispatch(spineOpen({ id: '1.1.1', summary: 'task A', parentId: '1.1', openedAt: 0 }));
 
     const before = readOps(ctx);
@@ -128,7 +128,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('closes the startup node like any work node', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
 
     wire.dispatch(spineClose({ id: '1.1', closedAt: 3, memory: 'startup done' }));
 
@@ -140,7 +140,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('repairs spans and the epoch boundary at a truncation cut', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     wire.dispatch(spineOpen({ id: '1.1.1', summary: 'task A', parentId: '1.1', openedAt: 2 }));
     wire.dispatch(spineClose({ id: '1.1.1', closedAt: 9, memory: 'did A' }));
     wire.dispatch(spineOpen({ id: '1.1.2', summary: 'task B', parentId: '1.1', openedAt: 10 }));
@@ -165,7 +165,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('keeps the epoch boundary when the cut stays after it', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     wire.dispatch(spineOpen({ id: '1.1.1', summary: 'task A', parentId: '1.1', openedAt: 22 }));
     wire.dispatch(spineClose({ id: '1.1.1', closedAt: 30, memory: 'did A' }));
     wire.dispatch(spineRootCompact({ epoch: 2, epochStartAt: 20, epochMemoryAt: 19 }));
@@ -183,7 +183,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('keeps a same-shape state on a repair that changes nothing', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     wire.dispatch(spineOpen({ id: '1.1.1', summary: 'task A', parentId: '1.1', openedAt: 2 }));
     const before = readOps(ctx);
 
@@ -194,7 +194,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('rejects closing a root epoch (no-op, same reference)', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     const before = readOps(ctx);
 
     wire.dispatch(spineClose({ id: '1', closedAt: 5, memory: 'nope' }));
@@ -204,7 +204,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('rejects closing a node that is not the cursor', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     wire.dispatch(spineOpen({ id: '1.1.1', summary: 'task A', parentId: '1.1', openedAt: 0 }));
     const before = readOps(ctx);
 
@@ -215,7 +215,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('commits next atomically (close cursor, open sibling under the same parent)', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     wire.dispatch(spineOpen({ id: '1.1.1', summary: 'task A', parentId: '1.1', openedAt: 0 }));
 
     wire.dispatch(
@@ -241,7 +241,7 @@ describe('Spine reducers (via wire)', () => {
 
   it('rejects opening under a parent that is not the cursor', () => {
     const ctx = testAgent();
-    const wire = ctx.get(IAgentWireService);
+    const wire = ctx.get(IWireService);
     const before = readOps(ctx);
 
     wire.dispatch(spineOpen({ id: '1.2', summary: 'task X', parentId: '1', openedAt: 0 }));
@@ -804,7 +804,7 @@ function readSpine(ctx: TestAgentContext) {
 
 // The legacy op reducers are exercised directly against the wire model.
 function readOps(ctx: TestAgentContext) {
-  return ctx.get(IAgentWireService).getModel(SpineModel);
+  return ctx.get(IWireService).getModel(SpineModel);
 }
 
 function spineToolNames(ctx: TestAgentContext): string[] {
diff --git a/packages/agent-core-v2/test/tool/result-builder.test.ts b/packages/agent-core-v2/test/tool/result-builder.test.ts
index 5030c6a19..b5f763315 100644
--- a/packages/agent-core-v2/test/tool/result-builder.test.ts
+++ b/packages/agent-core-v2/test/tool/result-builder.test.ts
@@ -11,7 +11,7 @@ describe('ToolResultBuilder', () => {
 
     const result = builder.ok('Operation completed');
     expect(result.output).toBe('Hello world');
-    expect(result.message).toBe('Operation completed.');
+    expect(result.truncated).toBe(false);
     expect(builder.nChars).toBe(11);
   });
 
@@ -24,10 +24,8 @@ describe('ToolResultBuilder', () => {
 
     const result = builder.ok('Operation completed');
     expect(result.output).toContain('Hello[...truncated]');
-    expect(result.output).toContain('Output is truncated');
+    expect(result.output).toContain('Operation completed.');
     expect(result.output.endsWith('Output is truncated to fit in the message.')).toBe(true);
-    expect(result.message).toContain('Operation completed.');
-    expect(result.message).toContain('Output is truncated');
     expect(result.truncated).toBe(true);
   });
 
@@ -38,7 +36,7 @@ describe('ToolResultBuilder', () => {
 
     const result = builder.ok();
     expect(result.output).toContain('[...truncated]');
-    expect(result.message).toContain('Output is truncated');
+    expect(result.output).toContain('Output is truncated');
   });
 
   it('respects both per-line and per-buffer limits at once', () => {
@@ -51,7 +49,7 @@ describe('ToolResultBuilder', () => {
 
     const result = builder.ok();
     expect(result.output).toContain('[...truncated]');
-    expect(result.message).toContain('Output is truncated');
+    expect(result.output).toContain('Output is truncated');
   });
 
   it('tracks nChars as the buffer grows', () => {
@@ -88,7 +86,7 @@ describe('ToolResultBuilder', () => {
 
     const result = builder.ok();
     expect(result.output).toContain('Hello\n[...truncated]');
-    expect(result.message).toContain('Output is truncated');
+    expect(result.output).toContain('Output is truncated');
   });
 
   it('keeps unterminated trailing text in output', () => {
@@ -115,7 +113,6 @@ describe('ToolResultBuilder', () => {
 
     expect(result.output).toContain('Some output');
     expect(result.output).toContain('Something went wrong');
-    expect(result.message).toBe('Something went wrong');
   });
 
   it('preserves the truncation hint on error', () => {
@@ -125,8 +122,8 @@ describe('ToolResultBuilder', () => {
     const result = builder.error('Command failed');
 
     expect(result.output).toContain('[...truncated]');
-    expect(result.message).toContain('Command failed');
-    expect(result.message).toContain('Output is truncated');
+    expect(result.output).toContain('Command failed');
+    expect(result.output).toContain('Output is truncated');
   });
 
   it('returns executable output with critical messages included', () => {
@@ -136,8 +133,8 @@ describe('ToolResultBuilder', () => {
     const result = builder.ok('Operation completed');
 
     expect(result.output).toContain('[...truncated]');
+    expect(result.output).toContain('Operation completed.');
     expect(result.output).toContain('Output is truncated');
-    expect(result.message).toContain('Output is truncated');
   });
 
   it('keeps normal success messages out of non-empty output', () => {
@@ -147,6 +144,5 @@ describe('ToolResultBuilder', () => {
     const result = builder.ok('Command executed successfully.');
 
     expect(result.output).toBe('ok\n');
-    expect(result.message).toBe('Command executed successfully.');
   });
 });
diff --git a/packages/agent-core-v2/test/tool/tool.test.ts b/packages/agent-core-v2/test/tool/tool.test.ts
index 35688af5b..c44762cff 100644
--- a/packages/agent-core-v2/test/tool/tool.test.ts
+++ b/packages/agent-core-v2/test/tool/tool.test.ts
@@ -8,6 +8,7 @@ import { Event, type Event as KimiEvent } from '#/_base/event';
 import { ILogService } from '#/_base/log/log';
 import { toInputJsonSchema } from '#/tool/input-schema';
 import { userCancellationReason } from '#/_base/utils/abort';
+import { createHooks } from '#/hooks';
 import type { ToolCall } from '#/app/llmProtocol/message';
 import type { TokenUsage } from '#/app/llmProtocol/usage';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -31,6 +32,7 @@ import {
   AgentToolInputSchema,
   type AgentToolInput,
 } from '#/session/subagent/tools/agent';
+import { DEFAULT_SUBAGENT_TIMEOUT_MS } from '#/session/subagent/configSection';
 import { runAgentTurn } from '#/session/subagent/runAgentTurn';
 import { emitAgentRunSpawned, mirrorAgentRun } from '#/session/subagent/mirrorAgentRun';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
@@ -51,7 +53,7 @@ import type {
   SessionSwarmRunResult,
 } from '#/session/swarm/sessionSwarm';
 import type { IProcess, ISessionProcessRunner } from '#/session/process/processRunner';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 import { createFakeProcessRunner } from '../tools/fixtures/fake-exec';
 import {
   configServices,
@@ -227,17 +229,16 @@ function createAgentLifecycleStub(options: AgentLifecycleStubOptions = {}): Agen
             unregister: () => {},
           } as never;
         }
-        if (serviceId === IAgentWireService) {
+        if (serviceId === IWireService) {
           return {
             _serviceBrand: undefined,
+            hooks: createHooks(['onDidRestore']),
             dispatch: () => {},
             replay: async () => {},
             flush: async () => {},
-            attach: () => noopDisposable(),
             getModel: () => [],
             subscribe: () => noopDisposable(),
             onEmission: () => noopDisposable(),
-            onRestored: () => noopDisposable(),
           } as never;
         }
         return undefined as never;
@@ -355,9 +356,8 @@ function sessionMetadataStub(agents: Readonly<Record<string, AgentMeta>>): ISess
   };
 }
 
-function subagentMeta(agentId: string, parentAgentId = 'main'): AgentMeta {
+function subagentMeta(parentAgentId = 'main'): AgentMeta {
   return {
-    homedir: `/tmp/kimi-test/agents/${agentId}`,
     labels: { parentAgentId },
   };
 }
@@ -451,7 +451,7 @@ describe('Agent tool description', () => {
 
     const description = agentDescription();
 
-    expect(description).toContain('fixed 30-minute timeout');
+    expect(description).toContain('fixed 2-hour timeout');
     expect(description).not.toContain('operator-configured background timeout');
     expect(description).not.toContain('no time limit');
     expect(description).toContain('Default to a foreground subagent');
@@ -720,7 +720,7 @@ describe('Agent tool execution contract', () => {
       lifecycle,
       sessionService(
         ISessionMetadata,
-        sessionMetadataStub({ 'agent-existing': subagentMeta('agent-existing') }),
+        sessionMetadataStub({ 'agent-existing': subagentMeta() }),
       ),
     );
     lifecycle.addHandle('agent-existing', 'explore');
@@ -749,7 +749,7 @@ describe('Agent tool execution contract', () => {
       sessionService(
         ISessionMetadata,
         sessionMetadataStub({
-          main: { homedir: '/tmp/kimi-test/agents/main', type: 'main' },
+          main: { type: 'main' },
         }),
       ),
     );
@@ -774,7 +774,7 @@ describe('Agent tool execution contract', () => {
       lifecycle,
       sessionService(
         ISessionMetadata,
-        sessionMetadataStub({ 'agent-existing': subagentMeta('agent-existing', 'other') }),
+        sessionMetadataStub({ 'agent-existing': subagentMeta('other') }),
       ),
     );
     lifecycle.addHandle('agent-existing', 'explore');
@@ -798,7 +798,7 @@ describe('Agent tool execution contract', () => {
       lifecycle,
       sessionService(
         ISessionMetadata,
-        sessionMetadataStub({ 'agent-existing': subagentMeta('agent-existing') }),
+        sessionMetadataStub({ 'agent-existing': subagentMeta() }),
       ),
     );
     lifecycle.addHandle(
@@ -843,7 +843,7 @@ describe('Agent tool execution contract', () => {
       lifecycle,
       sessionService(
         ISessionMetadata,
-        sessionMetadataStub({ 'agent-existing': subagentMeta('agent-existing') }),
+        sessionMetadataStub({ 'agent-existing': subagentMeta() }),
       ),
     );
     lifecycle.addHandle(
@@ -888,7 +888,7 @@ describe('Agent tool execution contract', () => {
     expect(context.get(IAgentTaskService).getTask(taskId!)).toMatchObject({
       status: 'running',
       description: 'Find cause',
-      timeoutMs: 30 * 60 * 1000,
+      timeoutMs: DEFAULT_SUBAGENT_TIMEOUT_MS,
     });
     completion.resolve({ summary: 'finished later' });
   });
@@ -1256,10 +1256,36 @@ describe('Agent tool execution contract', () => {
 
     expect(result.isError).toBe(true);
     expect(result.output).toContain('status: failed');
-    expect(result.output).not.toContain('was stopped by the user');
-    expect(result.output).toContain('not a system error');
-    expect(result.output).toContain('capacity');
-    expect(result.output).toContain('wait for the user');
+    expect(result.output).toContain('The subagent was stopped before it finished by user.');
+  });
+
+  it('reports the reason when a foreground subagent is stopped for another cause', async () => {
+    const lifecycle = createAgentLifecycleStub({
+      createAgentIds: ['agent-child'],
+      runCompletion: (_agentId, _request, options) =>
+        new Promise((_resolve, reject) => {
+          options.signal.addEventListener('abort', () => reject(options.signal.reason), {
+            once: true,
+          });
+        }),
+    });
+    const context = createAgentToolContext(lifecycle);
+
+    const resultPromise = executeAgentTool(context, {
+      prompt: 'Investigate',
+      description: 'Find cause',
+    });
+    await vi.waitFor(() => {
+      expect(context.get(IAgentTaskService).list(false)).toHaveLength(1);
+    });
+    const [task] = context.get(IAgentTaskService).list(false);
+    await context.get(IAgentTaskService).stop(task!.taskId, 'Session closed');
+    const result = await resultPromise;
+
+    expect(result.isError).toBe(true);
+    expect(result.output).toContain(
+      'The subagent was stopped before it finished. Reason: Session closed',
+    );
   });
 
   it('returns the spawned agent id when a foreground subagent times out', async () => {
@@ -1286,19 +1312,52 @@ describe('Agent tool execution contract', () => {
     await vi.waitFor(() => {
       expect(context.get(IAgentTaskService).list(false)).toHaveLength(1);
     });
-    await vi.advanceTimersByTimeAsync(30 * 60 * 1000);
+    await vi.advanceTimersByTimeAsync(DEFAULT_SUBAGENT_TIMEOUT_MS);
     const result = await resultPromise;
 
     expect(result).toMatchObject({ isError: true });
     expect(result.output).toContain('agent_id: agent-child');
     expect(result.output).toContain('actual_subagent_type: coder');
     expect(result.output).toContain('status: failed');
-    expect(result.output).toContain('subagent error: Agent timed out after 30 minutes.');
+    expect(result.output).toContain('subagent error: Agent timed out after 2 hours.');
     expect(result.output).toContain('resume_hint:');
     expect(result.output).toContain('Agent(resume="agent-child", prompt="continue")');
     expect(result.output).toContain('do not set subagent_type');
     expect(result.output).toContain('retains its prior context');
   });
+
+  it('honours the configured subagent timeout over the default', async () => {
+    vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+    const lifecycle = createAgentLifecycleStub({
+      createAgentIds: ['agent-child'],
+      runCompletion: (_agentId, _request, options) =>
+        new Promise((_resolve, reject) => {
+          options.signal.addEventListener(
+            'abort',
+            () => {
+              reject(options.signal.reason);
+            },
+            { once: true },
+          );
+        }),
+    });
+    const context = createAgentToolContext(lifecycle, {
+      initialConfig: { subagent: { timeoutMs: 1000 } },
+    });
+
+    const resultPromise = executeAgentTool(context, {
+      prompt: 'Investigate',
+      description: 'Find cause',
+    });
+    await vi.waitFor(() => {
+      expect(context.get(IAgentTaskService).list(false)).toHaveLength(1);
+    });
+    await vi.advanceTimersByTimeAsync(1000);
+    const result = await resultPromise;
+
+    expect(result).toMatchObject({ isError: true });
+    expect(result.output).toContain('subagent error: Agent timed out after 1 second.');
+  });
 });
 
 describe('AgentSwarmToolInputSchema', () => {
@@ -1447,7 +1506,7 @@ describe('AgentSwarm tool execution contract', () => {
           swarmItem: 'src/a.ts',
           runInBackground: false,
           signal,
-          timeout: 30 * 60 * 1000,
+          timeout: DEFAULT_SUBAGENT_TIMEOUT_MS,
         },
         {
           kind: 'spawn',
@@ -1460,7 +1519,7 @@ describe('AgentSwarm tool execution contract', () => {
           swarmItem: 'src/b.ts',
           runInBackground: false,
           signal,
-          timeout: 30 * 60 * 1000,
+          timeout: DEFAULT_SUBAGENT_TIMEOUT_MS,
         },
       ],
     });
@@ -1547,7 +1606,7 @@ describe('AgentSwarm tool execution contract', () => {
           runInBackground: false,
           resumeAgentId: 'agent-old-1',
           signal,
-          timeout: 30 * 60 * 1000,
+          timeout: DEFAULT_SUBAGENT_TIMEOUT_MS,
         },
         {
           kind: 'resume',
@@ -1567,7 +1626,7 @@ describe('AgentSwarm tool execution contract', () => {
           runInBackground: false,
           resumeAgentId: 'agent-old-2',
           signal,
-          timeout: 30 * 60 * 1000,
+          timeout: DEFAULT_SUBAGENT_TIMEOUT_MS,
         },
         {
           kind: 'spawn',
@@ -1585,7 +1644,7 @@ describe('AgentSwarm tool execution contract', () => {
           swarmItem: 'src/new.ts',
           runInBackground: false,
           signal,
-          timeout: 30 * 60 * 1000,
+          timeout: DEFAULT_SUBAGENT_TIMEOUT_MS,
         },
       ],
     });
@@ -2230,27 +2289,28 @@ describe('Agent tools', () => {
         [wire] tools.register_user_tool    { "name": "Lookup", "description": "Look up a short test value.", "parameters": { "type": "object", "properties": { "query": { "type": "string" } }, "required": [ "query" ], "additionalProperties": false }, "time": "<time>" }
         [wire] turn.prompt                 { "input": [ { "type": "text", "text": "Look up moon" } ], "origin": { "kind": "user" }, "time": "<time>" }
         [emit] turn.started                { "turnId": 0, "origin": { "kind": "user" } }
-        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Look up moon" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 5, "rawContextTokens": 5 }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [emit] context.spliced             { "start": 0, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Look up moon" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" } ] }
-        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "<auto-mode-enter-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "permission_mode" } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 140, "rawContextTokens": 140 }
+        [emit] agent.status.updated        { "contextTokens": 5, "rawContextTokens": 5 }
+        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "Look up moon" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-1>" }, "time": "<time>" }
         [emit] context.spliced             { "start": 1, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "<auto-mode-enter-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "permission_mode" } } ] }
+        [emit] agent.status.updated        { "contextTokens": 140, "rawContextTokens": 140 }
+        [wire] context.append_message      { "message": { "role": "user", "content": [ { "type": "text", "text": "<auto-mode-enter-reminder>" } ], "toolCalls": [], "origin": { "kind": "injection", "variant": "permission_mode" } }, "time": "<time>" }
         [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 140, "rawContextTokens": 143 }
-        [wire] llm.tools_snapshot          { "hash": "de7a41992b98f517933310ee33535fc82fa1e5896e657e789de0b0c8a8749564", "tools": [ { "name": "Agent", "description": "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\\n\\nWriting the prompt:\\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\\n\\nUsage notes:\\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its \`resume\` id) over spawning a fresh instance — the resumed agent keeps its prior context.\\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\\n- Subagents use a fixed 30-minute timeout. If one times out, resume the same agent instead of starting over.\\n\\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\\n\\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\\n\\n\\nWhen \`run_in_background=true\`, the subagent runs detached from this turn. The completion arrives in a later turn as a synthetic user-role message containing its result — you do not need to poll, sleep, or check on its progress. Continue with other work or respond to the user. Never fabricate or predict what the result will say.\\n\\nDefault to a foreground subagent (omit \`run_in_background\`) when your next step needs its result — foreground hands the result straight back. Reach for \`run_in_background=true\` only when you have other work to do while it runs and do not need its result to proceed. Never launch in the background and then immediately wait on it (with \`TaskOutput block=true\`, sleeping, or otherwise): that just blocks the turn for no benefit — run it in the foreground instead.\\n\\n\\nAvailable agent types (pass via subagent_type):\\n- plan: Read-only implementation planning and architecture design. Use this agent when the parent agent needs a step-by-step implementation plan, key file identification, and architectural trade-off analysis before code changes are made.\\n  Tools: Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL\\n- agent: Default Kimi Code agent\\n  Tools: Read, Write, Edit, Grep, Glob, Bash, TaskList, TaskOutput, TaskStop, CronCreate, CronList, CronDelete, ReadMediaFile, TodoList, Skill, WebSearch, Agent, AgentSwarm, FetchURL, AskUserQuestion, EnterPlanMode, ExitPlanMode, CreateGoal, GetGoal, SetGoalBudget, UpdateGoal, mcp__*, spine_open, spine_close, spine_next, spine_tree\\n- coder: General software engineering agent — the only subagent type with file-editing tools; use it for any delegated task that must modify code. Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.\\n  Tools: Agent, AgentSwarm, Bash, CronCreate, CronDelete, CronList, Edit, EnterPlanMode, ExitPlanMode, Glob, Grep, Read, ReadMediaFile, Skill, TaskList, TaskOutput, TaskStop, TodoList, WebSearch, FetchURL, Write, mcp__*\\n- explore: Fast codebase exploration with prompt-enforced read-only behavior. Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (e.g. \\"src/**/*.yaml\\"), search code for keywords (e.g. \\"database connection\\"), or answer questions about the codebase (e.g. \\"how does the auth module work?\\"). When calling this agent, specify the desired thoroughness level: \\"quick\\" for basic searches, \\"medium\\" for moderate exploration, or \\"thorough\\" for comprehensive analysis across multiple locations and naming conventions. Use this agent for any read-only exploration that will clearly require more than 3 search queries. Prefer launching multiple explore agents concurrently when investigating independent questions.\\n  Tools: Bash, Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "prompt": { "type": "string", "description": "Full task prompt for the subagent" }, "description": { "type": "string", "description": "Short task description (3-5 words) for UI display" }, "subagent_type": { "description": "One of the available agent types (see \\"Available agent types\\" in this tool description). Defaults to \\"coder\\" when omitted.", "type": "string" }, "resume": { "description": "Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected.", "type": "string" }, "run_in_background": { "description": "If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting.", "type": "boolean" } }, "required": [ "prompt", "description" ], "additionalProperties": false } }, { "name": "AgentSwarm", "description": "Launch multiple subagents from one prompt template, existing agent resumes, or both.\\n\\nUse AgentSwarm when many subagents should run the same kind of task over different inputs. The placeholder is exactly \`{{item}}\`. For example, with \`prompt_template\` set to \`Review {{item}} for likely regressions.\` and \`items\` set to \`[\\"src/a.ts\\", \\"src/b.ts\\"]\`, AgentSwarm launches two new subagents with those two concrete prompts. For a few differently-shaped tasks, make separate \`Agent\` calls in one message instead.\\n\\nUse \`resume_agent_ids\` to continue subagents that already exist from earlier work, such as ones that failed or timed out: map each agent id to the prompt for that resumed subagent (usually \`continue\` if no extra information is needed). You may combine \`resume_agent_ids\` with \`items\` in the same call to resume existing subagents and launch new ones. Do not duplicate resumed work in \`items\`.\\n\\nEach of these is enforced — a violation is rejected before any subagent starts: provide at least 2 \`items\` unless you pass \`resume_agent_ids\`; whenever \`items\` are present, \`prompt_template\` is required and must contain \`{{item}}\`; and the filled-in prompts must be distinct (two items that expand to the same prompt are rejected).\\n\\nUse enough subagents to keep the work focused and parallel. AgentSwarm supports up to 128 subagents, and launches are queued automatically, so it is safe to split large tasks into many clear, independent items.\\n\\nIf \`AgentSwarm\` is called, that call must be the only tool call in the response.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "description": { "type": "string", "minLength": 1, "description": "Short description for the whole swarm." }, "subagent_type": { "description": "Subagent type used for every new subagent spawned from items; defaults to coder when omitted. Resumed subagents always keep their original type, so passing subagent_type together with resume_agent_ids is allowed — it only affects the item-based spawns.", "type": "string", "minLength": 1 }, "prompt_template": { "description": "Prompt template for each subagent. The {{item}} placeholder is replaced with each item value.", "type": "string", "minLength": 1 }, "items": { "description": "Values used to fill {{item}}. Each item launches one new subagent.", "maxItems": 128, "type": "array", "items": { "type": "string", "minLength": 1 } }, "resume_agent_ids": { "description": "Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents.", "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "type": "string", "minLength": 1 } } }, "required": [ "description" ], "additionalProperties": false } }, { "name": "AskUserQuestion", "description": "Use this tool when you need to ask the user questions with structured options during execution. This allows you to:\\n1. Collect user preferences or requirements before proceeding\\n2. Resolve ambiguous or underspecified instructions\\n3. Let the user decide between implementation approaches as you work\\n4. Present concrete options when multiple valid directions exist\\n\\n**When NOT to use:**\\n- When you can infer the answer from context — be decisive and proceed\\n- Trivial decisions that don't materially affect the outcome\\n\\nOverusing this tool interrupts the user's flow. Only use it when the user's input genuinely changes your next action.\\n\\n**Usage notes:**\\n- Users always have an \\"Other\\" option for custom input — don't create one yourself\\n- Use multi_select to allow multiple answers to be selected for a question\\n- Keep option labels concise (1-5 words), use descriptions for trade-offs and details\\n- Each question should have 2-4 meaningful, distinct options\\n- Question texts must be unique across the call, and option labels must be unique within each question\\n- You can ask 1-4 questions at a time; group related questions to minimize interruptions\\n- If you recommend a specific option, list it first and append \\"(Recommended)\\" to its label\\n- The result is JSON with an \`answers\` object keyed by question text; each value is the chosen option's label (comma-separated labels for multi_select, or the user's own words if they picked \\"Other\\"); if \`answers\` is empty and a \`note\` says the user dismissed it, they chose not to answer — do not treat this as selecting the recommended option; decide based on context and do not re-ask the same question\\n- Set background=true when you can keep working without the answer. This starts a background question task and returns a task_id immediately. The answer arrives automatically in a later turn — you do not need to poll, sleep, or check on it. Continue with other work; never fabricate or predict the answer.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "questions": { "minItems": 1, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "question": { "type": "string", "minLength": 1, "description": "A specific, actionable question. End with '?'." }, "header": { "default": "", "description": "Short category tag (max 12 chars, e.g. 'Auth', 'Style').", "type": "string" }, "options": { "minItems": 2, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "description": "Concise display text (1-5 words). If recommended, append '(Recommended)'." }, "description": { "default": "", "description": "Brief explanation of trade-offs or implications.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false }, "description": "2-4 meaningful, distinct options. Do NOT include an 'Other' option — the system adds one automatically." }, "multi_select": { "default": false, "description": "Whether the user can select multiple options.", "type": "boolean" } }, "required": [ "question", "options" ], "additionalProperties": false }, "description": "The questions to ask the user (1-4 questions)." }, "background": { "default": false, "description": "Set true to ask in the background and return immediately with a background task_id; you are notified automatically when the user answers — do not poll with TaskOutput while the question is pending.", "type": "boolean" } }, "required": [ "questions" ], "additionalProperties": false } }, { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nIf \`run_in_background=true\`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short \`description\`. Background commands default to a 600s timeout and \`timeout\` is capped at 86400s; set \`disable_timeout=true\` only when the task should run without a timeout. You will be automatically notified when the task completes. After starting one, default to returning control to the user instead of immediately waiting on it. Use \`TaskOutput\` only for a non-blocking status/output snapshot — do not set \`block=true\` to wait for a task you just launched, since its completion arrives automatically; reserve \`block=true\` for when the user explicitly asked you to wait. Use \`TaskStop\` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the \`/tasks\` command, which opens an interactive panel; it has no subcommands.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the \`timeout\` argument in seconds. Foreground commands default to 60s and allow up to 300s. When a foreground command hits its timeout it is moved to the background instead of being killed, and you will be automatically notified when it completes.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Prefer \`run_in_background=true\` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } }, { "name": "CreateGoal", "description": "Create a durable, structured goal that the runtime will pursue across multiple turns.\\n\\nCall \`CreateGoal\` only when:\\n\\n- the user explicitly asks you to start a goal or work autonomously toward an outcome, or\\n- a host goal-intake prompt asks you to create one.\\n\\nDo NOT create a goal for greetings, ordinary questions, or vague requests that lack a\\nverifiable completion condition. A goal needs a checkable end state.\\n\\nWhen the request is vague, ask the user for the missing completion criterion before creating\\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\\nrespect that and create the goal.\\n\\nInclude a \`completionCriterion\` when the user provides one, or when it can be stated without\\ninventing new requirements. Keep \`objective\` concise; reference long task descriptions by file\\npath rather than pasting them.\\n\\nCreating a goal fails if one already exists, so use \`replace: true\` only when the user explicitly\\nwants to abandon the current goal and start a new one.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "objective": { "type": "string", "minLength": 1, "description": "The objective to pursue. Must have a verifiable end state." }, "completionCriterion": { "description": "How to verify the goal is complete. Include when the user provides one.", "type": "string" }, "replace": { "description": "Replace an existing active, paused, or blocked goal instead of failing.", "type": "boolean" } }, "required": [ "objective" ], "additionalProperties": false } }, { "name": "Edit", "description": "Perform exact replacements in existing files.\\n\\n- Edit is mandatory for every incremental change, especially small edits. DO NOT use Write or Bash \`sed\`.\\n- Read the target file before every Edit. DO NOT call Edit from memory, stale context, or a guessed \`old_string\`.\\n- Take \`old_string\` and \`new_string\` from the Read output view.\\n- Drop the line-number prefix and tab; match only file content.\\n- \`old_string\` must be unique unless \`replace_all\` is set.\\n- If \`old_string\` is ambiguous, add surrounding context. Use \`replace_all\` only when every occurrence should change — for example, renaming a symbol throughout the file.\\n- Multiple Edit calls may run in one response only when they do not target the same file.\\n- DO NOT issue consecutive Edit calls on the same file. A previous Edit can invalidate a later Edit's \`old_string\`, causing \`old_string not found\`. Read the file again before the next Edit.\\n- A write lock serializes same-file edits in response order, but serialization does not make stale \`old_string\` valid.\\n- For pure CRLF files, Read shows LF; use LF in \`old_string\` and \`new_string\`, and Edit writes CRLF back.\\n- For mixed endings or lone carriage returns, Read shows carriage returns as \\\\r; include actual \\\\r escapes in those positions.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the text file to edit. Relative paths resolve against the working directory; a path outside the working directory must be absolute." }, "old_string": { "type": "string", "minLength": 1, "description": "Exact content to replace from the Read output view, without the line-number prefix. Use LF for pure CRLF files; use actual \\\\r escapes where Read shows \\\\r." }, "new_string": { "type": "string", "description": "Replacement text in the same Read output view. LF is written back as CRLF only for pure CRLF files." }, "replace_all": { "description": "Set true only when every occurrence of old_string should be replaced.", "type": "boolean" } }, "required": [ "path", "old_string", "new_string" ], "additionalProperties": false } }, { "name": "EnterPlanMode", "description": "Use this tool proactively when you're about to start a non-trivial implementation task.\\nGetting user sign-off on your approach via ExitPlanMode before writing code prevents wasted effort.\\n\\nUse it when ANY of these conditions apply:\\n\\n1. New Feature Implementation - e.g. \\"Add a caching layer to the API\\"\\n2. Multiple Valid Approaches - e.g. \\"Optimize database queries\\" (indexing vs rewrite vs caching)\\n3. Code Modifications - e.g. \\"Refactor auth module to support OAuth\\"\\n4. Architectural Decisions - e.g. \\"Add WebSocket support\\"\\n5. Multi-File Changes - involves more than 2-3 files\\n6. Unclear Requirements - need exploration to understand scope\\n7. User Preferences Matter - if user input would materially change the implementation approach, use EnterPlanMode to structure the decision\\n\\nPermission mode notes:\\n- EnterPlanMode enters plan mode automatically without an approval prompt in all permission modes.\\n- In yolo and manual modes, ExitPlanMode still presents the plan to the user for approval.\\n- In auto permission mode, do not use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, ExitPlanMode exits plan mode without asking the user.\\n- Use EnterPlanMode only when planning itself adds value.\\n\\nWhen NOT to use:\\n- Single-line or few-line fixes (typos, obvious bugs, small tweaks)\\n- User gave very specific, detailed instructions\\n- Pure research/exploration tasks\\n\\nOnce you are in plan mode, a reminder walks you through the workflow (explore → design → write the plan file → \`ExitPlanMode\`) and enforces read-only access. For non-trivial tasks where you are unsure of the codebase structure or relevant code paths, use \`Agent(subagent_type=\\"explore\\")\` to investigate first when the \`Agent\` tool is available.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "ExitPlanMode", "description": "Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.\\n\\n## How This Tool Works\\n- You should have already written your plan to the plan file specified in the plan mode reminder.\\n- This tool does NOT take the plan content as a parameter - it reads the plan from the file you wrote.\\n- The user will see the contents of your plan file when they review it. In auto permission mode, the tool reads the file and exits plan mode without asking the user.\\n\\n## When to Use\\nOnly use this tool for tasks that require planning implementation steps. For research tasks (searching files, reading code, understanding the codebase), do NOT use this tool.\\n\\n## What a good plan contains\\nList specific, verifiable steps grounded in the actual codebase — real files, functions, and commands, in a sensible order. Each step should be concrete enough to act on and to check. Avoid vague filler like \\"improve performance\\" or \\"add tests\\"; say what to change and where.\\n\\n## Multiple Approaches\\nIf your plan offers multiple alternative approaches, pass them via the \`options\` parameter so the user can choose which one to execute — see the \`options\` parameter for the format, count, and reserved labels. In yolo and manual modes the user sees all options alongside the host's Reject and Revise controls.\\n\\n## Before Using\\n- In auto permission mode, do NOT use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, this tool exits plan mode without asking the user.\\n- In yolo and manual modes, this tool still presents the plan to the user for approval.\\n- If auto permission mode is not active and you have unresolved questions, use AskUserQuestion first.\\n- If auto permission mode is not active and you have multiple approaches and haven't narrowed down yet, consider using AskUserQuestion first to let the user choose, then write a plan for the chosen approach only.\\n- Once your plan is finalized, use THIS tool to request approval.\\n- Do NOT use AskUserQuestion to ask \\"Is this plan OK?\\" or \\"Should I proceed?\\" - that is exactly what ExitPlanMode does.\\n- If rejected, revise based on feedback and call ExitPlanMode again.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "options": { "description": "When the plan contains multiple alternative approaches, list them here so the user can choose which one to execute. Provide up to 3 options; 2-3 distinct approaches work best when the plan offers a real choice. Passing a single option is allowed and is equivalent to a plain plan approval. Each option represents a distinct approach from the plan. Do not use \\"Reject\\", \\"Revise\\", \\"Approve\\", or \\"Reject and Exit\\" as labels.", "minItems": 1, "maxItems": 3, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "maxLength": 80, "description": "Short name for this option (1-8 words). Append \\"(Recommended)\\" if you recommend this option." }, "description": { "default": "", "description": "Brief summary of this approach and its trade-offs.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "FetchURL", "description": "Fetch content from a URL. The content is returned either as the main text extracted from the page, or as the full response body verbatim; a note at the top of the result states which of the two you received, so you can judge how complete it is. Use this when you need to read a specific web page.\\n\\nOnly fully-formed public \`http\`/\`https\` URLs are supported; other schemes and private or loopback addresses are not fetched. Very large pages may be truncated or refused. The fetch carries no login or session for the target site, so pages behind authentication (private repositories, internal dashboards) return a login page or an error instead of the real content — if the text you get back looks like a generic landing or sign-in page, treat that as the login wall, not the answer, and reach the content through a credentialed route (an authenticated CLI or MCP tool) instead.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "url": { "type": "string", "description": "The URL to fetch content from." } }, "required": [ "url" ], "additionalProperties": false } }, { "name": "GetGoal", "description": "Read the current goal: its objective, completion criterion, status, and budgets (turns, tokens,\\ntime, and how much of each remains). When the goal has stopped, it also reports the terminal reason.\\n\\nUse \`GetGoal\` before deciding whether to continue working, report completion, report a blocker,\\nor respect a pause. It returns \`{ \\"goal\\": null }\` when there is no current goal.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "Glob", "description": "Find files by glob pattern, sorted by modification time (most recent first).\\n\\nPowered by ripgrep. Respects \`.gitignore\`, \`.ignore\`, and \`.rgignore\` by default — set \`include_ignored\` to also match ignored files (e.g. build outputs, \`node_modules\`). Sensitive files (such as \`.env\`) are always filtered out. Matches are files only — directories themselves are never listed; to find a directory, glob for a file inside it (e.g. \`**/fixtures/**\`).\\n\\nGood patterns:\\n- \`*.ts\` — all files matching an extension, at any depth below the search root (a bare pattern without \`/\` matches recursively)\\n- \`src/*.ts\` — files directly inside \`src/\` (one level, not recursive)\\n- \`src/**/*.ts\` — recursive walk with a subdirectory anchor and extension\\n- \`**/*.py\` — recursive walk from the search root for an extension\\n- \`*.{ts,tsx}\` — brace expansion is supported\\n- \`{src,test}/**/*.ts\` — cartesian brace expansion is supported too\\n\\nResults are capped at the first 100 matching paths. If a search would return more, a truncation marker is appended. Refine the pattern (extension, subdirectory) when 100 is not enough, or call again with a narrower anchor.\\n\\nLarge-directory caveat — avoid recursing into dependency / build output even with an anchor, especially when \`include_ignored\` is set:\\n- \`node_modules/**/*.js\`, \`.venv/**/*.py\`, \`__pycache__/**\`, \`target/**\` can produce thousands of results that truncate at the match cap and waste context. Prefer specific subpaths like \`node_modules/react/src/**/*.js\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Glob pattern to match files." }, "path": { "description": "Directory to search. Accepts an absolute path, or a path relative to the current working directory. Defaults to the current working directory.", "type": "string" }, "include_ignored": { "description": "Also match files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" }, "include_dirs": { "description": "Deprecated and ignored. Results are always files-only — directories are never listed. Accepted only so older calls that still pass this flag are not rejected by parameter validation.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Grep", "description": "Search file contents using regular expressions (powered by ripgrep).\\n\\nUse Grep when the task is to find unknown content or unknown file locations. Do not use shell \`grep\` or \`rg\` directly; this tool applies workspace path policy, output limits, and sensitive-file filtering.\\nALWAYS use Grep tool instead of running \`grep\` or \`rg\` from a shell — direct shell calls bypass workspace policy, output limits, and sensitive-file filtering.\\nIf you already know a concrete file path and need to inspect its contents, use Read directly instead.\\n\\nWrite patterns in ripgrep regex syntax, which differs from POSIX \`grep\` syntax. For example, braces are special, so escape them as \`\\\\{\` to match a literal \`{\`.\\n\\nHidden files (dotfiles such as \`.gitlab-ci.yml\` or \`.eslintrc.json\`) are searched by default. To also search files excluded by \`.gitignore\` (such as \`node_modules\` or build outputs), set \`include_ignored\` to \`true\`. Sensitive files (such as \`.env\`) are always skipped for safety, even when \`include_ignored\` is \`true\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Regular expression to search for." }, "path": { "description": "File or directory to search. Accepts an absolute path, or a path relative to the current working directory. Omit to search the current working directory. Use Read instead when you already know a concrete file path and need its contents.", "type": "string" }, "glob": { "description": "Optional glob filter for which files to search, e.g. \`*.ts\`. Matched against each file's full absolute path, so a path-anchored pattern like \`src/**/*.ts\` silently matches nothing — use a basename pattern (\`*.ts\`), or anchor with \`**/\` (\`**/src/**/*.ts\`). To scope the search to a directory, use \`path\` instead.", "type": "string" }, "type": { "description": "Optional ripgrep file type filter, such as ts or py. Prefer this over \`glob\` when filtering by language or file kind: it is more efficient and less error-prone than an equivalent glob pattern.", "type": "string" }, "output_mode": { "description": "Shape of the result. \`content\` shows matching lines (honors \`-A\`, \`-B\`, \`-C\`, \`-n\`, and \`head_limit\`); \`files_with_matches\` shows only the paths of files that contain a match, most-recently-modified first (honors \`head_limit\`); \`count_matches\` shows per-file match counts as \`path:count\` lines, preceded by an aggregate total line. Defaults to \`files_with_matches\`.", "type": "string", "enum": [ "content", "files_with_matches", "count_matches" ] }, "-i": { "description": "Perform a case-insensitive search. Defaults to false.", "type": "boolean" }, "-n": { "description": "Prefix each matching line with its line number. Applies only when \`output_mode\` is \`content\`. Defaults to true.", "type": "boolean" }, "-A": { "description": "Number of lines to show after each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-B": { "description": "Number of lines to show before each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-C": { "description": "Number of lines to show before and after each match. Applies only when \`output_mode\` is \`content\`; takes precedence over \`-A\` and \`-B\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "head_limit": { "description": "Limit output to the first N lines/entries after offset. Defaults to 250. Pass 0 for unlimited.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "offset": { "description": "Number of leading lines/entries to skip before applying \`head_limit\`. Use it together with \`head_limit\` to page through large result sets. Defaults to 0.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "multiline": { "description": "Enable multiline matching, where the pattern can span line boundaries and \`.\` also matches newlines. Defaults to false.", "type": "boolean" }, "include_ignored": { "description": "Also search files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Lookup", "description": "Look up a short test value.", "parameters": { "type": "object", "properties": { "query": { "type": "string" } }, "required": [ "query" ], "additionalProperties": false } }, { "name": "Read", "description": "Read a text file from the local filesystem.\\n\\nIf the user provides a concrete file path to a text file, call Read directly. Do not \`Glob\`, \`ls\`, or otherwise pre-check known text file paths; missing or invalid file paths return errors you can handle. Do not use Read for directories; use \`ls\` via Bash for a known directory, or Glob when you need files matching a name pattern (Glob lists files only, never directories). Use \`Grep\` only when the task is to search for unknown content or locations.\\n\\nWhen you need several files, prefer to read them in parallel: emit multiple \`Read\` calls in a single response instead of reading one file per turn.\\n\\n- Relative paths resolve against the working directory; a path outside the working directory must be absolute.\\n- Returns up to 1000 lines or 100 KB per call, whichever comes first; lines longer than 2000 chars are truncated mid-line.\\n- Page larger files with \`line_offset\` (1-based start line) and \`n_lines\`. Omit \`n_lines\` to read up to the 1000-line cap.\\n- Sensitive files (\`.env\` files, credential stores, SSH private keys, and similar secrets) are refused to protect secrets; do not attempt to read them. Templates and public keys are exempt: \`.env.example\` / \`.env.sample\` / \`.env.template\` and public SSH keys such as \`id_rsa.pub\` read normally.\\n- Only UTF-8 text files can be read. Non-UTF-8 encodings, binary files, and files containing NUL bytes are refused; use \`ReadMediaFile\` for images or video, and Bash or an MCP tool for other binary formats.\\n- Negative line_offset reads from the end of the file (for example, -100 reads the last 100 lines); the absolute value cannot exceed 1000.\\n- Output format: \`<line-number>\\\\t<content>\` per line.\\n- A \`<system>...</system>\` status block is appended after the file content; it summarizes how much was read (line and byte counts, truncation, line-ending notes) and is not part of the file itself.\\n- Pure CRLF files are displayed with LF line endings; \`Edit\` matches this output and preserves CRLF when writing back.\\n- Mixed or lone carriage-return line endings are shown as \`\\\\r\` and require exact \`Edit.old_string\` escapes.\\n- After a successful \`Edit\`/\`Write\`, do not re-read solely to prove the write landed. When the task depends on an exact file, API, or output shape, inspect the final external contract before finishing.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to a text file. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Directories are not supported; use \`ls\` via Bash for a known directory, or Glob for pattern search." }, "line_offset": { "description": "The line number to start reading from. Omit to start at line 1. Negative values read from the end of the file; the absolute value cannot exceed 1000.", "anyOf": [ { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, { "type": "integer", "minimum": -1000, "maximum": -1 } ] }, "n_lines": { "description": "The number of lines to read; the tool also applies its internal cap. Omit to read up to the internal cap of 1000 lines.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 } }, "required": [ "path" ], "additionalProperties": false } }, { "name": "SetGoalBudget", "description": "Set a hard budget limit for the current goal.\\n\\nUse this only when the user clearly gives a runtime limit, such as:\\n\\n- \\"stop after 20 turns\\"\\n- \\"use no more than 500k tokens\\"\\n- \\"finish within 30 minutes\\"\\n\\nDo not invent limits. Do not call this for vague wording such as \\"spend some time\\" or\\n\\"try to be quick\\".\\n\\nIf the user gives a compound time, convert it to one supported unit before calling this tool.\\nFor example, \\"2 hours and 3 minutes\\" can be set as \`value: 123, unit: \\"minutes\\"\`.\\n\\nA time budget must be between 1 second and 24 hours — the tool rejects anything shorter or\\nlonger, telling the user it is not a reasonable goal budget. Turn and token budgets are not\\nbounded this way; they must be positive and are rounded to the nearest whole number (minimum 1).\\n\\nSupported units:\\n\\n- \`turns\`\\n- \`tokens\`\\n- \`milliseconds\`\\n- \`seconds\`\\n- \`minutes\`\\n- \`hours\`\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "value": { "type": "number", "exclusiveMinimum": 0, "description": "The positive numeric budget value." }, "unit": { "type": "string", "enum": [ "turns", "tokens", "milliseconds", "seconds", "minutes", "hours" ] } }, "required": [ "value", "unit" ], "additionalProperties": false } }, { "name": "Skill", "description": "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a \`<kimi-skill-loaded>\` block for it with the same \`args\` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier \`args\` and will not reflect new inputs.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "skill": { "type": "string", "description": "The exact name of the skill to invoke, spelled as it appears in the current skill listing (e.g. \\"commit\\", \\"pdf\\")." }, "args": { "description": "Optional argument string for the skill, written like a command line (e.g. \`-m \\"fix bug\\"\`, \`123\`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing \`ARGUMENTS:\` line. Omit it only when there is nothing to pass.", "type": "string" } }, "required": [ "skill" ], "additionalProperties": false } }, { "name": "TaskList", "description": "List background tasks and their current status.\\n\\nUse this tool to discover which background tasks exist and where each one\\nstands. It is the entry point for inspecting background work: it returns a\\ntask ID, status, and description for every task it reports, plus the command,\\nPID, and (once finished) exit code for shell tasks, and a stop reason for any\\ntask that ended early.\\n\\nGuidelines:\\n\\n- After a context compaction, or whenever you are unsure which background\\n  tasks are running or what their task IDs are, call this tool to\\n  re-enumerate them instead of guessing a task ID.\\n- Prefer the default \`active_only=true\`, which lists only non-terminal tasks.\\n  Pass \`active_only=false\` only when you specifically need to see tasks that\\n  have already finished. With \`active_only=false\` the result may also include\\n  \`lost\` tasks — tasks left over from a previous process that can no longer be\\n  inspected or controlled; treat them as already terminated.\\n- \`limit\` caps how many tasks are returned. It accepts a value between 1 and\\n  100 and defaults to 20 when omitted.\\n- This tool only lists tasks; it does not return their output. Use it first\\n  to locate the task ID you need, then call \`TaskOutput\` with that ID to read\\n  the task's output and details.\\n- This tool is read-only and does not change any state, so it is always safe\\n  to call, including in plan mode.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "active_only": { "default": true, "description": "Whether to list only non-terminal background tasks.", "type": "boolean" }, "limit": { "default": 20, "description": "Maximum number of tasks to return.", "type": "integer", "minimum": 1, "maximum": 100 } }, "additionalProperties": false } }, { "name": "TaskOutput", "description": "Retrieve a snapshot of a running or completed background task.\\n\\nUse this after \`Bash(run_in_background=true)\` or \`Agent(run_in_background=true)\` to check progress, or to read the output of a task that has already completed.\\n\\nGuidelines:\\n- Prefer relying on automatic completion notifications. Use this tool only when you need task output before the automatic notification arrives.\\n- By default this tool is non-blocking and returns a current status/output snapshot — that is the normal way to use it.\\n- Do not use TaskOutput to wait for a result you need before continuing — if your next step depends on the task's result, run that task in the foreground instead. TaskOutput is for a deliberate progress check you will act on without blocking, not a way to sit and wait for a background task you just launched.\\n- Use block=true only when the user explicitly asked you to wait for the task. Never block on a task you launched in the current turn — if you need its result right away, it should have been a foreground call.\\n- If a block=true call returns \`retrieval_status: timeout\` (the task is still running), do not block on the same task again. Continue with other work or hand back to the user — the completion notification arrives on its own.\\n- This tool returns structured task metadata, a fixed-size output preview, and an output_path for the full log.\\n- For a terminal task, the metadata also explains why it ended. A shell command that runs to completion reports \`status: completed\` on a zero exit, or \`status: failed\` with its non-zero \`exit_code\` — judge that failure from the \`exit_code\`, because a plain command failure carries no \`stop_reason\` and no \`terminal_reason\`. \`terminal_reason\` is a categorical label emitted only when the end is not an ordinary exit: \`timed_out\` when the deadline aborted it, \`stopped\` when it was explicitly stopped, or \`failed\` when it errored without producing an exit code; the \`stopped\` and \`failed\` cases also carry a human-readable \`stop_reason\`. A task that finished on its own with a clean exit carries neither \`stop_reason\` nor \`terminal_reason\`.\\n- The full, never-truncated log is always available at output_path; use the \`Read\` tool with that path to page through it, whether or not the preview was truncated.\\n- This tool works with the generic background task system and should remain the primary read path for future task types, not just bash.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to inspect." }, "block": { "default": false, "description": "Whether to wait for the task to finish before returning. Discouraged — background tasks notify automatically on completion; use only when the user explicitly asked you to wait.", "type": "boolean" }, "timeout": { "default": 30, "description": "Maximum number of seconds to wait when block=true.", "type": "integer", "minimum": 0, "maximum": 3600 } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TaskStop", "description": "Stop a running background task.\\n\\nOnly use this when a task must genuinely be cancelled — for a task that is\\nfinishing normally, wait for its completion notification or inspect it with\\n\`TaskOutput\` instead of stopping it.\\n\\nGuidelines:\\n- This is a general-purpose stop capability for any background task. It is not\\n  a bash-specific kill.\\n- Stopping a task is destructive: it may leave partial side effects behind.\\n  Use it with care.\\n- If the task has already finished, this tool simply returns its current\\n  status.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to stop." }, "reason": { "default": "Stopped by TaskStop", "description": "Short reason recorded when the task is stopped.", "type": "string" } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TodoList", "description": "Use this tool to maintain a structured TODO list as you work through a multi-step task. Use it proactively and often when progress tracking helps the current work. This is especially useful in long-running investigations and implementation tasks with several tool calls; in plan mode, write the plan to the plan file rather than tracking it here.\\n\\n**When to use:**\\n- Multi-step tasks that span several tool calls\\n- Tracking investigation progress across a large codebase search\\n- Planning a sequence of edits before making them\\n- After receiving new multi-step instructions, capture the requirements as todos\\n- Before starting a tracked task, mark exactly one item as \`in_progress\`\\n- Immediately after finishing a tracked task, mark it \`done\`; do not batch completions at the end\\n\\n**When NOT to use:**\\n- Single-shot answers that complete in one or two tool calls\\n- Trivial requests where tracking adds no clarity\\n- Purely conversational or informational replies\\n\\n**Avoid churn:**\\n- Do not re-call this tool when nothing meaningful has changed since the last call — update the list only after real progress.\\n- When unsure of the current state, call query mode first (omit \`todos\`) to check the list before deciding what to update.\\n- If no available tool can move any task forward, tell the user where you are stuck instead of repeatedly re-ordering the same todos.\\n\\n**How to use:**\\n- Call with \`todos: [...]\` to replace the full list. Statuses: pending / in_progress / done.\\n- Call with no \`todos\` argument to retrieve the current list without changing it.\\n- Call with \`todos: []\` to clear the list.\\n- Keep titles short and actionable (e.g. \\"Read session-control.ts\\", \\"Add planMode flag to TurnManager\\").\\n- Update statuses as you make progress.\\n- When work is underway, keep exactly one task \`in_progress\`.\\n- Only mark a task \`done\` when it is fully accomplished.\\n- Never mark a task \`done\` if tests are failing, implementation is partial, unresolved errors remain, or required files/dependencies could not be found.\\n- If you encounter a blocker, keep the blocked task \`in_progress\` or add a new pending task describing what must be resolved.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "todos": { "description": "The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.", "type": "array", "items": { "type": "object", "properties": { "title": { "type": "string", "minLength": 1, "description": "Short, actionable title for the todo." }, "status": { "type": "string", "enum": [ "pending", "in_progress", "done" ], "description": "Current status of the todo." } }, "required": [ "title", "status" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "UpdateGoal", "description": "Set the status of the current goal. This is how you resume, complete, or block an autonomous goal.\\n\\n- \`active\` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\\n- \`complete\` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded. Before using this, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not use \`complete\` merely because a budget is nearly exhausted or you want to stop.\\n- \`blocked\` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. For non-terminal blockers, do not use \`blocked\` the first time you hit the blocker. The same blocking condition must repeat for at least 3 consecutive goal turns before you call \`blocked\`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. If the objective itself is impossible, unsafe, or contradictory, call \`blocked\` in the same turn instead of running more goal turns. Do not use \`blocked\` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call \`blocked\` instead of leaving the goal active.\\n\\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call \`complete\` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not call \`complete\` after only producing a plan, summary, first pass, or partial result. Call \`blocked\` only after the blocked audit threshold is met. If you call \`blocked\`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "status": { "type": "string", "enum": [ "active", "complete", "blocked" ], "description": "The lifecycle status to set for the current goal. Use \`blocked\` for impossible, unsafe, or contradictory objectives, or after the same non-terminal blocking condition repeats for at least 3 consecutive goal turns." } }, "required": [ "status" ], "additionalProperties": false } }, { "name": "Write", "description": "Create, append to, or replace a file entirely.\\n\\n- Missing parent directories are created automatically (like \`mkdir(parents=True, exist_ok=True)\`).\\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\\n- Do not create unsolicited documentation files (\`*.md\` write-ups, \`README\`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\\n- Read before overwriting an existing file.\\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\\n- Write outputs content literally, including supplied line endings: \\\\n stays LF, \\\\r\\\\n stays CRLF.\\n- For new content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically." }, "content": { "type": "string", "description": "Raw full file content to write exactly as provided. This does not use the Read/Edit text view." }, "mode": { "description": "Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline.", "type": "string", "enum": [ "overwrite", "append" ] } }, "required": [ "path", "content" ], "additionalProperties": false } } ], "time": "<time>" }
-        [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999860, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "de7a41992b98f517933310ee33535fc82fa1e5896e657e789de0b0c8a8749564", "messageCount": 2, "turnStep": "0.1", "time": "<time>" }
+        [wire] llm.tools_snapshot          { "hash": "1734910ed1f28dbc2d80eddcfcee1d0cfe832cbb9eaaf8a61c1f08dd1ec2141c", "tools": [ { "name": "Agent", "description": "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\\n\\nWriting the prompt:\\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\\n\\nUsage notes:\\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its \`resume\` id) over spawning a fresh instance — the resumed agent keeps its prior context.\\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\\n- Subagents use a fixed 2-hour timeout. If one times out, resume the same agent instead of starting over.\\n\\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\\n\\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\\n\\n\\nWhen \`run_in_background=true\`, the subagent runs detached from this turn. The completion arrives in a later turn as a synthetic user-role message containing its result — you do not need to poll, sleep, or check on its progress. Continue with other work or respond to the user. Never fabricate or predict what the result will say.\\n\\nDefault to a foreground subagent (omit \`run_in_background\`) when your next step needs its result — foreground hands the result straight back. Reach for \`run_in_background=true\` only when you have other work to do while it runs and do not need its result to proceed. Never launch in the background and then immediately wait on it (with \`TaskOutput block=true\`, sleeping, or otherwise): that just blocks the turn for no benefit — run it in the foreground instead.\\n\\n\\nAvailable agent types (pass via subagent_type):\\n- plan: Read-only implementation planning and architecture design. Use this agent when the parent agent needs a step-by-step implementation plan, key file identification, and architectural trade-off analysis before code changes are made.\\n  Tools: Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL\\n- agent: Default Kimi Code agent\\n  Tools: Read, Write, Edit, Grep, Glob, Bash, TaskList, TaskOutput, TaskStop, CronCreate, CronList, CronDelete, ReadMediaFile, TodoList, Skill, WebSearch, Agent, AgentSwarm, FetchURL, AskUserQuestion, EnterPlanMode, ExitPlanMode, CreateGoal, GetGoal, SetGoalBudget, UpdateGoal, mcp__*, spine_open, spine_close, spine_next, spine_tree\\n- coder: General software engineering agent — the only subagent type with file-editing tools; use it for any delegated task that must modify code. Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.\\n  Tools: Agent, AgentSwarm, Bash, CronCreate, CronDelete, CronList, Edit, EnterPlanMode, ExitPlanMode, Glob, Grep, Read, ReadMediaFile, Skill, TaskList, TaskOutput, TaskStop, TodoList, WebSearch, FetchURL, Write, mcp__*\\n- explore: Fast codebase exploration with prompt-enforced read-only behavior. Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (e.g. \\"src/**/*.yaml\\"), search code for keywords (e.g. \\"database connection\\"), or answer questions about the codebase (e.g. \\"how does the auth module work?\\"). When calling this agent, specify the desired thoroughness level: \\"quick\\" for basic searches, \\"medium\\" for moderate exploration, or \\"thorough\\" for comprehensive analysis across multiple locations and naming conventions. Use this agent for any read-only exploration that will clearly require more than 3 search queries. Prefer launching multiple explore agents concurrently when investigating independent questions.\\n  Tools: Bash, Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "prompt": { "type": "string", "description": "Full task prompt for the subagent" }, "description": { "type": "string", "description": "Short task description (3-5 words) for UI display" }, "subagent_type": { "description": "One of the available agent types (see \\"Available agent types\\" in this tool description). Defaults to \\"coder\\" when omitted.", "type": "string" }, "resume": { "description": "Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected.", "type": "string" }, "run_in_background": { "description": "If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting.", "type": "boolean" } }, "required": [ "prompt", "description" ], "additionalProperties": false } }, { "name": "AgentSwarm", "description": "Launch multiple subagents from one prompt template, existing agent resumes, or both.\\n\\nUse AgentSwarm when many subagents should run the same kind of task over different inputs. The placeholder is exactly \`{{item}}\`. For example, with \`prompt_template\` set to \`Review {{item}} for likely regressions.\` and \`items\` set to \`[\\"src/a.ts\\", \\"src/b.ts\\"]\`, AgentSwarm launches two new subagents with those two concrete prompts. For a few differently-shaped tasks, make separate \`Agent\` calls in one message instead.\\n\\nUse \`resume_agent_ids\` to continue subagents that already exist from earlier work, such as ones that failed or timed out: map each agent id to the prompt for that resumed subagent (usually \`continue\` if no extra information is needed). You may combine \`resume_agent_ids\` with \`items\` in the same call to resume existing subagents and launch new ones. Do not duplicate resumed work in \`items\`.\\n\\nEach of these is enforced — a violation is rejected before any subagent starts: provide at least 2 \`items\` unless you pass \`resume_agent_ids\`; whenever \`items\` are present, \`prompt_template\` is required and must contain \`{{item}}\`; and the filled-in prompts must be distinct (two items that expand to the same prompt are rejected).\\n\\nUse enough subagents to keep the work focused and parallel. AgentSwarm supports up to 128 subagents, and launches are queued automatically, so it is safe to split large tasks into many clear, independent items.\\n\\nIf \`AgentSwarm\` is called, that call must be the only tool call in the response.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "description": { "type": "string", "minLength": 1, "description": "Short description for the whole swarm." }, "subagent_type": { "description": "Subagent type used for every new subagent spawned from items; defaults to coder when omitted. Resumed subagents always keep their original type, so passing subagent_type together with resume_agent_ids is allowed — it only affects the item-based spawns.", "type": "string", "minLength": 1 }, "prompt_template": { "description": "Prompt template for each subagent. The {{item}} placeholder is replaced with each item value.", "type": "string", "minLength": 1 }, "items": { "description": "Values used to fill {{item}}. Each item launches one new subagent.", "maxItems": 128, "type": "array", "items": { "type": "string", "minLength": 1 } }, "resume_agent_ids": { "description": "Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents.", "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "type": "string", "minLength": 1 } } }, "required": [ "description" ], "additionalProperties": false } }, { "name": "AskUserQuestion", "description": "Use this tool when you need to ask the user questions with structured options during execution. This allows you to:\\n1. Collect user preferences or requirements before proceeding\\n2. Resolve ambiguous or underspecified instructions\\n3. Let the user decide between implementation approaches as you work\\n4. Present concrete options when multiple valid directions exist\\n\\n**When NOT to use:**\\n- When you can infer the answer from context — be decisive and proceed\\n- Trivial decisions that don't materially affect the outcome\\n\\nOverusing this tool interrupts the user's flow. Only use it when the user's input genuinely changes your next action.\\n\\n**Usage notes:**\\n- Users always have an \\"Other\\" option for custom input — don't create one yourself\\n- Use multi_select to allow multiple answers to be selected for a question\\n- Keep option labels concise (1-5 words), use descriptions for trade-offs and details\\n- Each question should have 2-4 meaningful, distinct options\\n- Question texts must be unique across the call, and option labels must be unique within each question\\n- You can ask 1-4 questions at a time; group related questions to minimize interruptions\\n- If you recommend a specific option, list it first and append \\"(Recommended)\\" to its label\\n- The result is JSON with an \`answers\` object keyed by question text; each value is the chosen option's label (comma-separated labels for multi_select, or the user's own words if they picked \\"Other\\"); if \`answers\` is empty and a \`note\` says the user dismissed it, they chose not to answer — do not treat this as selecting the recommended option; decide based on context and do not re-ask the same question\\n- Set background=true when you can keep working without the answer. This starts a background question task and returns a task_id immediately. The answer arrives automatically in a later turn — you do not need to poll, sleep, or check on it. Continue with other work; never fabricate or predict the answer.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "questions": { "minItems": 1, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "question": { "type": "string", "minLength": 1, "description": "A specific, actionable question. End with '?'." }, "header": { "default": "", "description": "Short category tag (max 12 chars, e.g. 'Auth', 'Style').", "type": "string" }, "options": { "minItems": 2, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "description": "Concise display text (1-5 words). If recommended, append '(Recommended)'." }, "description": { "default": "", "description": "Brief explanation of trade-offs or implications.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false }, "description": "2-4 meaningful, distinct options. Do NOT include an 'Other' option — the system adds one automatically." }, "multi_select": { "default": false, "description": "Whether the user can select multiple options.", "type": "boolean" } }, "required": [ "question", "options" ], "additionalProperties": false }, "description": "The questions to ask the user (1-4 questions)." }, "background": { "default": false, "description": "Set true to ask in the background and return immediately with a background task_id; you are notified automatically when the user answers — do not poll with TaskOutput while the question is pending.", "type": "boolean" } }, "required": [ "questions" ], "additionalProperties": false } }, { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nIf \`run_in_background=true\`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short \`description\`. Background commands default to a 600s timeout and \`timeout\` is capped at 86400s; set \`disable_timeout=true\` only when the task should run without a timeout. You will be automatically notified when the task completes. After starting one, default to returning control to the user instead of immediately waiting on it. Use \`TaskOutput\` only for a non-blocking status/output snapshot — do not set \`block=true\` to wait for a task you just launched, since its completion arrives automatically; reserve \`block=true\` for when the user explicitly asked you to wait. Use \`TaskStop\` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the \`/tasks\` command, which opens an interactive panel; it has no subcommands.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the \`timeout\` argument in seconds. Foreground commands default to 60s and allow up to 300s. When a foreground command hits its timeout it is moved to the background instead of being killed, and you will be automatically notified when it completes.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Prefer \`run_in_background=true\` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } }, { "name": "CreateGoal", "description": "Create a durable, structured goal that the runtime will pursue across multiple turns.\\n\\nCall \`CreateGoal\` only when:\\n\\n- the user explicitly asks you to start a goal or work autonomously toward an outcome, or\\n- a host goal-intake prompt asks you to create one.\\n\\nDo NOT create a goal for greetings, ordinary questions, or vague requests that lack a\\nverifiable completion condition. A goal needs a checkable end state.\\n\\nWhen the request is vague, ask the user for the missing completion criterion before creating\\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\\nrespect that and create the goal.\\n\\nInclude a \`completionCriterion\` when the user provides one, or when it can be stated without\\ninventing new requirements. Keep \`objective\` concise; reference long task descriptions by file\\npath rather than pasting them.\\n\\nCreating a goal fails if one already exists, so use \`replace: true\` only when the user explicitly\\nwants to abandon the current goal and start a new one.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "objective": { "type": "string", "minLength": 1, "description": "The objective to pursue. Must have a verifiable end state." }, "completionCriterion": { "description": "How to verify the goal is complete. Include when the user provides one.", "type": "string" }, "replace": { "description": "Replace an existing active, paused, or blocked goal instead of failing.", "type": "boolean" } }, "required": [ "objective" ], "additionalProperties": false } }, { "name": "Edit", "description": "Perform exact replacements in existing files.\\n\\n- Edit is mandatory for every incremental change, especially small edits. DO NOT use Write or Bash \`sed\`.\\n- Read the target file before every Edit. DO NOT call Edit from memory, stale context, or a guessed \`old_string\`.\\n- Take \`old_string\` and \`new_string\` from the Read output view.\\n- Drop the line-number prefix and tab; match only file content.\\n- \`old_string\` must be unique unless \`replace_all\` is set.\\n- If \`old_string\` is ambiguous, add surrounding context. Use \`replace_all\` only when every occurrence should change — for example, renaming a symbol throughout the file.\\n- Multiple Edit calls may run in one response only when they do not target the same file.\\n- DO NOT issue consecutive Edit calls on the same file. A previous Edit can invalidate a later Edit's \`old_string\`, causing \`old_string not found\`. Read the file again before the next Edit.\\n- A write lock serializes same-file edits in response order, but serialization does not make stale \`old_string\` valid.\\n- For pure CRLF files, Read shows LF; use LF in \`old_string\` and \`new_string\`, and Edit writes CRLF back.\\n- For mixed endings or lone carriage returns, Read shows carriage returns as \\\\r; include actual \\\\r escapes in those positions.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the text file to edit. Relative paths resolve against the working directory; a path outside the working directory must be absolute." }, "old_string": { "type": "string", "minLength": 1, "description": "Exact content to replace from the Read output view, without the line-number prefix. Use LF for pure CRLF files; use actual \\\\r escapes where Read shows \\\\r." }, "new_string": { "type": "string", "description": "Replacement text in the same Read output view. LF is written back as CRLF only for pure CRLF files." }, "replace_all": { "description": "Set true only when every occurrence of old_string should be replaced.", "type": "boolean" } }, "required": [ "path", "old_string", "new_string" ], "additionalProperties": false } }, { "name": "EnterPlanMode", "description": "Use this tool proactively when you're about to start a non-trivial implementation task.\\nGetting user sign-off on your approach via ExitPlanMode before writing code prevents wasted effort.\\n\\nUse it when ANY of these conditions apply:\\n\\n1. New Feature Implementation - e.g. \\"Add a caching layer to the API\\"\\n2. Multiple Valid Approaches - e.g. \\"Optimize database queries\\" (indexing vs rewrite vs caching)\\n3. Code Modifications - e.g. \\"Refactor auth module to support OAuth\\"\\n4. Architectural Decisions - e.g. \\"Add WebSocket support\\"\\n5. Multi-File Changes - involves more than 2-3 files\\n6. Unclear Requirements - need exploration to understand scope\\n7. User Preferences Matter - if user input would materially change the implementation approach, use EnterPlanMode to structure the decision\\n\\nPermission mode notes:\\n- EnterPlanMode enters plan mode automatically without an approval prompt in all permission modes.\\n- In yolo and manual modes, ExitPlanMode still presents the plan to the user for approval.\\n- In auto permission mode, do not use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, ExitPlanMode exits plan mode without asking the user.\\n- Use EnterPlanMode only when planning itself adds value.\\n\\nWhen NOT to use:\\n- Single-line or few-line fixes (typos, obvious bugs, small tweaks)\\n- User gave very specific, detailed instructions\\n- Pure research/exploration tasks\\n\\nOnce you are in plan mode, a reminder walks you through the workflow (explore → design → write the plan file → \`ExitPlanMode\`) and enforces read-only access. For non-trivial tasks where you are unsure of the codebase structure or relevant code paths, use \`Agent(subagent_type=\\"explore\\")\` to investigate first when the \`Agent\` tool is available.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "ExitPlanMode", "description": "Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.\\n\\n## How This Tool Works\\n- You should have already written your plan to the plan file specified in the plan mode reminder.\\n- This tool does NOT take the plan content as a parameter - it reads the plan from the file you wrote.\\n- The user will see the contents of your plan file when they review it. In auto permission mode, the tool reads the file and exits plan mode without asking the user.\\n\\n## When to Use\\nOnly use this tool for tasks that require planning implementation steps. For research tasks (searching files, reading code, understanding the codebase), do NOT use this tool.\\n\\n## What a good plan contains\\nList specific, verifiable steps grounded in the actual codebase — real files, functions, and commands, in a sensible order. Each step should be concrete enough to act on and to check. Avoid vague filler like \\"improve performance\\" or \\"add tests\\"; say what to change and where.\\n\\n## Multiple Approaches\\nIf your plan offers multiple alternative approaches, pass them via the \`options\` parameter so the user can choose which one to execute — see the \`options\` parameter for the format, count, and reserved labels. In yolo and manual modes the user sees all options alongside the host's Reject and Revise controls.\\n\\n## Before Using\\n- In auto permission mode, do NOT use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, this tool exits plan mode without asking the user.\\n- In yolo and manual modes, this tool still presents the plan to the user for approval.\\n- If auto permission mode is not active and you have unresolved questions, use AskUserQuestion first.\\n- If auto permission mode is not active and you have multiple approaches and haven't narrowed down yet, consider using AskUserQuestion first to let the user choose, then write a plan for the chosen approach only.\\n- Once your plan is finalized, use THIS tool to request approval.\\n- Do NOT use AskUserQuestion to ask \\"Is this plan OK?\\" or \\"Should I proceed?\\" - that is exactly what ExitPlanMode does.\\n- If rejected, revise based on feedback and call ExitPlanMode again.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "options": { "description": "When the plan contains multiple alternative approaches, list them here so the user can choose which one to execute. Provide up to 3 options; 2-3 distinct approaches work best when the plan offers a real choice. Passing a single option is allowed and is equivalent to a plain plan approval. Each option represents a distinct approach from the plan. Do not use \\"Reject\\", \\"Revise\\", \\"Approve\\", or \\"Reject and Exit\\" as labels.", "minItems": 1, "maxItems": 3, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "maxLength": 80, "description": "Short name for this option (1-8 words). Append \\"(Recommended)\\" if you recommend this option." }, "description": { "default": "", "description": "Brief summary of this approach and its trade-offs.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "FetchURL", "description": "Fetch content from a URL. The content is returned either as the main text extracted from the page, or as the full response body verbatim; a note at the top of the result states which of the two you received, so you can judge how complete it is. Use this when you need to read a specific web page.\\n\\nOnly fully-formed public \`http\`/\`https\` URLs are supported; other schemes and private or loopback addresses are not fetched. Very large pages may be truncated or refused. The fetch carries no login or session for the target site, so pages behind authentication (private repositories, internal dashboards) return a login page or an error instead of the real content — if the text you get back looks like a generic landing or sign-in page, treat that as the login wall, not the answer, and reach the content through a credentialed route (an authenticated CLI or MCP tool) instead.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "url": { "type": "string", "description": "The URL to fetch content from." } }, "required": [ "url" ], "additionalProperties": false } }, { "name": "GetGoal", "description": "Read the current goal: its objective, completion criterion, status, and budgets (turns, tokens,\\ntime, and how much of each remains). When the goal has stopped, it also reports the terminal reason.\\n\\nUse \`GetGoal\` before deciding whether to continue working, report completion, report a blocker,\\nor respect a pause. It returns \`{ \\"goal\\": null }\` when there is no current goal.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "Glob", "description": "Find files by glob pattern, sorted by modification time (most recent first).\\n\\nPowered by ripgrep. Respects \`.gitignore\`, \`.ignore\`, and \`.rgignore\` by default — set \`include_ignored\` to also match ignored files (e.g. build outputs, \`node_modules\`). Sensitive files (such as \`.env\`) are always filtered out. Matches are files only — directories themselves are never listed; to find a directory, glob for a file inside it (e.g. \`**/fixtures/**\`).\\n\\nGood patterns:\\n- \`*.ts\` — all files matching an extension, at any depth below the search root (a bare pattern without \`/\` matches recursively)\\n- \`src/*.ts\` — files directly inside \`src/\` (one level, not recursive)\\n- \`src/**/*.ts\` — recursive walk with a subdirectory anchor and extension\\n- \`**/*.py\` — recursive walk from the search root for an extension\\n- \`*.{ts,tsx}\` — brace expansion is supported\\n- \`{src,test}/**/*.ts\` — cartesian brace expansion is supported too\\n\\nResults are capped at the first 100 matching paths. If a search would return more, a truncation marker is appended. Refine the pattern (extension, subdirectory) when 100 is not enough, or call again with a narrower anchor.\\n\\nLarge-directory caveat — avoid recursing into dependency / build output even with an anchor, especially when \`include_ignored\` is set:\\n- \`node_modules/**/*.js\`, \`.venv/**/*.py\`, \`__pycache__/**\`, \`target/**\` can produce thousands of results that truncate at the match cap and waste context. Prefer specific subpaths like \`node_modules/react/src/**/*.js\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Glob pattern to match files." }, "path": { "description": "Directory to search. Accepts an absolute path, or a path relative to the current working directory. Defaults to the current working directory.", "type": "string" }, "include_ignored": { "description": "Also match files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" }, "include_dirs": { "description": "Deprecated and ignored. Results are always files-only — directories are never listed. Accepted only so older calls that still pass this flag are not rejected by parameter validation.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Grep", "description": "Search file contents using regular expressions (powered by ripgrep).\\n\\nUse Grep when the task is to find unknown content or unknown file locations. Do not use shell \`grep\` or \`rg\` directly; this tool applies workspace path policy, output limits, and sensitive-file filtering.\\nALWAYS use Grep tool instead of running \`grep\` or \`rg\` from a shell — direct shell calls bypass workspace policy, output limits, and sensitive-file filtering.\\nIf you already know a concrete file path and need to inspect its contents, use Read directly instead.\\n\\nWrite patterns in ripgrep regex syntax, which differs from POSIX \`grep\` syntax. For example, braces are special, so escape them as \`\\\\{\` to match a literal \`{\`.\\n\\nHidden files (dotfiles such as \`.gitlab-ci.yml\` or \`.eslintrc.json\`) are searched by default. To also search files excluded by \`.gitignore\` (such as \`node_modules\` or build outputs), set \`include_ignored\` to \`true\`. Sensitive files (such as \`.env\`) are always skipped for safety, even when \`include_ignored\` is \`true\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Regular expression to search for." }, "path": { "description": "File or directory to search. Accepts an absolute path, or a path relative to the current working directory. Omit to search the current working directory. Use Read instead when you already know a concrete file path and need its contents.", "type": "string" }, "glob": { "description": "Optional glob filter for which files to search, e.g. \`*.ts\`. Matched against each file's full absolute path, so a path-anchored pattern like \`src/**/*.ts\` silently matches nothing — use a basename pattern (\`*.ts\`), or anchor with \`**/\` (\`**/src/**/*.ts\`). To scope the search to a directory, use \`path\` instead.", "type": "string" }, "type": { "description": "Optional ripgrep file type filter, such as ts or py. Prefer this over \`glob\` when filtering by language or file kind: it is more efficient and less error-prone than an equivalent glob pattern.", "type": "string" }, "output_mode": { "description": "Shape of the result. \`content\` shows matching lines (honors \`-A\`, \`-B\`, \`-C\`, \`-n\`, and \`head_limit\`); \`files_with_matches\` shows only the paths of files that contain a match, most-recently-modified first (honors \`head_limit\`); \`count_matches\` shows per-file match counts as \`path:count\` lines, preceded by an aggregate total line. Defaults to \`files_with_matches\`.", "type": "string", "enum": [ "content", "files_with_matches", "count_matches" ] }, "-i": { "description": "Perform a case-insensitive search. Defaults to false.", "type": "boolean" }, "-n": { "description": "Prefix each matching line with its line number. Applies only when \`output_mode\` is \`content\`. Defaults to true.", "type": "boolean" }, "-A": { "description": "Number of lines to show after each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-B": { "description": "Number of lines to show before each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-C": { "description": "Number of lines to show before and after each match. Applies only when \`output_mode\` is \`content\`; takes precedence over \`-A\` and \`-B\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "head_limit": { "description": "Limit output to the first N lines/entries after offset. Defaults to 250. Pass 0 for unlimited.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "offset": { "description": "Number of leading lines/entries to skip before applying \`head_limit\`. Use it together with \`head_limit\` to page through large result sets. Defaults to 0.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "multiline": { "description": "Enable multiline matching, where the pattern can span line boundaries and \`.\` also matches newlines. Defaults to false.", "type": "boolean" }, "include_ignored": { "description": "Also search files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Lookup", "description": "Look up a short test value.", "parameters": { "type": "object", "properties": { "query": { "type": "string" } }, "required": [ "query" ], "additionalProperties": false } }, { "name": "Read", "description": "Read a text file from the local filesystem.\\n\\nIf the user provides a concrete file path to a text file, call Read directly. Do not \`Glob\`, \`ls\`, or otherwise pre-check known text file paths; missing or invalid file paths return errors you can handle. Do not use Read for directories; use \`ls\` via Bash for a known directory, or Glob when you need files matching a name pattern (Glob lists files only, never directories). Use \`Grep\` only when the task is to search for unknown content or locations.\\n\\nWhen you need several files, prefer to read them in parallel: emit multiple \`Read\` calls in a single response instead of reading one file per turn.\\n\\n- Relative paths resolve against the working directory; a path outside the working directory must be absolute.\\n- Returns up to 1000 lines or 100 KB per call, whichever comes first; lines longer than 2000 chars are truncated mid-line.\\n- Page larger files with \`line_offset\` (1-based start line) and \`n_lines\`. Omit \`n_lines\` to read up to the 1000-line cap.\\n- Sensitive files (\`.env\` files, credential stores, SSH private keys, and similar secrets) are refused to protect secrets; do not attempt to read them. Templates and public keys are exempt: \`.env.example\` / \`.env.sample\` / \`.env.template\` and public SSH keys such as \`id_rsa.pub\` read normally.\\n- Only UTF-8 text files can be read. Non-UTF-8 encodings, binary files, and files containing NUL bytes are refused; use \`ReadMediaFile\` for images or video, and Bash or an MCP tool for other binary formats.\\n- Negative line_offset reads from the end of the file (for example, -100 reads the last 100 lines); the absolute value cannot exceed 1000.\\n- Output format: \`<line-number>\\\\t<content>\` per line.\\n- A \`<system>...</system>\` status block is appended after the file content; it summarizes how much was read (line and byte counts, truncation, line-ending notes) and is not part of the file itself.\\n- Pure CRLF files are displayed with LF line endings; \`Edit\` matches this output and preserves CRLF when writing back.\\n- Mixed or lone carriage-return line endings are shown as \`\\\\r\` and require exact \`Edit.old_string\` escapes.\\n- After a successful \`Edit\`/\`Write\`, do not re-read solely to prove the write landed. When the task depends on an exact file, API, or output shape, inspect the final external contract before finishing.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to a text file. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Directories are not supported; use \`ls\` via Bash for a known directory, or Glob for pattern search." }, "line_offset": { "description": "The line number to start reading from. Omit to start at line 1. Negative values read from the end of the file; the absolute value cannot exceed 1000.", "anyOf": [ { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, { "type": "integer", "minimum": -1000, "maximum": -1 } ] }, "n_lines": { "description": "The number of lines to read; the tool also applies its internal cap. Omit to read up to the internal cap of 1000 lines.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 } }, "required": [ "path" ], "additionalProperties": false } }, { "name": "SetGoalBudget", "description": "Set a hard budget limit for the current goal.\\n\\nUse this only when the user clearly gives a runtime limit, such as:\\n\\n- \\"stop after 20 turns\\"\\n- \\"use no more than 500k tokens\\"\\n- \\"finish within 30 minutes\\"\\n\\nDo not invent limits. Do not call this for vague wording such as \\"spend some time\\" or\\n\\"try to be quick\\".\\n\\nIf the user gives a compound time, convert it to one supported unit before calling this tool.\\nFor example, \\"2 hours and 3 minutes\\" can be set as \`value: 123, unit: \\"minutes\\"\`.\\n\\nA time budget must be between 1 second and 24 hours — the tool rejects anything shorter or\\nlonger, telling the user it is not a reasonable goal budget. Turn and token budgets are not\\nbounded this way; they must be positive and are rounded to the nearest whole number (minimum 1).\\n\\nSupported units:\\n\\n- \`turns\`\\n- \`tokens\`\\n- \`milliseconds\`\\n- \`seconds\`\\n- \`minutes\`\\n- \`hours\`\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "value": { "type": "number", "exclusiveMinimum": 0, "description": "The positive numeric budget value." }, "unit": { "type": "string", "enum": [ "turns", "tokens", "milliseconds", "seconds", "minutes", "hours" ] } }, "required": [ "value", "unit" ], "additionalProperties": false } }, { "name": "Skill", "description": "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a \`<kimi-skill-loaded>\` block for it with the same \`args\` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier \`args\` and will not reflect new inputs.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "skill": { "type": "string", "description": "The exact name of the skill to invoke, spelled as it appears in the current skill listing (e.g. \\"commit\\", \\"pdf\\")." }, "args": { "description": "Optional argument string for the skill, written like a command line (e.g. \`-m \\"fix bug\\"\`, \`123\`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing \`ARGUMENTS:\` line. Omit it only when there is nothing to pass.", "type": "string" } }, "required": [ "skill" ], "additionalProperties": false } }, { "name": "TaskList", "description": "List background tasks and their current status.\\n\\nUse this tool to discover which background tasks exist and where each one\\nstands. It is the entry point for inspecting background work: it returns a\\ntask ID, status, and description for every task it reports, plus the command,\\nPID, and (once finished) exit code for shell tasks, and a stop reason for any\\ntask that ended early.\\n\\nGuidelines:\\n\\n- After a context compaction, or whenever you are unsure which background\\n  tasks are running or what their task IDs are, call this tool to\\n  re-enumerate them instead of guessing a task ID.\\n- Prefer the default \`active_only=true\`, which lists only non-terminal tasks.\\n  Pass \`active_only=false\` only when you specifically need to see tasks that\\n  have already finished. With \`active_only=false\` the result may also include\\n  \`lost\` tasks — tasks left over from a previous process that can no longer be\\n  inspected or controlled; treat them as already terminated.\\n- \`limit\` caps how many tasks are returned. It accepts a value between 1 and\\n  100 and defaults to 20 when omitted.\\n- This tool only lists tasks; it does not return their output. Use it first\\n  to locate the task ID you need, then call \`TaskOutput\` with that ID to read\\n  the task's output and details.\\n- This tool is read-only and does not change any state, so it is always safe\\n  to call, including in plan mode.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "active_only": { "default": true, "description": "Whether to list only non-terminal background tasks.", "type": "boolean" }, "limit": { "default": 20, "description": "Maximum number of tasks to return.", "type": "integer", "minimum": 1, "maximum": 100 } }, "additionalProperties": false } }, { "name": "TaskOutput", "description": "Retrieve a snapshot of a running or completed background task.\\n\\nUse this after \`Bash(run_in_background=true)\` or \`Agent(run_in_background=true)\` to check progress, or to read the output of a task that has already completed.\\n\\nGuidelines:\\n- Prefer relying on automatic completion notifications. Use this tool only when you need task output before the automatic notification arrives.\\n- By default this tool is non-blocking and returns a current status/output snapshot — that is the normal way to use it.\\n- Do not use TaskOutput to wait for a result you need before continuing — if your next step depends on the task's result, run that task in the foreground instead. TaskOutput is for a deliberate progress check you will act on without blocking, not a way to sit and wait for a background task you just launched.\\n- Use block=true only when the user explicitly asked you to wait for the task. Never block on a task you launched in the current turn — if you need its result right away, it should have been a foreground call.\\n- If a block=true call returns \`retrieval_status: timeout\` (the task is still running), do not block on the same task again. Continue with other work or hand back to the user — the completion notification arrives on its own.\\n- This tool returns structured task metadata, a fixed-size output preview, and an output_path for the full log.\\n- For a terminal task, the metadata also explains why it ended. A shell command that runs to completion reports \`status: completed\` on a zero exit, or \`status: failed\` with its non-zero \`exit_code\` — judge that failure from the \`exit_code\`, because a plain command failure carries no \`stop_reason\` and no \`terminal_reason\`. \`terminal_reason\` is a categorical label emitted only when the end is not an ordinary exit: \`timed_out\` when the deadline aborted it, \`stopped\` when it was explicitly stopped, or \`failed\` when it errored without producing an exit code; the \`stopped\` and \`failed\` cases also carry a human-readable \`stop_reason\`. A task that finished on its own with a clean exit carries neither \`stop_reason\` nor \`terminal_reason\`.\\n- The full, never-truncated log is always available at output_path; use the \`Read\` tool with that path to page through it, whether or not the preview was truncated.\\n- This tool works with the generic background task system and should remain the primary read path for future task types, not just bash.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to inspect." }, "block": { "default": false, "description": "Whether to wait for the task to finish before returning. Discouraged — background tasks notify automatically on completion; use only when the user explicitly asked you to wait.", "type": "boolean" }, "timeout": { "default": 30, "description": "Maximum number of seconds to wait when block=true.", "type": "integer", "minimum": 0, "maximum": 3600 } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TaskStop", "description": "Stop a running background task.\\n\\nOnly use this when a task must genuinely be cancelled — for a task that is\\nfinishing normally, wait for its completion notification or inspect it with\\n\`TaskOutput\` instead of stopping it.\\n\\nGuidelines:\\n- This is a general-purpose stop capability for any background task. It is not\\n  a bash-specific kill.\\n- Stopping a task is destructive: it may leave partial side effects behind.\\n  Use it with care.\\n- If the task has already finished, this tool simply returns its current\\n  status.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to stop." }, "reason": { "default": "Stopped by TaskStop", "description": "Short reason recorded when the task is stopped.", "type": "string" } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TodoList", "description": "Use this tool to maintain a structured TODO list as you work through a multi-step task. Use it proactively and often when progress tracking helps the current work. This is especially useful in long-running investigations and implementation tasks with several tool calls; in plan mode, write the plan to the plan file rather than tracking it here.\\n\\n**When to use:**\\n- Multi-step tasks that span several tool calls\\n- Tracking investigation progress across a large codebase search\\n- Planning a sequence of edits before making them\\n- After receiving new multi-step instructions, capture the requirements as todos\\n- Before starting a tracked task, mark exactly one item as \`in_progress\`\\n- Immediately after finishing a tracked task, mark it \`done\`; do not batch completions at the end\\n\\n**When NOT to use:**\\n- Single-shot answers that complete in one or two tool calls\\n- Trivial requests where tracking adds no clarity\\n- Purely conversational or informational replies\\n\\n**Avoid churn:**\\n- Do not re-call this tool when nothing meaningful has changed since the last call — update the list only after real progress.\\n- When unsure of the current state, call query mode first (omit \`todos\`) to check the list before deciding what to update.\\n- If no available tool can move any task forward, tell the user where you are stuck instead of repeatedly re-ordering the same todos.\\n\\n**How to use:**\\n- Call with \`todos: [...]\` to replace the full list. Statuses: pending / in_progress / done.\\n- Call with no \`todos\` argument to retrieve the current list without changing it.\\n- Call with \`todos: []\` to clear the list.\\n- Keep titles short and actionable (e.g. \\"Read session-control.ts\\", \\"Add planMode flag to TurnManager\\").\\n- Update statuses as you make progress.\\n- When work is underway, keep exactly one task \`in_progress\`.\\n- Only mark a task \`done\` when it is fully accomplished.\\n- Never mark a task \`done\` if tests are failing, implementation is partial, unresolved errors remain, or required files/dependencies could not be found.\\n- If you encounter a blocker, keep the blocked task \`in_progress\` or add a new pending task describing what must be resolved.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "todos": { "description": "The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.", "type": "array", "items": { "type": "object", "properties": { "title": { "type": "string", "minLength": 1, "description": "Short, actionable title for the todo." }, "status": { "type": "string", "enum": [ "pending", "in_progress", "done" ], "description": "Current status of the todo." } }, "required": [ "title", "status" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "UpdateGoal", "description": "Set the status of the current goal. This is how you resume, complete, or block an autonomous goal.\\n\\n- \`active\` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\\n- \`complete\` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded. Before using this, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not use \`complete\` merely because a budget is nearly exhausted or you want to stop.\\n- \`blocked\` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. For non-terminal blockers, do not use \`blocked\` the first time you hit the blocker. The same blocking condition must repeat for at least 3 consecutive goal turns before you call \`blocked\`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. If the objective itself is impossible, unsafe, or contradictory, call \`blocked\` in the same turn instead of running more goal turns. Do not use \`blocked\` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call \`blocked\` instead of leaving the goal active.\\n\\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call \`complete\` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not call \`complete\` after only producing a plan, summary, first pass, or partial result. Call \`blocked\` only after the blocked audit threshold is met. If you call \`blocked\`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "status": { "type": "string", "enum": [ "active", "complete", "blocked" ], "description": "The lifecycle status to set for the current goal. Use \`blocked\` for impossible, unsafe, or contradictory objectives, or after the same non-terminal blocking condition repeats for at least 3 consecutive goal turns." } }, "required": [ "status" ], "additionalProperties": false } }, { "name": "Write", "description": "Create, append to, or replace a file entirely.\\n\\n- Missing parent directories are created automatically (like \`mkdir(parents=True, exist_ok=True)\`).\\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\\n- Do not create unsolicited documentation files (\`*.md\` write-ups, \`README\`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\\n- Read before overwriting an existing file.\\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\\n- Write outputs content literally, including supplied line endings: \\\\n stays LF, \\\\r\\\\n stays CRLF.\\n- For new content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically." }, "content": { "type": "string", "description": "Raw full file content to write exactly as provided. This does not use the Read/Edit text view." }, "mode": { "description": "Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline.", "type": "string", "enum": [ "overwrite", "append" ] } }, "required": [ "path", "content" ], "additionalProperties": false } } ], "time": "<time>" }
+        [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999860, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "1734910ed1f28dbc2d80eddcfcee1d0cfe832cbb9eaaf8a61c1f08dd1ec2141c", "messageCount": 2, "turnStep": "0.1", "time": "<time>" }
         [emit] assistant.delta             { "turnId": 0, "delta": "I will look it up." }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [emit] tool.call.delta             { "turnId": 0, "toolCallId": "call_lookup", "name": "Lookup", "argumentsPart": "{\\"query\\":\\"moon\\"}" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 140, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
         [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 140, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 140, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 140, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
         [emit] agent.status.updated        { "contextTokens": 161, "rawContextTokens": 164 }
         [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "I will look it up." } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 161, "rawContextTokens": 170 }
         [emit] tool.call.started           { "turnId": 0, "toolCallId": "call_lookup", "name": "Lookup", "args": { "query": "moon" } }
-        [wire] context.append_loop_event   { "event": { "type": "tool.call", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "toolCallId": "call_lookup", "name": "Lookup", "args": { "query": "moon" } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 161, "rawContextTokens": 182 }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "tool_call", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [ { "toolCallId": "call_lookup", "name": "Lookup", "since": "<time>" } ], "since": "<time>" }, "background": [] }
         [emit] toolCall                    { "turnId": 0, "toolCallId": "call_lookup", "args": { "query": "moon" } }
       `);
       expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -2263,25 +2323,25 @@ describe('Agent tools', () => {
 
       ctx.mockNextResponse({ type: 'text', text: 'The lookup result is moon-result.' });
       expect(await ctx.untilTurnEnd()).toMatchInlineSnapshot(`
+        [wire] context.append_loop_event   { "event": { "type": "tool.call", "uuid": "<uuid-3>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "toolCallId": "call_lookup", "name": "Lookup", "args": { "query": "moon" } }, "time": "<time>" }
         [emit] tool.result                 { "turnId": 0, "toolCallId": "call_lookup", "output": "moon-result" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "tool.result", "parentUuid": "<uuid-3>", "toolCallId": "call_lookup", "result": { "output": "moon-result" } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 166, "rawContextTokens": 187 }
-        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 140, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 166, "rawContextTokens": 166 }
         [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 140, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "tool_use", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }
+        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "tool_use", "usage": { "inputOther": 140, "output": 21, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "tool_calls", "rawFinishReason": "tool_calls" }, "time": "<time>" }
         [emit] turn.step.started           { "turnId": 0, "step": 2, "stepId": "<uuid-4>" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-4>", "turnId": "0", "step": 2 }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 169, "rawContextTokens": 172 }
-        [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999831, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "de7a41992b98f517933310ee33535fc82fa1e5896e657e789de0b0c8a8749564", "messageCount": 4, "turnStep": "0.2", "time": "<time>" }
+        [wire] llm.request                 { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999831, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "1734910ed1f28dbc2d80eddcfcee1d0cfe832cbb9eaaf8a61c1f08dd1ec2141c", "messageCount": 4, "turnStep": "0.2", "time": "<time>" }
         [emit] assistant.delta             { "turnId": 0, "delta": "The lookup result is moon-result." }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 166, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
         [emit] agent.status.updated        { "usage": { "byModel": { "mock-model": { "inputOther": 306, "output": 33, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 306, "output": 33, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 306, "output": 33, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
         [emit] agent.status.updated        { "contextTokens": 178, "rawContextTokens": 181 }
-        [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The lookup result is moon-result." } }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 178, "rawContextTokens": 190 }
-        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 166, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-        [emit] agent.status.updated        { "contextTokens": 178, "rawContextTokens": 178 }
         [emit] turn.step.completed         { "turnId": 0, "step": 2, "stepId": "<uuid-4>", "usage": { "inputOther": 166, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+        [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 2, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+        [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-5>", "turnId": "0", "step": 2, "stepUuid": "<uuid-4>", "part": { "type": "text", "text": "The lookup result is moon-result." } }, "time": "<time>" }
+        [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-4>", "turnId": "0", "step": 2, "finishReason": "end_turn", "usage": { "inputOther": 166, "output": 12, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-2", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
         [emit] turn.ended                  { "turnId": 0, "reason": "completed" }
       `);
       expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -2295,27 +2355,29 @@ describe('Agent tools', () => {
       await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Can you still use Lookup?' }] });
 
       expect(await ctx.untilTurnEnd()).toMatchInlineSnapshot(`
+        [emit] agent.activity.updated       { "lifecycle": "ready", "lastTurn": { "turnId": 0, "reason": "completed", "at": "<time>" }, "background": [] }
         [wire] tools.unregister_user_tool   { "name": "Lookup", "time": "<time>" }
         [emit] prompt.completed             { "promptId": "<msg-1>", "finishedAt": "<time>", "reason": "completed" }
         [wire] turn.prompt                  { "input": [ { "type": "text", "text": "Can you still use Lookup?" } ], "origin": { "kind": "user" }, "time": "<time>" }
         [emit] turn.started                 { "turnId": 1, "origin": { "kind": "user" } }
-        [wire] context.append_message       { "message": { "role": "user", "content": [ { "type": "text", "text": "Can you still use Lookup?" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-2>" }, "time": "<time>" }
-        [emit] agent.status.updated         { "contextTokens": 186, "rawContextTokens": 186 }
+        [emit] agent.activity.updated       { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "running", "step": 0, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [emit] context.spliced              { "start": 5, "deleteCount": 0, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Can you still use Lookup?" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-2>" } ] }
+        [emit] agent.status.updated         { "contextTokens": 186, "rawContextTokens": 186 }
+        [wire] context.append_message       { "message": { "role": "user", "content": [ { "type": "text", "text": "Can you still use Lookup?" } ], "toolCalls": [], "origin": { "kind": "user" }, "id": "<msg-2>" }, "time": "<time>" }
         [emit] turn.step.started            { "turnId": 1, "step": 1, "stepId": "<uuid-6>" }
+        [emit] agent.activity.updated       { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] context.append_loop_event    { "event": { "type": "step.begin", "uuid": "<uuid-6>", "turnId": "1", "step": 1 }, "time": "<time>" }
-        [emit] agent.status.updated         { "contextTokens": 189, "rawContextTokens": 192 }
-        [wire] llm.tools_snapshot           { "hash": "e1c03bebb1298f76f76913ceac4f165154dcac73691b41c958927104c5a87dbf", "tools": [ { "name": "Agent", "description": "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\\n\\nWriting the prompt:\\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\\n\\nUsage notes:\\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its \`resume\` id) over spawning a fresh instance — the resumed agent keeps its prior context.\\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\\n- Subagents use a fixed 30-minute timeout. If one times out, resume the same agent instead of starting over.\\n\\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\\n\\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\\n\\n\\nWhen \`run_in_background=true\`, the subagent runs detached from this turn. The completion arrives in a later turn as a synthetic user-role message containing its result — you do not need to poll, sleep, or check on its progress. Continue with other work or respond to the user. Never fabricate or predict what the result will say.\\n\\nDefault to a foreground subagent (omit \`run_in_background\`) when your next step needs its result — foreground hands the result straight back. Reach for \`run_in_background=true\` only when you have other work to do while it runs and do not need its result to proceed. Never launch in the background and then immediately wait on it (with \`TaskOutput block=true\`, sleeping, or otherwise): that just blocks the turn for no benefit — run it in the foreground instead.\\n\\n\\nAvailable agent types (pass via subagent_type):\\n- plan: Read-only implementation planning and architecture design. Use this agent when the parent agent needs a step-by-step implementation plan, key file identification, and architectural trade-off analysis before code changes are made.\\n  Tools: Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL\\n- agent: Default Kimi Code agent\\n  Tools: Read, Write, Edit, Grep, Glob, Bash, TaskList, TaskOutput, TaskStop, CronCreate, CronList, CronDelete, ReadMediaFile, TodoList, Skill, WebSearch, Agent, AgentSwarm, FetchURL, AskUserQuestion, EnterPlanMode, ExitPlanMode, CreateGoal, GetGoal, SetGoalBudget, UpdateGoal, mcp__*, spine_open, spine_close, spine_next, spine_tree\\n- coder: General software engineering agent — the only subagent type with file-editing tools; use it for any delegated task that must modify code. Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.\\n  Tools: Agent, AgentSwarm, Bash, CronCreate, CronDelete, CronList, Edit, EnterPlanMode, ExitPlanMode, Glob, Grep, Read, ReadMediaFile, Skill, TaskList, TaskOutput, TaskStop, TodoList, WebSearch, FetchURL, Write, mcp__*\\n- explore: Fast codebase exploration with prompt-enforced read-only behavior. Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (e.g. \\"src/**/*.yaml\\"), search code for keywords (e.g. \\"database connection\\"), or answer questions about the codebase (e.g. \\"how does the auth module work?\\"). When calling this agent, specify the desired thoroughness level: \\"quick\\" for basic searches, \\"medium\\" for moderate exploration, or \\"thorough\\" for comprehensive analysis across multiple locations and naming conventions. Use this agent for any read-only exploration that will clearly require more than 3 search queries. Prefer launching multiple explore agents concurrently when investigating independent questions.\\n  Tools: Bash, Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "prompt": { "type": "string", "description": "Full task prompt for the subagent" }, "description": { "type": "string", "description": "Short task description (3-5 words) for UI display" }, "subagent_type": { "description": "One of the available agent types (see \\"Available agent types\\" in this tool description). Defaults to \\"coder\\" when omitted.", "type": "string" }, "resume": { "description": "Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected.", "type": "string" }, "run_in_background": { "description": "If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting.", "type": "boolean" } }, "required": [ "prompt", "description" ], "additionalProperties": false } }, { "name": "AgentSwarm", "description": "Launch multiple subagents from one prompt template, existing agent resumes, or both.\\n\\nUse AgentSwarm when many subagents should run the same kind of task over different inputs. The placeholder is exactly \`{{item}}\`. For example, with \`prompt_template\` set to \`Review {{item}} for likely regressions.\` and \`items\` set to \`[\\"src/a.ts\\", \\"src/b.ts\\"]\`, AgentSwarm launches two new subagents with those two concrete prompts. For a few differently-shaped tasks, make separate \`Agent\` calls in one message instead.\\n\\nUse \`resume_agent_ids\` to continue subagents that already exist from earlier work, such as ones that failed or timed out: map each agent id to the prompt for that resumed subagent (usually \`continue\` if no extra information is needed). You may combine \`resume_agent_ids\` with \`items\` in the same call to resume existing subagents and launch new ones. Do not duplicate resumed work in \`items\`.\\n\\nEach of these is enforced — a violation is rejected before any subagent starts: provide at least 2 \`items\` unless you pass \`resume_agent_ids\`; whenever \`items\` are present, \`prompt_template\` is required and must contain \`{{item}}\`; and the filled-in prompts must be distinct (two items that expand to the same prompt are rejected).\\n\\nUse enough subagents to keep the work focused and parallel. AgentSwarm supports up to 128 subagents, and launches are queued automatically, so it is safe to split large tasks into many clear, independent items.\\n\\nIf \`AgentSwarm\` is called, that call must be the only tool call in the response.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "description": { "type": "string", "minLength": 1, "description": "Short description for the whole swarm." }, "subagent_type": { "description": "Subagent type used for every new subagent spawned from items; defaults to coder when omitted. Resumed subagents always keep their original type, so passing subagent_type together with resume_agent_ids is allowed — it only affects the item-based spawns.", "type": "string", "minLength": 1 }, "prompt_template": { "description": "Prompt template for each subagent. The {{item}} placeholder is replaced with each item value.", "type": "string", "minLength": 1 }, "items": { "description": "Values used to fill {{item}}. Each item launches one new subagent.", "maxItems": 128, "type": "array", "items": { "type": "string", "minLength": 1 } }, "resume_agent_ids": { "description": "Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents.", "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "type": "string", "minLength": 1 } } }, "required": [ "description" ], "additionalProperties": false } }, { "name": "AskUserQuestion", "description": "Use this tool when you need to ask the user questions with structured options during execution. This allows you to:\\n1. Collect user preferences or requirements before proceeding\\n2. Resolve ambiguous or underspecified instructions\\n3. Let the user decide between implementation approaches as you work\\n4. Present concrete options when multiple valid directions exist\\n\\n**When NOT to use:**\\n- When you can infer the answer from context — be decisive and proceed\\n- Trivial decisions that don't materially affect the outcome\\n\\nOverusing this tool interrupts the user's flow. Only use it when the user's input genuinely changes your next action.\\n\\n**Usage notes:**\\n- Users always have an \\"Other\\" option for custom input — don't create one yourself\\n- Use multi_select to allow multiple answers to be selected for a question\\n- Keep option labels concise (1-5 words), use descriptions for trade-offs and details\\n- Each question should have 2-4 meaningful, distinct options\\n- Question texts must be unique across the call, and option labels must be unique within each question\\n- You can ask 1-4 questions at a time; group related questions to minimize interruptions\\n- If you recommend a specific option, list it first and append \\"(Recommended)\\" to its label\\n- The result is JSON with an \`answers\` object keyed by question text; each value is the chosen option's label (comma-separated labels for multi_select, or the user's own words if they picked \\"Other\\"); if \`answers\` is empty and a \`note\` says the user dismissed it, they chose not to answer — do not treat this as selecting the recommended option; decide based on context and do not re-ask the same question\\n- Set background=true when you can keep working without the answer. This starts a background question task and returns a task_id immediately. The answer arrives automatically in a later turn — you do not need to poll, sleep, or check on it. Continue with other work; never fabricate or predict the answer.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "questions": { "minItems": 1, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "question": { "type": "string", "minLength": 1, "description": "A specific, actionable question. End with '?'." }, "header": { "default": "", "description": "Short category tag (max 12 chars, e.g. 'Auth', 'Style').", "type": "string" }, "options": { "minItems": 2, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "description": "Concise display text (1-5 words). If recommended, append '(Recommended)'." }, "description": { "default": "", "description": "Brief explanation of trade-offs or implications.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false }, "description": "2-4 meaningful, distinct options. Do NOT include an 'Other' option — the system adds one automatically." }, "multi_select": { "default": false, "description": "Whether the user can select multiple options.", "type": "boolean" } }, "required": [ "question", "options" ], "additionalProperties": false }, "description": "The questions to ask the user (1-4 questions)." }, "background": { "default": false, "description": "Set true to ask in the background and return immediately with a background task_id; you are notified automatically when the user answers — do not poll with TaskOutput while the question is pending.", "type": "boolean" } }, "required": [ "questions" ], "additionalProperties": false } }, { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nIf \`run_in_background=true\`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short \`description\`. Background commands default to a 600s timeout and \`timeout\` is capped at 86400s; set \`disable_timeout=true\` only when the task should run without a timeout. You will be automatically notified when the task completes. After starting one, default to returning control to the user instead of immediately waiting on it. Use \`TaskOutput\` only for a non-blocking status/output snapshot — do not set \`block=true\` to wait for a task you just launched, since its completion arrives automatically; reserve \`block=true\` for when the user explicitly asked you to wait. Use \`TaskStop\` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the \`/tasks\` command, which opens an interactive panel; it has no subcommands.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the \`timeout\` argument in seconds. Foreground commands default to 60s and allow up to 300s. When a foreground command hits its timeout it is moved to the background instead of being killed, and you will be automatically notified when it completes.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Prefer \`run_in_background=true\` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } }, { "name": "CreateGoal", "description": "Create a durable, structured goal that the runtime will pursue across multiple turns.\\n\\nCall \`CreateGoal\` only when:\\n\\n- the user explicitly asks you to start a goal or work autonomously toward an outcome, or\\n- a host goal-intake prompt asks you to create one.\\n\\nDo NOT create a goal for greetings, ordinary questions, or vague requests that lack a\\nverifiable completion condition. A goal needs a checkable end state.\\n\\nWhen the request is vague, ask the user for the missing completion criterion before creating\\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\\nrespect that and create the goal.\\n\\nInclude a \`completionCriterion\` when the user provides one, or when it can be stated without\\ninventing new requirements. Keep \`objective\` concise; reference long task descriptions by file\\npath rather than pasting them.\\n\\nCreating a goal fails if one already exists, so use \`replace: true\` only when the user explicitly\\nwants to abandon the current goal and start a new one.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "objective": { "type": "string", "minLength": 1, "description": "The objective to pursue. Must have a verifiable end state." }, "completionCriterion": { "description": "How to verify the goal is complete. Include when the user provides one.", "type": "string" }, "replace": { "description": "Replace an existing active, paused, or blocked goal instead of failing.", "type": "boolean" } }, "required": [ "objective" ], "additionalProperties": false } }, { "name": "Edit", "description": "Perform exact replacements in existing files.\\n\\n- Edit is mandatory for every incremental change, especially small edits. DO NOT use Write or Bash \`sed\`.\\n- Read the target file before every Edit. DO NOT call Edit from memory, stale context, or a guessed \`old_string\`.\\n- Take \`old_string\` and \`new_string\` from the Read output view.\\n- Drop the line-number prefix and tab; match only file content.\\n- \`old_string\` must be unique unless \`replace_all\` is set.\\n- If \`old_string\` is ambiguous, add surrounding context. Use \`replace_all\` only when every occurrence should change — for example, renaming a symbol throughout the file.\\n- Multiple Edit calls may run in one response only when they do not target the same file.\\n- DO NOT issue consecutive Edit calls on the same file. A previous Edit can invalidate a later Edit's \`old_string\`, causing \`old_string not found\`. Read the file again before the next Edit.\\n- A write lock serializes same-file edits in response order, but serialization does not make stale \`old_string\` valid.\\n- For pure CRLF files, Read shows LF; use LF in \`old_string\` and \`new_string\`, and Edit writes CRLF back.\\n- For mixed endings or lone carriage returns, Read shows carriage returns as \\\\r; include actual \\\\r escapes in those positions.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the text file to edit. Relative paths resolve against the working directory; a path outside the working directory must be absolute." }, "old_string": { "type": "string", "minLength": 1, "description": "Exact content to replace from the Read output view, without the line-number prefix. Use LF for pure CRLF files; use actual \\\\r escapes where Read shows \\\\r." }, "new_string": { "type": "string", "description": "Replacement text in the same Read output view. LF is written back as CRLF only for pure CRLF files." }, "replace_all": { "description": "Set true only when every occurrence of old_string should be replaced.", "type": "boolean" } }, "required": [ "path", "old_string", "new_string" ], "additionalProperties": false } }, { "name": "EnterPlanMode", "description": "Use this tool proactively when you're about to start a non-trivial implementation task.\\nGetting user sign-off on your approach via ExitPlanMode before writing code prevents wasted effort.\\n\\nUse it when ANY of these conditions apply:\\n\\n1. New Feature Implementation - e.g. \\"Add a caching layer to the API\\"\\n2. Multiple Valid Approaches - e.g. \\"Optimize database queries\\" (indexing vs rewrite vs caching)\\n3. Code Modifications - e.g. \\"Refactor auth module to support OAuth\\"\\n4. Architectural Decisions - e.g. \\"Add WebSocket support\\"\\n5. Multi-File Changes - involves more than 2-3 files\\n6. Unclear Requirements - need exploration to understand scope\\n7. User Preferences Matter - if user input would materially change the implementation approach, use EnterPlanMode to structure the decision\\n\\nPermission mode notes:\\n- EnterPlanMode enters plan mode automatically without an approval prompt in all permission modes.\\n- In yolo and manual modes, ExitPlanMode still presents the plan to the user for approval.\\n- In auto permission mode, do not use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, ExitPlanMode exits plan mode without asking the user.\\n- Use EnterPlanMode only when planning itself adds value.\\n\\nWhen NOT to use:\\n- Single-line or few-line fixes (typos, obvious bugs, small tweaks)\\n- User gave very specific, detailed instructions\\n- Pure research/exploration tasks\\n\\nOnce you are in plan mode, a reminder walks you through the workflow (explore → design → write the plan file → \`ExitPlanMode\`) and enforces read-only access. For non-trivial tasks where you are unsure of the codebase structure or relevant code paths, use \`Agent(subagent_type=\\"explore\\")\` to investigate first when the \`Agent\` tool is available.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "ExitPlanMode", "description": "Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.\\n\\n## How This Tool Works\\n- You should have already written your plan to the plan file specified in the plan mode reminder.\\n- This tool does NOT take the plan content as a parameter - it reads the plan from the file you wrote.\\n- The user will see the contents of your plan file when they review it. In auto permission mode, the tool reads the file and exits plan mode without asking the user.\\n\\n## When to Use\\nOnly use this tool for tasks that require planning implementation steps. For research tasks (searching files, reading code, understanding the codebase), do NOT use this tool.\\n\\n## What a good plan contains\\nList specific, verifiable steps grounded in the actual codebase — real files, functions, and commands, in a sensible order. Each step should be concrete enough to act on and to check. Avoid vague filler like \\"improve performance\\" or \\"add tests\\"; say what to change and where.\\n\\n## Multiple Approaches\\nIf your plan offers multiple alternative approaches, pass them via the \`options\` parameter so the user can choose which one to execute — see the \`options\` parameter for the format, count, and reserved labels. In yolo and manual modes the user sees all options alongside the host's Reject and Revise controls.\\n\\n## Before Using\\n- In auto permission mode, do NOT use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, this tool exits plan mode without asking the user.\\n- In yolo and manual modes, this tool still presents the plan to the user for approval.\\n- If auto permission mode is not active and you have unresolved questions, use AskUserQuestion first.\\n- If auto permission mode is not active and you have multiple approaches and haven't narrowed down yet, consider using AskUserQuestion first to let the user choose, then write a plan for the chosen approach only.\\n- Once your plan is finalized, use THIS tool to request approval.\\n- Do NOT use AskUserQuestion to ask \\"Is this plan OK?\\" or \\"Should I proceed?\\" - that is exactly what ExitPlanMode does.\\n- If rejected, revise based on feedback and call ExitPlanMode again.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "options": { "description": "When the plan contains multiple alternative approaches, list them here so the user can choose which one to execute. Provide up to 3 options; 2-3 distinct approaches work best when the plan offers a real choice. Passing a single option is allowed and is equivalent to a plain plan approval. Each option represents a distinct approach from the plan. Do not use \\"Reject\\", \\"Revise\\", \\"Approve\\", or \\"Reject and Exit\\" as labels.", "minItems": 1, "maxItems": 3, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "maxLength": 80, "description": "Short name for this option (1-8 words). Append \\"(Recommended)\\" if you recommend this option." }, "description": { "default": "", "description": "Brief summary of this approach and its trade-offs.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "FetchURL", "description": "Fetch content from a URL. The content is returned either as the main text extracted from the page, or as the full response body verbatim; a note at the top of the result states which of the two you received, so you can judge how complete it is. Use this when you need to read a specific web page.\\n\\nOnly fully-formed public \`http\`/\`https\` URLs are supported; other schemes and private or loopback addresses are not fetched. Very large pages may be truncated or refused. The fetch carries no login or session for the target site, so pages behind authentication (private repositories, internal dashboards) return a login page or an error instead of the real content — if the text you get back looks like a generic landing or sign-in page, treat that as the login wall, not the answer, and reach the content through a credentialed route (an authenticated CLI or MCP tool) instead.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "url": { "type": "string", "description": "The URL to fetch content from." } }, "required": [ "url" ], "additionalProperties": false } }, { "name": "GetGoal", "description": "Read the current goal: its objective, completion criterion, status, and budgets (turns, tokens,\\ntime, and how much of each remains). When the goal has stopped, it also reports the terminal reason.\\n\\nUse \`GetGoal\` before deciding whether to continue working, report completion, report a blocker,\\nor respect a pause. It returns \`{ \\"goal\\": null }\` when there is no current goal.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "Glob", "description": "Find files by glob pattern, sorted by modification time (most recent first).\\n\\nPowered by ripgrep. Respects \`.gitignore\`, \`.ignore\`, and \`.rgignore\` by default — set \`include_ignored\` to also match ignored files (e.g. build outputs, \`node_modules\`). Sensitive files (such as \`.env\`) are always filtered out. Matches are files only — directories themselves are never listed; to find a directory, glob for a file inside it (e.g. \`**/fixtures/**\`).\\n\\nGood patterns:\\n- \`*.ts\` — all files matching an extension, at any depth below the search root (a bare pattern without \`/\` matches recursively)\\n- \`src/*.ts\` — files directly inside \`src/\` (one level, not recursive)\\n- \`src/**/*.ts\` — recursive walk with a subdirectory anchor and extension\\n- \`**/*.py\` — recursive walk from the search root for an extension\\n- \`*.{ts,tsx}\` — brace expansion is supported\\n- \`{src,test}/**/*.ts\` — cartesian brace expansion is supported too\\n\\nResults are capped at the first 100 matching paths. If a search would return more, a truncation marker is appended. Refine the pattern (extension, subdirectory) when 100 is not enough, or call again with a narrower anchor.\\n\\nLarge-directory caveat — avoid recursing into dependency / build output even with an anchor, especially when \`include_ignored\` is set:\\n- \`node_modules/**/*.js\`, \`.venv/**/*.py\`, \`__pycache__/**\`, \`target/**\` can produce thousands of results that truncate at the match cap and waste context. Prefer specific subpaths like \`node_modules/react/src/**/*.js\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Glob pattern to match files." }, "path": { "description": "Directory to search. Accepts an absolute path, or a path relative to the current working directory. Defaults to the current working directory.", "type": "string" }, "include_ignored": { "description": "Also match files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" }, "include_dirs": { "description": "Deprecated and ignored. Results are always files-only — directories are never listed. Accepted only so older calls that still pass this flag are not rejected by parameter validation.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Grep", "description": "Search file contents using regular expressions (powered by ripgrep).\\n\\nUse Grep when the task is to find unknown content or unknown file locations. Do not use shell \`grep\` or \`rg\` directly; this tool applies workspace path policy, output limits, and sensitive-file filtering.\\nALWAYS use Grep tool instead of running \`grep\` or \`rg\` from a shell — direct shell calls bypass workspace policy, output limits, and sensitive-file filtering.\\nIf you already know a concrete file path and need to inspect its contents, use Read directly instead.\\n\\nWrite patterns in ripgrep regex syntax, which differs from POSIX \`grep\` syntax. For example, braces are special, so escape them as \`\\\\{\` to match a literal \`{\`.\\n\\nHidden files (dotfiles such as \`.gitlab-ci.yml\` or \`.eslintrc.json\`) are searched by default. To also search files excluded by \`.gitignore\` (such as \`node_modules\` or build outputs), set \`include_ignored\` to \`true\`. Sensitive files (such as \`.env\`) are always skipped for safety, even when \`include_ignored\` is \`true\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Regular expression to search for." }, "path": { "description": "File or directory to search. Accepts an absolute path, or a path relative to the current working directory. Omit to search the current working directory. Use Read instead when you already know a concrete file path and need its contents.", "type": "string" }, "glob": { "description": "Optional glob filter for which files to search, e.g. \`*.ts\`. Matched against each file's full absolute path, so a path-anchored pattern like \`src/**/*.ts\` silently matches nothing — use a basename pattern (\`*.ts\`), or anchor with \`**/\` (\`**/src/**/*.ts\`). To scope the search to a directory, use \`path\` instead.", "type": "string" }, "type": { "description": "Optional ripgrep file type filter, such as ts or py. Prefer this over \`glob\` when filtering by language or file kind: it is more efficient and less error-prone than an equivalent glob pattern.", "type": "string" }, "output_mode": { "description": "Shape of the result. \`content\` shows matching lines (honors \`-A\`, \`-B\`, \`-C\`, \`-n\`, and \`head_limit\`); \`files_with_matches\` shows only the paths of files that contain a match, most-recently-modified first (honors \`head_limit\`); \`count_matches\` shows per-file match counts as \`path:count\` lines, preceded by an aggregate total line. Defaults to \`files_with_matches\`.", "type": "string", "enum": [ "content", "files_with_matches", "count_matches" ] }, "-i": { "description": "Perform a case-insensitive search. Defaults to false.", "type": "boolean" }, "-n": { "description": "Prefix each matching line with its line number. Applies only when \`output_mode\` is \`content\`. Defaults to true.", "type": "boolean" }, "-A": { "description": "Number of lines to show after each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-B": { "description": "Number of lines to show before each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-C": { "description": "Number of lines to show before and after each match. Applies only when \`output_mode\` is \`content\`; takes precedence over \`-A\` and \`-B\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "head_limit": { "description": "Limit output to the first N lines/entries after offset. Defaults to 250. Pass 0 for unlimited.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "offset": { "description": "Number of leading lines/entries to skip before applying \`head_limit\`. Use it together with \`head_limit\` to page through large result sets. Defaults to 0.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "multiline": { "description": "Enable multiline matching, where the pattern can span line boundaries and \`.\` also matches newlines. Defaults to false.", "type": "boolean" }, "include_ignored": { "description": "Also search files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Read", "description": "Read a text file from the local filesystem.\\n\\nIf the user provides a concrete file path to a text file, call Read directly. Do not \`Glob\`, \`ls\`, or otherwise pre-check known text file paths; missing or invalid file paths return errors you can handle. Do not use Read for directories; use \`ls\` via Bash for a known directory, or Glob when you need files matching a name pattern (Glob lists files only, never directories). Use \`Grep\` only when the task is to search for unknown content or locations.\\n\\nWhen you need several files, prefer to read them in parallel: emit multiple \`Read\` calls in a single response instead of reading one file per turn.\\n\\n- Relative paths resolve against the working directory; a path outside the working directory must be absolute.\\n- Returns up to 1000 lines or 100 KB per call, whichever comes first; lines longer than 2000 chars are truncated mid-line.\\n- Page larger files with \`line_offset\` (1-based start line) and \`n_lines\`. Omit \`n_lines\` to read up to the 1000-line cap.\\n- Sensitive files (\`.env\` files, credential stores, SSH private keys, and similar secrets) are refused to protect secrets; do not attempt to read them. Templates and public keys are exempt: \`.env.example\` / \`.env.sample\` / \`.env.template\` and public SSH keys such as \`id_rsa.pub\` read normally.\\n- Only UTF-8 text files can be read. Non-UTF-8 encodings, binary files, and files containing NUL bytes are refused; use \`ReadMediaFile\` for images or video, and Bash or an MCP tool for other binary formats.\\n- Negative line_offset reads from the end of the file (for example, -100 reads the last 100 lines); the absolute value cannot exceed 1000.\\n- Output format: \`<line-number>\\\\t<content>\` per line.\\n- A \`<system>...</system>\` status block is appended after the file content; it summarizes how much was read (line and byte counts, truncation, line-ending notes) and is not part of the file itself.\\n- Pure CRLF files are displayed with LF line endings; \`Edit\` matches this output and preserves CRLF when writing back.\\n- Mixed or lone carriage-return line endings are shown as \`\\\\r\` and require exact \`Edit.old_string\` escapes.\\n- After a successful \`Edit\`/\`Write\`, do not re-read solely to prove the write landed. When the task depends on an exact file, API, or output shape, inspect the final external contract before finishing.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to a text file. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Directories are not supported; use \`ls\` via Bash for a known directory, or Glob for pattern search." }, "line_offset": { "description": "The line number to start reading from. Omit to start at line 1. Negative values read from the end of the file; the absolute value cannot exceed 1000.", "anyOf": [ { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, { "type": "integer", "minimum": -1000, "maximum": -1 } ] }, "n_lines": { "description": "The number of lines to read; the tool also applies its internal cap. Omit to read up to the internal cap of 1000 lines.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 } }, "required": [ "path" ], "additionalProperties": false } }, { "name": "SetGoalBudget", "description": "Set a hard budget limit for the current goal.\\n\\nUse this only when the user clearly gives a runtime limit, such as:\\n\\n- \\"stop after 20 turns\\"\\n- \\"use no more than 500k tokens\\"\\n- \\"finish within 30 minutes\\"\\n\\nDo not invent limits. Do not call this for vague wording such as \\"spend some time\\" or\\n\\"try to be quick\\".\\n\\nIf the user gives a compound time, convert it to one supported unit before calling this tool.\\nFor example, \\"2 hours and 3 minutes\\" can be set as \`value: 123, unit: \\"minutes\\"\`.\\n\\nA time budget must be between 1 second and 24 hours — the tool rejects anything shorter or\\nlonger, telling the user it is not a reasonable goal budget. Turn and token budgets are not\\nbounded this way; they must be positive and are rounded to the nearest whole number (minimum 1).\\n\\nSupported units:\\n\\n- \`turns\`\\n- \`tokens\`\\n- \`milliseconds\`\\n- \`seconds\`\\n- \`minutes\`\\n- \`hours\`\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "value": { "type": "number", "exclusiveMinimum": 0, "description": "The positive numeric budget value." }, "unit": { "type": "string", "enum": [ "turns", "tokens", "milliseconds", "seconds", "minutes", "hours" ] } }, "required": [ "value", "unit" ], "additionalProperties": false } }, { "name": "Skill", "description": "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a \`<kimi-skill-loaded>\` block for it with the same \`args\` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier \`args\` and will not reflect new inputs.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "skill": { "type": "string", "description": "The exact name of the skill to invoke, spelled as it appears in the current skill listing (e.g. \\"commit\\", \\"pdf\\")." }, "args": { "description": "Optional argument string for the skill, written like a command line (e.g. \`-m \\"fix bug\\"\`, \`123\`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing \`ARGUMENTS:\` line. Omit it only when there is nothing to pass.", "type": "string" } }, "required": [ "skill" ], "additionalProperties": false } }, { "name": "TaskList", "description": "List background tasks and their current status.\\n\\nUse this tool to discover which background tasks exist and where each one\\nstands. It is the entry point for inspecting background work: it returns a\\ntask ID, status, and description for every task it reports, plus the command,\\nPID, and (once finished) exit code for shell tasks, and a stop reason for any\\ntask that ended early.\\n\\nGuidelines:\\n\\n- After a context compaction, or whenever you are unsure which background\\n  tasks are running or what their task IDs are, call this tool to\\n  re-enumerate them instead of guessing a task ID.\\n- Prefer the default \`active_only=true\`, which lists only non-terminal tasks.\\n  Pass \`active_only=false\` only when you specifically need to see tasks that\\n  have already finished. With \`active_only=false\` the result may also include\\n  \`lost\` tasks — tasks left over from a previous process that can no longer be\\n  inspected or controlled; treat them as already terminated.\\n- \`limit\` caps how many tasks are returned. It accepts a value between 1 and\\n  100 and defaults to 20 when omitted.\\n- This tool only lists tasks; it does not return their output. Use it first\\n  to locate the task ID you need, then call \`TaskOutput\` with that ID to read\\n  the task's output and details.\\n- This tool is read-only and does not change any state, so it is always safe\\n  to call, including in plan mode.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "active_only": { "default": true, "description": "Whether to list only non-terminal background tasks.", "type": "boolean" }, "limit": { "default": 20, "description": "Maximum number of tasks to return.", "type": "integer", "minimum": 1, "maximum": 100 } }, "additionalProperties": false } }, { "name": "TaskOutput", "description": "Retrieve a snapshot of a running or completed background task.\\n\\nUse this after \`Bash(run_in_background=true)\` or \`Agent(run_in_background=true)\` to check progress, or to read the output of a task that has already completed.\\n\\nGuidelines:\\n- Prefer relying on automatic completion notifications. Use this tool only when you need task output before the automatic notification arrives.\\n- By default this tool is non-blocking and returns a current status/output snapshot — that is the normal way to use it.\\n- Do not use TaskOutput to wait for a result you need before continuing — if your next step depends on the task's result, run that task in the foreground instead. TaskOutput is for a deliberate progress check you will act on without blocking, not a way to sit and wait for a background task you just launched.\\n- Use block=true only when the user explicitly asked you to wait for the task. Never block on a task you launched in the current turn — if you need its result right away, it should have been a foreground call.\\n- If a block=true call returns \`retrieval_status: timeout\` (the task is still running), do not block on the same task again. Continue with other work or hand back to the user — the completion notification arrives on its own.\\n- This tool returns structured task metadata, a fixed-size output preview, and an output_path for the full log.\\n- For a terminal task, the metadata also explains why it ended. A shell command that runs to completion reports \`status: completed\` on a zero exit, or \`status: failed\` with its non-zero \`exit_code\` — judge that failure from the \`exit_code\`, because a plain command failure carries no \`stop_reason\` and no \`terminal_reason\`. \`terminal_reason\` is a categorical label emitted only when the end is not an ordinary exit: \`timed_out\` when the deadline aborted it, \`stopped\` when it was explicitly stopped, or \`failed\` when it errored without producing an exit code; the \`stopped\` and \`failed\` cases also carry a human-readable \`stop_reason\`. A task that finished on its own with a clean exit carries neither \`stop_reason\` nor \`terminal_reason\`.\\n- The full, never-truncated log is always available at output_path; use the \`Read\` tool with that path to page through it, whether or not the preview was truncated.\\n- This tool works with the generic background task system and should remain the primary read path for future task types, not just bash.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to inspect." }, "block": { "default": false, "description": "Whether to wait for the task to finish before returning. Discouraged — background tasks notify automatically on completion; use only when the user explicitly asked you to wait.", "type": "boolean" }, "timeout": { "default": 30, "description": "Maximum number of seconds to wait when block=true.", "type": "integer", "minimum": 0, "maximum": 3600 } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TaskStop", "description": "Stop a running background task.\\n\\nOnly use this when a task must genuinely be cancelled — for a task that is\\nfinishing normally, wait for its completion notification or inspect it with\\n\`TaskOutput\` instead of stopping it.\\n\\nGuidelines:\\n- This is a general-purpose stop capability for any background task. It is not\\n  a bash-specific kill.\\n- Stopping a task is destructive: it may leave partial side effects behind.\\n  Use it with care.\\n- If the task has already finished, this tool simply returns its current\\n  status.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to stop." }, "reason": { "default": "Stopped by TaskStop", "description": "Short reason recorded when the task is stopped.", "type": "string" } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TodoList", "description": "Use this tool to maintain a structured TODO list as you work through a multi-step task. Use it proactively and often when progress tracking helps the current work. This is especially useful in long-running investigations and implementation tasks with several tool calls; in plan mode, write the plan to the plan file rather than tracking it here.\\n\\n**When to use:**\\n- Multi-step tasks that span several tool calls\\n- Tracking investigation progress across a large codebase search\\n- Planning a sequence of edits before making them\\n- After receiving new multi-step instructions, capture the requirements as todos\\n- Before starting a tracked task, mark exactly one item as \`in_progress\`\\n- Immediately after finishing a tracked task, mark it \`done\`; do not batch completions at the end\\n\\n**When NOT to use:**\\n- Single-shot answers that complete in one or two tool calls\\n- Trivial requests where tracking adds no clarity\\n- Purely conversational or informational replies\\n\\n**Avoid churn:**\\n- Do not re-call this tool when nothing meaningful has changed since the last call — update the list only after real progress.\\n- When unsure of the current state, call query mode first (omit \`todos\`) to check the list before deciding what to update.\\n- If no available tool can move any task forward, tell the user where you are stuck instead of repeatedly re-ordering the same todos.\\n\\n**How to use:**\\n- Call with \`todos: [...]\` to replace the full list. Statuses: pending / in_progress / done.\\n- Call with no \`todos\` argument to retrieve the current list without changing it.\\n- Call with \`todos: []\` to clear the list.\\n- Keep titles short and actionable (e.g. \\"Read session-control.ts\\", \\"Add planMode flag to TurnManager\\").\\n- Update statuses as you make progress.\\n- When work is underway, keep exactly one task \`in_progress\`.\\n- Only mark a task \`done\` when it is fully accomplished.\\n- Never mark a task \`done\` if tests are failing, implementation is partial, unresolved errors remain, or required files/dependencies could not be found.\\n- If you encounter a blocker, keep the blocked task \`in_progress\` or add a new pending task describing what must be resolved.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "todos": { "description": "The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.", "type": "array", "items": { "type": "object", "properties": { "title": { "type": "string", "minLength": 1, "description": "Short, actionable title for the todo." }, "status": { "type": "string", "enum": [ "pending", "in_progress", "done" ], "description": "Current status of the todo." } }, "required": [ "title", "status" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "UpdateGoal", "description": "Set the status of the current goal. This is how you resume, complete, or block an autonomous goal.\\n\\n- \`active\` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\\n- \`complete\` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded. Before using this, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not use \`complete\` merely because a budget is nearly exhausted or you want to stop.\\n- \`blocked\` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. For non-terminal blockers, do not use \`blocked\` the first time you hit the blocker. The same blocking condition must repeat for at least 3 consecutive goal turns before you call \`blocked\`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. If the objective itself is impossible, unsafe, or contradictory, call \`blocked\` in the same turn instead of running more goal turns. Do not use \`blocked\` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call \`blocked\` instead of leaving the goal active.\\n\\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call \`complete\` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not call \`complete\` after only producing a plan, summary, first pass, or partial result. Call \`blocked\` only after the blocked audit threshold is met. If you call \`blocked\`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "status": { "type": "string", "enum": [ "active", "complete", "blocked" ], "description": "The lifecycle status to set for the current goal. Use \`blocked\` for impossible, unsafe, or contradictory objectives, or after the same non-terminal blocking condition repeats for at least 3 consecutive goal turns." } }, "required": [ "status" ], "additionalProperties": false } }, { "name": "Write", "description": "Create, append to, or replace a file entirely.\\n\\n- Missing parent directories are created automatically (like \`mkdir(parents=True, exist_ok=True)\`).\\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\\n- Do not create unsolicited documentation files (\`*.md\` write-ups, \`README\`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\\n- Read before overwriting an existing file.\\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\\n- Write outputs content literally, including supplied line endings: \\\\n stays LF, \\\\r\\\\n stays CRLF.\\n- For new content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically." }, "content": { "type": "string", "description": "Raw full file content to write exactly as provided. This does not use the Read/Edit text view." }, "mode": { "description": "Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline.", "type": "string", "enum": [ "overwrite", "append" ] } }, "required": [ "path", "content" ], "additionalProperties": false } } ], "time": "<time>" }
-        [wire] llm.request                  { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999811, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "e1c03bebb1298f76f76913ceac4f165154dcac73691b41c958927104c5a87dbf", "messageCount": 6, "turnStep": "1.1", "time": "<time>" }
+        [wire] llm.tools_snapshot           { "hash": "b0e35cedccd898afc718a76e65bcb9fb84b7657958a03a95d49f40a40b99a81f", "tools": [ { "name": "Agent", "description": "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\\n\\nWriting the prompt:\\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\\n\\nUsage notes:\\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its \`resume\` id) over spawning a fresh instance — the resumed agent keeps its prior context.\\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\\n- Subagents use a fixed 2-hour timeout. If one times out, resume the same agent instead of starting over.\\n\\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\\n\\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\\n\\n\\nWhen \`run_in_background=true\`, the subagent runs detached from this turn. The completion arrives in a later turn as a synthetic user-role message containing its result — you do not need to poll, sleep, or check on its progress. Continue with other work or respond to the user. Never fabricate or predict what the result will say.\\n\\nDefault to a foreground subagent (omit \`run_in_background\`) when your next step needs its result — foreground hands the result straight back. Reach for \`run_in_background=true\` only when you have other work to do while it runs and do not need its result to proceed. Never launch in the background and then immediately wait on it (with \`TaskOutput block=true\`, sleeping, or otherwise): that just blocks the turn for no benefit — run it in the foreground instead.\\n\\n\\nAvailable agent types (pass via subagent_type):\\n- plan: Read-only implementation planning and architecture design. Use this agent when the parent agent needs a step-by-step implementation plan, key file identification, and architectural trade-off analysis before code changes are made.\\n  Tools: Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL\\n- agent: Default Kimi Code agent\\n  Tools: Read, Write, Edit, Grep, Glob, Bash, TaskList, TaskOutput, TaskStop, CronCreate, CronList, CronDelete, ReadMediaFile, TodoList, Skill, WebSearch, Agent, AgentSwarm, FetchURL, AskUserQuestion, EnterPlanMode, ExitPlanMode, CreateGoal, GetGoal, SetGoalBudget, UpdateGoal, mcp__*, spine_open, spine_close, spine_next, spine_tree\\n- coder: General software engineering agent — the only subagent type with file-editing tools; use it for any delegated task that must modify code. Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.\\n  Tools: Agent, AgentSwarm, Bash, CronCreate, CronDelete, CronList, Edit, EnterPlanMode, ExitPlanMode, Glob, Grep, Read, ReadMediaFile, Skill, TaskList, TaskOutput, TaskStop, TodoList, WebSearch, FetchURL, Write, mcp__*\\n- explore: Fast codebase exploration with prompt-enforced read-only behavior. Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (e.g. \\"src/**/*.yaml\\"), search code for keywords (e.g. \\"database connection\\"), or answer questions about the codebase (e.g. \\"how does the auth module work?\\"). When calling this agent, specify the desired thoroughness level: \\"quick\\" for basic searches, \\"medium\\" for moderate exploration, or \\"thorough\\" for comprehensive analysis across multiple locations and naming conventions. Use this agent for any read-only exploration that will clearly require more than 3 search queries. Prefer launching multiple explore agents concurrently when investigating independent questions.\\n  Tools: Bash, Read, ReadMediaFile, Glob, Grep, WebSearch, FetchURL", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "prompt": { "type": "string", "description": "Full task prompt for the subagent" }, "description": { "type": "string", "description": "Short task description (3-5 words) for UI display" }, "subagent_type": { "description": "One of the available agent types (see \\"Available agent types\\" in this tool description). Defaults to \\"coder\\" when omitted.", "type": "string" }, "resume": { "description": "Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected.", "type": "string" }, "run_in_background": { "description": "If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting.", "type": "boolean" } }, "required": [ "prompt", "description" ], "additionalProperties": false } }, { "name": "AgentSwarm", "description": "Launch multiple subagents from one prompt template, existing agent resumes, or both.\\n\\nUse AgentSwarm when many subagents should run the same kind of task over different inputs. The placeholder is exactly \`{{item}}\`. For example, with \`prompt_template\` set to \`Review {{item}} for likely regressions.\` and \`items\` set to \`[\\"src/a.ts\\", \\"src/b.ts\\"]\`, AgentSwarm launches two new subagents with those two concrete prompts. For a few differently-shaped tasks, make separate \`Agent\` calls in one message instead.\\n\\nUse \`resume_agent_ids\` to continue subagents that already exist from earlier work, such as ones that failed or timed out: map each agent id to the prompt for that resumed subagent (usually \`continue\` if no extra information is needed). You may combine \`resume_agent_ids\` with \`items\` in the same call to resume existing subagents and launch new ones. Do not duplicate resumed work in \`items\`.\\n\\nEach of these is enforced — a violation is rejected before any subagent starts: provide at least 2 \`items\` unless you pass \`resume_agent_ids\`; whenever \`items\` are present, \`prompt_template\` is required and must contain \`{{item}}\`; and the filled-in prompts must be distinct (two items that expand to the same prompt are rejected).\\n\\nUse enough subagents to keep the work focused and parallel. AgentSwarm supports up to 128 subagents, and launches are queued automatically, so it is safe to split large tasks into many clear, independent items.\\n\\nIf \`AgentSwarm\` is called, that call must be the only tool call in the response.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "description": { "type": "string", "minLength": 1, "description": "Short description for the whole swarm." }, "subagent_type": { "description": "Subagent type used for every new subagent spawned from items; defaults to coder when omitted. Resumed subagents always keep their original type, so passing subagent_type together with resume_agent_ids is allowed — it only affects the item-based spawns.", "type": "string", "minLength": 1 }, "prompt_template": { "description": "Prompt template for each subagent. The {{item}} placeholder is replaced with each item value.", "type": "string", "minLength": 1 }, "items": { "description": "Values used to fill {{item}}. Each item launches one new subagent.", "maxItems": 128, "type": "array", "items": { "type": "string", "minLength": 1 } }, "resume_agent_ids": { "description": "Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents.", "type": "object", "propertyNames": { "type": "string", "minLength": 1 }, "additionalProperties": { "type": "string", "minLength": 1 } } }, "required": [ "description" ], "additionalProperties": false } }, { "name": "AskUserQuestion", "description": "Use this tool when you need to ask the user questions with structured options during execution. This allows you to:\\n1. Collect user preferences or requirements before proceeding\\n2. Resolve ambiguous or underspecified instructions\\n3. Let the user decide between implementation approaches as you work\\n4. Present concrete options when multiple valid directions exist\\n\\n**When NOT to use:**\\n- When you can infer the answer from context — be decisive and proceed\\n- Trivial decisions that don't materially affect the outcome\\n\\nOverusing this tool interrupts the user's flow. Only use it when the user's input genuinely changes your next action.\\n\\n**Usage notes:**\\n- Users always have an \\"Other\\" option for custom input — don't create one yourself\\n- Use multi_select to allow multiple answers to be selected for a question\\n- Keep option labels concise (1-5 words), use descriptions for trade-offs and details\\n- Each question should have 2-4 meaningful, distinct options\\n- Question texts must be unique across the call, and option labels must be unique within each question\\n- You can ask 1-4 questions at a time; group related questions to minimize interruptions\\n- If you recommend a specific option, list it first and append \\"(Recommended)\\" to its label\\n- The result is JSON with an \`answers\` object keyed by question text; each value is the chosen option's label (comma-separated labels for multi_select, or the user's own words if they picked \\"Other\\"); if \`answers\` is empty and a \`note\` says the user dismissed it, they chose not to answer — do not treat this as selecting the recommended option; decide based on context and do not re-ask the same question\\n- Set background=true when you can keep working without the answer. This starts a background question task and returns a task_id immediately. The answer arrives automatically in a later turn — you do not need to poll, sleep, or check on it. Continue with other work; never fabricate or predict the answer.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "questions": { "minItems": 1, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "question": { "type": "string", "minLength": 1, "description": "A specific, actionable question. End with '?'." }, "header": { "default": "", "description": "Short category tag (max 12 chars, e.g. 'Auth', 'Style').", "type": "string" }, "options": { "minItems": 2, "maxItems": 4, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "description": "Concise display text (1-5 words). If recommended, append '(Recommended)'." }, "description": { "default": "", "description": "Brief explanation of trade-offs or implications.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false }, "description": "2-4 meaningful, distinct options. Do NOT include an 'Other' option — the system adds one automatically." }, "multi_select": { "default": false, "description": "Whether the user can select multiple options.", "type": "boolean" } }, "required": [ "question", "options" ], "additionalProperties": false }, "description": "The questions to ask the user (1-4 questions)." }, "background": { "default": false, "description": "Set true to ask in the background and return immediately with a background task_id; you are notified automatically when the user answers — do not poll with TaskOutput while the question is pending.", "type": "boolean" } }, "required": [ "questions" ], "additionalProperties": false } }, { "name": "Bash", "description": "Execute a \`bash\` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\\n\\n**Translate these to a dedicated tool instead:**\\n- \`cat\` / \`head\` / \`tail\` (known path) → \`Read\`\\n- \`sed\` / \`awk\` (in-place edit) → \`Edit\`\\n- \`echo > file\` / \`cat <<EOF\` → \`Write\`\\n- \`find\` / recursive \`ls\` to locate files by name pattern → \`Glob\` (plain \`ls <known-directory>\` is fine for listing a directory)\\n- \`grep\` / \`rg\` (search file contents) → \`Grep\`\\n- \`echo\` / \`printf\` (talk to the user) → just output text directly\\n\\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\\n\\n**Output:**\\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command exits non-zero, the output ends with a \`Command failed with exit code: N\` line; a command killed by its timeout or interrupted by the user ends with its own message instead.\\n\\nIf \`run_in_background=true\`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short \`description\`. Background commands default to a 600s timeout and \`timeout\` is capped at 86400s; set \`disable_timeout=true\` only when the task should run without a timeout. You will be automatically notified when the task completes. After starting one, default to returning control to the user instead of immediately waiting on it. Use \`TaskOutput\` only for a non-blocking status/output snapshot — do not set \`block=true\` to wait for a task you just launched, since its completion arrives automatically; reserve \`block=true\` for when the user explicitly asked you to wait. Use \`TaskStop\` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the \`/tasks\` command, which opens an interactive panel; it has no subcommands.\\n\\n**Guidelines for safety and security:**\\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls. To run a command in a particular directory, pass the \`cwd\` argument (or use absolute paths) rather than relying on a \`cd\` from an earlier call.\\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the \`timeout\` argument in seconds. Foreground commands default to 60s and allow up to 300s. When a foreground command hits its timeout it is moved to the background instead of being killed, and you will be automatically notified when it completes.\\n- Avoid using \`..\` to access files or directories outside of the working directory.\\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\\n\\n**Guidelines for efficiency:**\\n- Use \`&&\` to chain commands that genuinely depend on each other, e.g. \`npm install && npm test\`. Independent read-only commands (separate \`git show\`, \`ls\`, or status checks) should be issued as separate parallel Bash calls in one response, not chained into a single call — chaining serializes their execution and mixes their output. Do not stitch outputs together with \`echo\` separators.\\n- Use \`;\` to run commands sequentially regardless of success/failure\\n- Use \`||\` for conditional execution (run second command only if first fails)\\n- Use pipe operations (\`|\`) and redirections (\`>\`, \`>>\`) to chain input and output between commands\\n- Always quote file paths containing spaces with double quotes (e.g., cd \\"/path with spaces/\\")\\n- Compose multi-step logic in a single call with \`if\` / \`case\` / \`for\` / \`while\` control flows.\\n- Prefer \`run_in_background=true\` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\\n\\n**Commands available:**\\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run \`which <command>\` first to confirm a command exists before relying on it.\\n- Navigation and inspection: \`ls\`, \`pwd\`, \`cd\`, \`stat\`, \`file\`, \`du\`, \`df\`, \`tree\`\\n- File and directory management: \`cp\`, \`mv\`, \`rm\`, \`mkdir\`, \`touch\`, \`ln\`, \`chmod\`, \`chown\`\\n- Text and data processing: \`wc\`, \`sort\`, \`uniq\`, \`cut\`, \`tr\`, \`diff\`, \`xargs\`\\n- Archives and compression: \`tar\`, \`gzip\`, \`gunzip\`, \`zip\`, \`unzip\`\\n- Networking and transfer: \`curl\`, \`wget\`, \`ping\`, \`ssh\`, \`scp\`\\n- Version control: \`git\`; for GitHub-hosted work (PRs, issues, CI runs, API queries) prefer the \`gh\` CLI when installed — it carries the user's GitHub auth and can return structured JSON\\n- Process and system: \`ps\`, \`kill\`, \`top\`, \`env\`, \`date\`, \`uname\`, \`whoami\`\\n- Language and package toolchains: \`node\`, \`npm\`, \`pnpm\`, \`yarn\`, \`python\`, \`pip\` (use whichever the project actually relies on)\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "command": { "type": "string", "minLength": 1, "description": "The command to execute." }, "cwd": { "description": "The working directory in which to run the command. When omitted, the command runs in the session's working directory.", "type": "string" }, "timeout": { "default": 60, "description": "Optional timeout in seconds for the command to execute. Foreground default 60s, max 300s. Background default 600s, max 86400s. Ignored for background commands when disable_timeout=true.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 }, "description": { "description": "A short description for the background task. Required when run_in_background is true.", "type": "string" }, "run_in_background": { "description": "Whether to run the command as a background task.", "type": "boolean" }, "disable_timeout": { "description": "If true, do not apply a timeout to the command. Only applies when run_in_background is true.", "type": "boolean" } }, "required": [ "command" ], "additionalProperties": false } }, { "name": "CreateGoal", "description": "Create a durable, structured goal that the runtime will pursue across multiple turns.\\n\\nCall \`CreateGoal\` only when:\\n\\n- the user explicitly asks you to start a goal or work autonomously toward an outcome, or\\n- a host goal-intake prompt asks you to create one.\\n\\nDo NOT create a goal for greetings, ordinary questions, or vague requests that lack a\\nverifiable completion condition. A goal needs a checkable end state.\\n\\nWhen the request is vague, ask the user for the missing completion criterion before creating\\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\\nrespect that and create the goal.\\n\\nInclude a \`completionCriterion\` when the user provides one, or when it can be stated without\\ninventing new requirements. Keep \`objective\` concise; reference long task descriptions by file\\npath rather than pasting them.\\n\\nCreating a goal fails if one already exists, so use \`replace: true\` only when the user explicitly\\nwants to abandon the current goal and start a new one.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "objective": { "type": "string", "minLength": 1, "description": "The objective to pursue. Must have a verifiable end state." }, "completionCriterion": { "description": "How to verify the goal is complete. Include when the user provides one.", "type": "string" }, "replace": { "description": "Replace an existing active, paused, or blocked goal instead of failing.", "type": "boolean" } }, "required": [ "objective" ], "additionalProperties": false } }, { "name": "Edit", "description": "Perform exact replacements in existing files.\\n\\n- Edit is mandatory for every incremental change, especially small edits. DO NOT use Write or Bash \`sed\`.\\n- Read the target file before every Edit. DO NOT call Edit from memory, stale context, or a guessed \`old_string\`.\\n- Take \`old_string\` and \`new_string\` from the Read output view.\\n- Drop the line-number prefix and tab; match only file content.\\n- \`old_string\` must be unique unless \`replace_all\` is set.\\n- If \`old_string\` is ambiguous, add surrounding context. Use \`replace_all\` only when every occurrence should change — for example, renaming a symbol throughout the file.\\n- Multiple Edit calls may run in one response only when they do not target the same file.\\n- DO NOT issue consecutive Edit calls on the same file. A previous Edit can invalidate a later Edit's \`old_string\`, causing \`old_string not found\`. Read the file again before the next Edit.\\n- A write lock serializes same-file edits in response order, but serialization does not make stale \`old_string\` valid.\\n- For pure CRLF files, Read shows LF; use LF in \`old_string\` and \`new_string\`, and Edit writes CRLF back.\\n- For mixed endings or lone carriage returns, Read shows carriage returns as \\\\r; include actual \\\\r escapes in those positions.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the text file to edit. Relative paths resolve against the working directory; a path outside the working directory must be absolute." }, "old_string": { "type": "string", "minLength": 1, "description": "Exact content to replace from the Read output view, without the line-number prefix. Use LF for pure CRLF files; use actual \\\\r escapes where Read shows \\\\r." }, "new_string": { "type": "string", "description": "Replacement text in the same Read output view. LF is written back as CRLF only for pure CRLF files." }, "replace_all": { "description": "Set true only when every occurrence of old_string should be replaced.", "type": "boolean" } }, "required": [ "path", "old_string", "new_string" ], "additionalProperties": false } }, { "name": "EnterPlanMode", "description": "Use this tool proactively when you're about to start a non-trivial implementation task.\\nGetting user sign-off on your approach via ExitPlanMode before writing code prevents wasted effort.\\n\\nUse it when ANY of these conditions apply:\\n\\n1. New Feature Implementation - e.g. \\"Add a caching layer to the API\\"\\n2. Multiple Valid Approaches - e.g. \\"Optimize database queries\\" (indexing vs rewrite vs caching)\\n3. Code Modifications - e.g. \\"Refactor auth module to support OAuth\\"\\n4. Architectural Decisions - e.g. \\"Add WebSocket support\\"\\n5. Multi-File Changes - involves more than 2-3 files\\n6. Unclear Requirements - need exploration to understand scope\\n7. User Preferences Matter - if user input would materially change the implementation approach, use EnterPlanMode to structure the decision\\n\\nPermission mode notes:\\n- EnterPlanMode enters plan mode automatically without an approval prompt in all permission modes.\\n- In yolo and manual modes, ExitPlanMode still presents the plan to the user for approval.\\n- In auto permission mode, do not use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, ExitPlanMode exits plan mode without asking the user.\\n- Use EnterPlanMode only when planning itself adds value.\\n\\nWhen NOT to use:\\n- Single-line or few-line fixes (typos, obvious bugs, small tweaks)\\n- User gave very specific, detailed instructions\\n- Pure research/exploration tasks\\n\\nOnce you are in plan mode, a reminder walks you through the workflow (explore → design → write the plan file → \`ExitPlanMode\`) and enforces read-only access. For non-trivial tasks where you are unsure of the codebase structure or relevant code paths, use \`Agent(subagent_type=\\"explore\\")\` to investigate first when the \`Agent\` tool is available.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "ExitPlanMode", "description": "Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.\\n\\n## How This Tool Works\\n- You should have already written your plan to the plan file specified in the plan mode reminder.\\n- This tool does NOT take the plan content as a parameter - it reads the plan from the file you wrote.\\n- The user will see the contents of your plan file when they review it. In auto permission mode, the tool reads the file and exits plan mode without asking the user.\\n\\n## When to Use\\nOnly use this tool for tasks that require planning implementation steps. For research tasks (searching files, reading code, understanding the codebase), do NOT use this tool.\\n\\n## What a good plan contains\\nList specific, verifiable steps grounded in the actual codebase — real files, functions, and commands, in a sensible order. Each step should be concrete enough to act on and to check. Avoid vague filler like \\"improve performance\\" or \\"add tests\\"; say what to change and where.\\n\\n## Multiple Approaches\\nIf your plan offers multiple alternative approaches, pass them via the \`options\` parameter so the user can choose which one to execute — see the \`options\` parameter for the format, count, and reserved labels. In yolo and manual modes the user sees all options alongside the host's Reject and Revise controls.\\n\\n## Before Using\\n- In auto permission mode, do NOT use AskUserQuestion; make the best decision from available context.\\n- In auto permission mode, this tool exits plan mode without asking the user.\\n- In yolo and manual modes, this tool still presents the plan to the user for approval.\\n- If auto permission mode is not active and you have unresolved questions, use AskUserQuestion first.\\n- If auto permission mode is not active and you have multiple approaches and haven't narrowed down yet, consider using AskUserQuestion first to let the user choose, then write a plan for the chosen approach only.\\n- Once your plan is finalized, use THIS tool to request approval.\\n- Do NOT use AskUserQuestion to ask \\"Is this plan OK?\\" or \\"Should I proceed?\\" - that is exactly what ExitPlanMode does.\\n- If rejected, revise based on feedback and call ExitPlanMode again.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "options": { "description": "When the plan contains multiple alternative approaches, list them here so the user can choose which one to execute. Provide up to 3 options; 2-3 distinct approaches work best when the plan offers a real choice. Passing a single option is allowed and is equivalent to a plain plan approval. Each option represents a distinct approach from the plan. Do not use \\"Reject\\", \\"Revise\\", \\"Approve\\", or \\"Reject and Exit\\" as labels.", "minItems": 1, "maxItems": 3, "type": "array", "items": { "type": "object", "properties": { "label": { "type": "string", "minLength": 1, "maxLength": 80, "description": "Short name for this option (1-8 words). Append \\"(Recommended)\\" if you recommend this option." }, "description": { "default": "", "description": "Brief summary of this approach and its trade-offs.", "type": "string" } }, "required": [ "label" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "FetchURL", "description": "Fetch content from a URL. The content is returned either as the main text extracted from the page, or as the full response body verbatim; a note at the top of the result states which of the two you received, so you can judge how complete it is. Use this when you need to read a specific web page.\\n\\nOnly fully-formed public \`http\`/\`https\` URLs are supported; other schemes and private or loopback addresses are not fetched. Very large pages may be truncated or refused. The fetch carries no login or session for the target site, so pages behind authentication (private repositories, internal dashboards) return a login page or an error instead of the real content — if the text you get back looks like a generic landing or sign-in page, treat that as the login wall, not the answer, and reach the content through a credentialed route (an authenticated CLI or MCP tool) instead.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "url": { "type": "string", "description": "The URL to fetch content from." } }, "required": [ "url" ], "additionalProperties": false } }, { "name": "GetGoal", "description": "Read the current goal: its objective, completion criterion, status, and budgets (turns, tokens,\\ntime, and how much of each remains). When the goal has stopped, it also reports the terminal reason.\\n\\nUse \`GetGoal\` before deciding whether to continue working, report completion, report a blocker,\\nor respect a pause. It returns \`{ \\"goal\\": null }\` when there is no current goal.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": {}, "additionalProperties": false } }, { "name": "Glob", "description": "Find files by glob pattern, sorted by modification time (most recent first).\\n\\nPowered by ripgrep. Respects \`.gitignore\`, \`.ignore\`, and \`.rgignore\` by default — set \`include_ignored\` to also match ignored files (e.g. build outputs, \`node_modules\`). Sensitive files (such as \`.env\`) are always filtered out. Matches are files only — directories themselves are never listed; to find a directory, glob for a file inside it (e.g. \`**/fixtures/**\`).\\n\\nGood patterns:\\n- \`*.ts\` — all files matching an extension, at any depth below the search root (a bare pattern without \`/\` matches recursively)\\n- \`src/*.ts\` — files directly inside \`src/\` (one level, not recursive)\\n- \`src/**/*.ts\` — recursive walk with a subdirectory anchor and extension\\n- \`**/*.py\` — recursive walk from the search root for an extension\\n- \`*.{ts,tsx}\` — brace expansion is supported\\n- \`{src,test}/**/*.ts\` — cartesian brace expansion is supported too\\n\\nResults are capped at the first 100 matching paths. If a search would return more, a truncation marker is appended. Refine the pattern (extension, subdirectory) when 100 is not enough, or call again with a narrower anchor.\\n\\nLarge-directory caveat — avoid recursing into dependency / build output even with an anchor, especially when \`include_ignored\` is set:\\n- \`node_modules/**/*.js\`, \`.venv/**/*.py\`, \`__pycache__/**\`, \`target/**\` can produce thousands of results that truncate at the match cap and waste context. Prefer specific subpaths like \`node_modules/react/src/**/*.js\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Glob pattern to match files." }, "path": { "description": "Directory to search. Accepts an absolute path, or a path relative to the current working directory. Defaults to the current working directory.", "type": "string" }, "include_ignored": { "description": "Also match files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" }, "include_dirs": { "description": "Deprecated and ignored. Results are always files-only — directories are never listed. Accepted only so older calls that still pass this flag are not rejected by parameter validation.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Grep", "description": "Search file contents using regular expressions (powered by ripgrep).\\n\\nUse Grep when the task is to find unknown content or unknown file locations. Do not use shell \`grep\` or \`rg\` directly; this tool applies workspace path policy, output limits, and sensitive-file filtering.\\nALWAYS use Grep tool instead of running \`grep\` or \`rg\` from a shell — direct shell calls bypass workspace policy, output limits, and sensitive-file filtering.\\nIf you already know a concrete file path and need to inspect its contents, use Read directly instead.\\n\\nWrite patterns in ripgrep regex syntax, which differs from POSIX \`grep\` syntax. For example, braces are special, so escape them as \`\\\\{\` to match a literal \`{\`.\\n\\nHidden files (dotfiles such as \`.gitlab-ci.yml\` or \`.eslintrc.json\`) are searched by default. To also search files excluded by \`.gitignore\` (such as \`node_modules\` or build outputs), set \`include_ignored\` to \`true\`. Sensitive files (such as \`.env\`) are always skipped for safety, even when \`include_ignored\` is \`true\`.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "pattern": { "type": "string", "description": "Regular expression to search for." }, "path": { "description": "File or directory to search. Accepts an absolute path, or a path relative to the current working directory. Omit to search the current working directory. Use Read instead when you already know a concrete file path and need its contents.", "type": "string" }, "glob": { "description": "Optional glob filter for which files to search, e.g. \`*.ts\`. Matched against each file's full absolute path, so a path-anchored pattern like \`src/**/*.ts\` silently matches nothing — use a basename pattern (\`*.ts\`), or anchor with \`**/\` (\`**/src/**/*.ts\`). To scope the search to a directory, use \`path\` instead.", "type": "string" }, "type": { "description": "Optional ripgrep file type filter, such as ts or py. Prefer this over \`glob\` when filtering by language or file kind: it is more efficient and less error-prone than an equivalent glob pattern.", "type": "string" }, "output_mode": { "description": "Shape of the result. \`content\` shows matching lines (honors \`-A\`, \`-B\`, \`-C\`, \`-n\`, and \`head_limit\`); \`files_with_matches\` shows only the paths of files that contain a match, most-recently-modified first (honors \`head_limit\`); \`count_matches\` shows per-file match counts as \`path:count\` lines, preceded by an aggregate total line. Defaults to \`files_with_matches\`.", "type": "string", "enum": [ "content", "files_with_matches", "count_matches" ] }, "-i": { "description": "Perform a case-insensitive search. Defaults to false.", "type": "boolean" }, "-n": { "description": "Prefix each matching line with its line number. Applies only when \`output_mode\` is \`content\`. Defaults to true.", "type": "boolean" }, "-A": { "description": "Number of lines to show after each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-B": { "description": "Number of lines to show before each match. Applies only when \`output_mode\` is \`content\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "-C": { "description": "Number of lines to show before and after each match. Applies only when \`output_mode\` is \`content\`; takes precedence over \`-A\` and \`-B\`.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "head_limit": { "description": "Limit output to the first N lines/entries after offset. Defaults to 250. Pass 0 for unlimited.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "offset": { "description": "Number of leading lines/entries to skip before applying \`head_limit\`. Use it together with \`head_limit\` to page through large result sets. Defaults to 0.", "type": "integer", "minimum": 0, "maximum": 9007199254740991 }, "multiline": { "description": "Enable multiline matching, where the pattern can span line boundaries and \`.\` also matches newlines. Defaults to false.", "type": "boolean" }, "include_ignored": { "description": "Also search files excluded by ignore files such as \`.gitignore\`, \`.ignore\`, and \`.rgignore\` (for example \`node_modules\` or build outputs). Sensitive files (such as \`.env\`) remain filtered out for safety. VCS metadata directories (\`.git\` and similar) are always skipped, even when this is true. Defaults to false.", "type": "boolean" } }, "required": [ "pattern" ], "additionalProperties": false } }, { "name": "Read", "description": "Read a text file from the local filesystem.\\n\\nIf the user provides a concrete file path to a text file, call Read directly. Do not \`Glob\`, \`ls\`, or otherwise pre-check known text file paths; missing or invalid file paths return errors you can handle. Do not use Read for directories; use \`ls\` via Bash for a known directory, or Glob when you need files matching a name pattern (Glob lists files only, never directories). Use \`Grep\` only when the task is to search for unknown content or locations.\\n\\nWhen you need several files, prefer to read them in parallel: emit multiple \`Read\` calls in a single response instead of reading one file per turn.\\n\\n- Relative paths resolve against the working directory; a path outside the working directory must be absolute.\\n- Returns up to 1000 lines or 100 KB per call, whichever comes first; lines longer than 2000 chars are truncated mid-line.\\n- Page larger files with \`line_offset\` (1-based start line) and \`n_lines\`. Omit \`n_lines\` to read up to the 1000-line cap.\\n- Sensitive files (\`.env\` files, credential stores, SSH private keys, and similar secrets) are refused to protect secrets; do not attempt to read them. Templates and public keys are exempt: \`.env.example\` / \`.env.sample\` / \`.env.template\` and public SSH keys such as \`id_rsa.pub\` read normally.\\n- Only UTF-8 text files can be read. Non-UTF-8 encodings, binary files, and files containing NUL bytes are refused; use \`ReadMediaFile\` for images or video, and Bash or an MCP tool for other binary formats.\\n- Negative line_offset reads from the end of the file (for example, -100 reads the last 100 lines); the absolute value cannot exceed 1000.\\n- Output format: \`<line-number>\\\\t<content>\` per line.\\n- A \`<system>...</system>\` status block is appended after the file content; it summarizes how much was read (line and byte counts, truncation, line-ending notes) and is not part of the file itself.\\n- Pure CRLF files are displayed with LF line endings; \`Edit\` matches this output and preserves CRLF when writing back.\\n- Mixed or lone carriage-return line endings are shown as \`\\\\r\` and require exact \`Edit.old_string\` escapes.\\n- After a successful \`Edit\`/\`Write\`, do not re-read solely to prove the write landed. When the task depends on an exact file, API, or output shape, inspect the final external contract before finishing.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to a text file. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Directories are not supported; use \`ls\` via Bash for a known directory, or Glob for pattern search." }, "line_offset": { "description": "The line number to start reading from. Omit to start at line 1. Negative values read from the end of the file; the absolute value cannot exceed 1000.", "anyOf": [ { "type": "integer", "minimum": 1, "maximum": 9007199254740991 }, { "type": "integer", "minimum": -1000, "maximum": -1 } ] }, "n_lines": { "description": "The number of lines to read; the tool also applies its internal cap. Omit to read up to the internal cap of 1000 lines.", "type": "integer", "exclusiveMinimum": 0, "maximum": 9007199254740991 } }, "required": [ "path" ], "additionalProperties": false } }, { "name": "SetGoalBudget", "description": "Set a hard budget limit for the current goal.\\n\\nUse this only when the user clearly gives a runtime limit, such as:\\n\\n- \\"stop after 20 turns\\"\\n- \\"use no more than 500k tokens\\"\\n- \\"finish within 30 minutes\\"\\n\\nDo not invent limits. Do not call this for vague wording such as \\"spend some time\\" or\\n\\"try to be quick\\".\\n\\nIf the user gives a compound time, convert it to one supported unit before calling this tool.\\nFor example, \\"2 hours and 3 minutes\\" can be set as \`value: 123, unit: \\"minutes\\"\`.\\n\\nA time budget must be between 1 second and 24 hours — the tool rejects anything shorter or\\nlonger, telling the user it is not a reasonable goal budget. Turn and token budgets are not\\nbounded this way; they must be positive and are rounded to the nearest whole number (minimum 1).\\n\\nSupported units:\\n\\n- \`turns\`\\n- \`tokens\`\\n- \`milliseconds\`\\n- \`seconds\`\\n- \`minutes\`\\n- \`hours\`\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "value": { "type": "number", "exclusiveMinimum": 0, "description": "The positive numeric budget value." }, "unit": { "type": "string", "enum": [ "turns", "tokens", "milliseconds", "seconds", "minutes", "hours" ] } }, "required": [ "value", "unit" ], "additionalProperties": false } }, { "name": "Skill", "description": "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a \`<kimi-skill-loaded>\` block for it with the same \`args\` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier \`args\` and will not reflect new inputs.", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "skill": { "type": "string", "description": "The exact name of the skill to invoke, spelled as it appears in the current skill listing (e.g. \\"commit\\", \\"pdf\\")." }, "args": { "description": "Optional argument string for the skill, written like a command line (e.g. \`-m \\"fix bug\\"\`, \`123\`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing \`ARGUMENTS:\` line. Omit it only when there is nothing to pass.", "type": "string" } }, "required": [ "skill" ], "additionalProperties": false } }, { "name": "TaskList", "description": "List background tasks and their current status.\\n\\nUse this tool to discover which background tasks exist and where each one\\nstands. It is the entry point for inspecting background work: it returns a\\ntask ID, status, and description for every task it reports, plus the command,\\nPID, and (once finished) exit code for shell tasks, and a stop reason for any\\ntask that ended early.\\n\\nGuidelines:\\n\\n- After a context compaction, or whenever you are unsure which background\\n  tasks are running or what their task IDs are, call this tool to\\n  re-enumerate them instead of guessing a task ID.\\n- Prefer the default \`active_only=true\`, which lists only non-terminal tasks.\\n  Pass \`active_only=false\` only when you specifically need to see tasks that\\n  have already finished. With \`active_only=false\` the result may also include\\n  \`lost\` tasks — tasks left over from a previous process that can no longer be\\n  inspected or controlled; treat them as already terminated.\\n- \`limit\` caps how many tasks are returned. It accepts a value between 1 and\\n  100 and defaults to 20 when omitted.\\n- This tool only lists tasks; it does not return their output. Use it first\\n  to locate the task ID you need, then call \`TaskOutput\` with that ID to read\\n  the task's output and details.\\n- This tool is read-only and does not change any state, so it is always safe\\n  to call, including in plan mode.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "active_only": { "default": true, "description": "Whether to list only non-terminal background tasks.", "type": "boolean" }, "limit": { "default": 20, "description": "Maximum number of tasks to return.", "type": "integer", "minimum": 1, "maximum": 100 } }, "additionalProperties": false } }, { "name": "TaskOutput", "description": "Retrieve a snapshot of a running or completed background task.\\n\\nUse this after \`Bash(run_in_background=true)\` or \`Agent(run_in_background=true)\` to check progress, or to read the output of a task that has already completed.\\n\\nGuidelines:\\n- Prefer relying on automatic completion notifications. Use this tool only when you need task output before the automatic notification arrives.\\n- By default this tool is non-blocking and returns a current status/output snapshot — that is the normal way to use it.\\n- Do not use TaskOutput to wait for a result you need before continuing — if your next step depends on the task's result, run that task in the foreground instead. TaskOutput is for a deliberate progress check you will act on without blocking, not a way to sit and wait for a background task you just launched.\\n- Use block=true only when the user explicitly asked you to wait for the task. Never block on a task you launched in the current turn — if you need its result right away, it should have been a foreground call.\\n- If a block=true call returns \`retrieval_status: timeout\` (the task is still running), do not block on the same task again. Continue with other work or hand back to the user — the completion notification arrives on its own.\\n- This tool returns structured task metadata, a fixed-size output preview, and an output_path for the full log.\\n- For a terminal task, the metadata also explains why it ended. A shell command that runs to completion reports \`status: completed\` on a zero exit, or \`status: failed\` with its non-zero \`exit_code\` — judge that failure from the \`exit_code\`, because a plain command failure carries no \`stop_reason\` and no \`terminal_reason\`. \`terminal_reason\` is a categorical label emitted only when the end is not an ordinary exit: \`timed_out\` when the deadline aborted it, \`stopped\` when it was explicitly stopped, or \`failed\` when it errored without producing an exit code; the \`stopped\` and \`failed\` cases also carry a human-readable \`stop_reason\`. A task that finished on its own with a clean exit carries neither \`stop_reason\` nor \`terminal_reason\`.\\n- The full, never-truncated log is always available at output_path; use the \`Read\` tool with that path to page through it, whether or not the preview was truncated.\\n- This tool works with the generic background task system and should remain the primary read path for future task types, not just bash.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to inspect." }, "block": { "default": false, "description": "Whether to wait for the task to finish before returning. Discouraged — background tasks notify automatically on completion; use only when the user explicitly asked you to wait.", "type": "boolean" }, "timeout": { "default": 30, "description": "Maximum number of seconds to wait when block=true.", "type": "integer", "minimum": 0, "maximum": 3600 } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TaskStop", "description": "Stop a running background task.\\n\\nOnly use this when a task must genuinely be cancelled — for a task that is\\nfinishing normally, wait for its completion notification or inspect it with\\n\`TaskOutput\` instead of stopping it.\\n\\nGuidelines:\\n- This is a general-purpose stop capability for any background task. It is not\\n  a bash-specific kill.\\n- Stopping a task is destructive: it may leave partial side effects behind.\\n  Use it with care.\\n- If the task has already finished, this tool simply returns its current\\n  status.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "task_id": { "type": "string", "description": "The background task ID to stop." }, "reason": { "default": "Stopped by TaskStop", "description": "Short reason recorded when the task is stopped.", "type": "string" } }, "required": [ "task_id" ], "additionalProperties": false } }, { "name": "TodoList", "description": "Use this tool to maintain a structured TODO list as you work through a multi-step task. Use it proactively and often when progress tracking helps the current work. This is especially useful in long-running investigations and implementation tasks with several tool calls; in plan mode, write the plan to the plan file rather than tracking it here.\\n\\n**When to use:**\\n- Multi-step tasks that span several tool calls\\n- Tracking investigation progress across a large codebase search\\n- Planning a sequence of edits before making them\\n- After receiving new multi-step instructions, capture the requirements as todos\\n- Before starting a tracked task, mark exactly one item as \`in_progress\`\\n- Immediately after finishing a tracked task, mark it \`done\`; do not batch completions at the end\\n\\n**When NOT to use:**\\n- Single-shot answers that complete in one or two tool calls\\n- Trivial requests where tracking adds no clarity\\n- Purely conversational or informational replies\\n\\n**Avoid churn:**\\n- Do not re-call this tool when nothing meaningful has changed since the last call — update the list only after real progress.\\n- When unsure of the current state, call query mode first (omit \`todos\`) to check the list before deciding what to update.\\n- If no available tool can move any task forward, tell the user where you are stuck instead of repeatedly re-ordering the same todos.\\n\\n**How to use:**\\n- Call with \`todos: [...]\` to replace the full list. Statuses: pending / in_progress / done.\\n- Call with no \`todos\` argument to retrieve the current list without changing it.\\n- Call with \`todos: []\` to clear the list.\\n- Keep titles short and actionable (e.g. \\"Read session-control.ts\\", \\"Add planMode flag to TurnManager\\").\\n- Update statuses as you make progress.\\n- When work is underway, keep exactly one task \`in_progress\`.\\n- Only mark a task \`done\` when it is fully accomplished.\\n- Never mark a task \`done\` if tests are failing, implementation is partial, unresolved errors remain, or required files/dependencies could not be found.\\n- If you encounter a blocker, keep the blocked task \`in_progress\` or add a new pending task describing what must be resolved.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "todos": { "description": "The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.", "type": "array", "items": { "type": "object", "properties": { "title": { "type": "string", "minLength": 1, "description": "Short, actionable title for the todo." }, "status": { "type": "string", "enum": [ "pending", "in_progress", "done" ], "description": "Current status of the todo." } }, "required": [ "title", "status" ], "additionalProperties": false } } }, "additionalProperties": false } }, { "name": "UpdateGoal", "description": "Set the status of the current goal. This is how you resume, complete, or block an autonomous goal.\\n\\n- \`active\` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\\n- \`complete\` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded. Before using this, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not use \`complete\` merely because a budget is nearly exhausted or you want to stop.\\n- \`blocked\` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. For non-terminal blockers, do not use \`blocked\` the first time you hit the blocker. The same blocking condition must repeat for at least 3 consecutive goal turns before you call \`blocked\`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. If the objective itself is impossible, unsafe, or contradictory, call \`blocked\` in the same turn instead of running more goal turns. Do not use \`blocked\` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call \`blocked\` instead of leaving the goal active.\\n\\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call \`complete\` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not call \`complete\` after only producing a plan, summary, first pass, or partial result. Call \`blocked\` only after the blocked audit threshold is met. If you call \`blocked\`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "status": { "type": "string", "enum": [ "active", "complete", "blocked" ], "description": "The lifecycle status to set for the current goal. Use \`blocked\` for impossible, unsafe, or contradictory objectives, or after the same non-terminal blocking condition repeats for at least 3 consecutive goal turns." } }, "required": [ "status" ], "additionalProperties": false } }, { "name": "Write", "description": "Create, append to, or replace a file entirely.\\n\\n- Missing parent directories are created automatically (like \`mkdir(parents=True, exist_ok=True)\`).\\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\\n- Do not create unsolicited documentation files (\`*.md\` write-ups, \`README\`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\\n- Read before overwriting an existing file.\\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\\n- Write outputs content literally, including supplied line endings: \\\\n stays LF, \\\\r\\\\n stays CRLF.\\n- For new content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\\n", "parameters": { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "path": { "type": "string", "description": "Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically." }, "content": { "type": "string", "description": "Raw full file content to write exactly as provided. This does not use the Read/Edit text view." }, "mode": { "description": "Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline.", "type": "string", "enum": [ "overwrite", "append" ] } }, "required": [ "path", "content" ], "additionalProperties": false } } ], "time": "<time>" }
+        [wire] llm.request                  { "kind": "loop", "provider": "kimi", "model": "mock-model", "modelAlias": "mock-model", "thinkingEffort": "off", "maxTokens": 999811, "toolSelect": false, "systemPromptHash": "ec9c34379c88babbc468ef2f3e0e08cd2f422c8c4a910664fb8bb394d703a575", "toolsHash": "b0e35cedccd898afc718a76e65bcb9fb84b7657958a03a95d49f40a40b99a81f", "messageCount": 6, "turnStep": "1.1", "time": "<time>" }
         [emit] assistant.delta              { "turnId": 1, "delta": "No lookup tool is available." }
+        [emit] agent.activity.updated       { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "streaming", "stream": "assistant", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
         [wire] usage.record                 { "model": "mock-model", "usage": { "inputOther": 186, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
         [emit] agent.status.updated         { "usage": { "byModel": { "mock-model": { "inputOther": 492, "output": 44, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 492, "output": 44, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 186, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
         [emit] agent.status.updated         { "contextTokens": 197, "rawContextTokens": 200 }
-        [wire] context.append_loop_event    { "event": { "type": "content.part", "uuid": "<uuid-7>", "turnId": "1", "step": 1, "stepUuid": "<uuid-6>", "part": { "type": "text", "text": "No lookup tool is available." } }, "time": "<time>" }
-        [emit] agent.status.updated         { "contextTokens": 197, "rawContextTokens": 208 }
-        [wire] context.append_loop_event    { "event": { "type": "step.end", "uuid": "<uuid-6>", "turnId": "1", "step": 1, "finishReason": "end_turn", "usage": { "inputOther": 186, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-3", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
-        [emit] agent.status.updated         { "contextTokens": 197, "rawContextTokens": 197 }
         [emit] turn.step.completed          { "turnId": 1, "step": 1, "stepId": "<uuid-6>", "usage": { "inputOther": 186, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn", "providerFinishReason": "completed", "rawFinishReason": "stop" }
+        [emit] agent.activity.updated       { "lifecycle": "ready", "turn": { "turnId": 1, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
+        [wire] context.append_loop_event    { "event": { "type": "content.part", "uuid": "<uuid-7>", "turnId": "1", "step": 1, "stepUuid": "<uuid-6>", "part": { "type": "text", "text": "No lookup tool is available." } }, "time": "<time>" }
+        [wire] context.append_loop_event    { "event": { "type": "step.end", "uuid": "<uuid-6>", "turnId": "1", "step": 1, "finishReason": "end_turn", "usage": { "inputOther": 186, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-3", "providerFinishReason": "completed", "rawFinishReason": "stop" }, "time": "<time>" }
         [emit] turn.ended                   { "turnId": 1, "reason": "completed" }
       `);
       expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
diff --git a/packages/agent-core-v2/test/tools/fixtures/fake-exec.ts b/packages/agent-core-v2/test/tools/fixtures/fake-exec.ts
index 6a85e62f8..f8c952f05 100644
--- a/packages/agent-core-v2/test/tools/fixtures/fake-exec.ts
+++ b/packages/agent-core-v2/test/tools/fixtures/fake-exec.ts
@@ -29,6 +29,7 @@ export function createFakeHostFs(overrides: Partial<IHostFileSystem> = {}): IHos
     readdir: () => notImplemented('FakeHostFs.readdir'),
     mkdir: () => notImplemented('FakeHostFs.mkdir'),
     remove: () => notImplemented('FakeHostFs.remove'),
+    realpath: () => notImplemented('FakeHostFs.realpath'),
   };
   return { ...fs, ...overrides };
 }
diff --git a/packages/agent-core-v2/test/agent/wireRecord/migration/migration.test.ts b/packages/agent-core-v2/test/wire/migration/migration.test.ts
similarity index 93%
rename from packages/agent-core-v2/test/agent/wireRecord/migration/migration.test.ts
rename to packages/agent-core-v2/test/wire/migration/migration.test.ts
index a3f48d399..07e965d04 100644
--- a/packages/agent-core-v2/test/agent/wireRecord/migration/migration.test.ts
+++ b/packages/agent-core-v2/test/wire/migration/migration.test.ts
@@ -3,7 +3,7 @@ import { describe, expect, it } from 'vitest';
 import {
   migrateWireRecord,
   type WireMigration,
-} from '#/agent/wireRecord/migration/migration';
+} from '#/wire/migration/migration';
 
 describe('wire record migrations', () => {
   it('applies migrations in order', () => {
diff --git a/packages/agent-core-v2/test/agent/wireRecord/migration/utils.ts b/packages/agent-core-v2/test/wire/migration/utils.ts
similarity index 93%
rename from packages/agent-core-v2/test/agent/wireRecord/migration/utils.ts
rename to packages/agent-core-v2/test/wire/migration/utils.ts
index 503235c3e..e65f996ff 100644
--- a/packages/agent-core-v2/test/agent/wireRecord/migration/utils.ts
+++ b/packages/agent-core-v2/test/wire/migration/utils.ts
@@ -1,8 +1,8 @@
 import {
   type WireMigration,
   type WireMigrationRecord,
-} from '#/agent/wireRecord/migration/migration';
-import { eventSnapshot } from '../../../harness/snapshots';
+} from '#/wire/migration/migration';
+import { eventSnapshot } from '../../harness/snapshots';
 
 export function runMigration(
   migration: WireMigration,
diff --git a/packages/agent-core-v2/test/agent/wireRecord/migration/v1.1.test.ts b/packages/agent-core-v2/test/wire/migration/v1.1.test.ts
similarity index 97%
rename from packages/agent-core-v2/test/agent/wireRecord/migration/v1.1.test.ts
rename to packages/agent-core-v2/test/wire/migration/v1.1.test.ts
index 77ad4e5ca..c48a5677b 100644
--- a/packages/agent-core-v2/test/agent/wireRecord/migration/v1.1.test.ts
+++ b/packages/agent-core-v2/test/wire/migration/v1.1.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { migrateV1_0ToV1_1 } from '#/agent/wireRecord/migration/migration';
+import { migrateV1_0ToV1_1 } from '#/wire/migration/migration';
 import { runMigration } from './utils';
 
 describe('1.0 to 1.1', () => {
diff --git a/packages/agent-core-v2/test/agent/wireRecord/migration/v1.2.test.ts b/packages/agent-core-v2/test/wire/migration/v1.2.test.ts
similarity index 98%
rename from packages/agent-core-v2/test/agent/wireRecord/migration/v1.2.test.ts
rename to packages/agent-core-v2/test/wire/migration/v1.2.test.ts
index 5157ac41d..e46a82603 100644
--- a/packages/agent-core-v2/test/agent/wireRecord/migration/v1.2.test.ts
+++ b/packages/agent-core-v2/test/wire/migration/v1.2.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { migrateV1_1ToV1_2 } from '#/agent/wireRecord/migration/migration';
+import { migrateV1_1ToV1_2 } from '#/wire/migration/migration';
 import { runMigration } from './utils';
 
 describe('1.1 to 1.2', () => {
diff --git a/packages/agent-core-v2/test/agent/wireRecord/migration/v1.4.test.ts b/packages/agent-core-v2/test/wire/migration/v1.4.test.ts
similarity index 92%
rename from packages/agent-core-v2/test/agent/wireRecord/migration/v1.4.test.ts
rename to packages/agent-core-v2/test/wire/migration/v1.4.test.ts
index b815e77a0..4dc3ee635 100644
--- a/packages/agent-core-v2/test/agent/wireRecord/migration/v1.4.test.ts
+++ b/packages/agent-core-v2/test/wire/migration/v1.4.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { migrateV1_3ToV1_4 } from '#/agent/wireRecord/migration/migration';
+import { migrateV1_3ToV1_4 } from '#/wire/migration/migration';
 import { runMigration } from './utils';
 
 describe('1.3 to 1.4', () => {
@@ -64,7 +64,7 @@ describe('1.3 to 1.4', () => {
         },
       ]),
     ).toMatchInlineSnapshot(`
-      [wire] metadata      { "protocol_version": "<protocol-version>", "created_at": "<time>" }
+      [wire] metadata      { "protocol_version": "1.4", "created_at": "<time>" }
       [wire] goal.create   { "goalId": "goal-1", "objective": "ship the feature", "completionCriterion": "tests pass", "time": "<time>" }
       [wire] goal.update   { "tokensUsed": 5, "wallClockMs": 0, "time": "<time>" }
       [wire] goal.update   { "turnsUsed": 1, "time": "<time>" }
diff --git a/packages/agent-core-v2/test/wire/migration/v1.5.test.ts b/packages/agent-core-v2/test/wire/migration/v1.5.test.ts
new file mode 100644
index 000000000..0e6638371
--- /dev/null
+++ b/packages/agent-core-v2/test/wire/migration/v1.5.test.ts
@@ -0,0 +1,73 @@
+/**
+ * Scenario: migrate persisted goal lifecycle records from wire protocol 1.4 to 1.5.
+ * Responsibilities: recover missing active wall-clock anchors without replacing persisted ones.
+ * Wiring: pure migration exercised through the shared migration test surface.
+ * Run: `pnpm --filter @moonshot-ai/agent-core-v2 exec vitest run test/wire/migration/v1.5.test.ts`.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { migrateV1_4ToV1_5 } from '#/wire/migration/migration';
+import { runMigration } from './utils';
+
+describe('1.4 to 1.5 active wall-clock anchor migration', () => {
+  it('backfills missing anchors from create and resume record timestamps', () => {
+    expect(
+      runMigration(migrateV1_4ToV1_5, [
+        {
+          type: 'metadata',
+          protocol_version: '1.4',
+          created_at: 1,
+        },
+        {
+          type: 'goal.create',
+          goalId: 'goal-1',
+          objective: 'ship the feature',
+          time: 10,
+        },
+        {
+          type: 'goal.update',
+          status: 'paused',
+          wallClockMs: 20,
+          time: 30,
+        },
+        {
+          type: 'goal.update',
+          status: 'active',
+          time: 40,
+        },
+      ]),
+    ).toMatchInlineSnapshot(`
+      [wire] metadata      { "protocol_version": "<protocol-version>", "created_at": "<time>" }
+      [wire] goal.create   { "goalId": "goal-1", "objective": "ship the feature", "time": "<time>", "wallClockResumedAt": 10 }
+      [wire] goal.update   { "status": "paused", "wallClockMs": 20, "time": "<time>" }
+      [wire] goal.update   { "status": "active", "time": "<time>", "wallClockResumedAt": 40 }
+    `);
+  });
+
+  it('preserves an existing active wall-clock anchor', () => {
+    expect(
+      runMigration(migrateV1_4ToV1_5, [
+        {
+          type: 'goal.update',
+          status: 'active',
+          wallClockResumedAt: 35,
+          time: 40,
+        },
+      ]),
+    ).toMatchInlineSnapshot(`[wire] goal.update   { "status": "active", "wallClockResumedAt": 35, "time": "<time>" }`);
+  });
+
+  it('advances a missing anchor from a wall-clock checkpoint timestamp', () => {
+    expect(
+      runMigration(migrateV1_4ToV1_5, [
+        {
+          type: 'goal.update',
+          wallClockMs: 3_000,
+          time: 4_000,
+        },
+      ]),
+    ).toMatchInlineSnapshot(
+      `[wire] goal.update   { "wallClockMs": 3000, "time": "<time>", "wallClockResumedAt": 4000 }`,
+    );
+  });
+});
diff --git a/packages/agent-core-v2/test/agent/wireRecord/persistence.test.ts b/packages/agent-core-v2/test/wire/persistence.test.ts
similarity index 75%
rename from packages/agent-core-v2/test/agent/wireRecord/persistence.test.ts
rename to packages/agent-core-v2/test/wire/persistence.test.ts
index c1bfd5757..6208a3381 100644
--- a/packages/agent-core-v2/test/agent/wireRecord/persistence.test.ts
+++ b/packages/agent-core-v2/test/wire/persistence.test.ts
@@ -1,10 +1,10 @@
 /**
  * Scenario: append-log file persistence and agent wire migration rewrites.
  *
- * Resolves real append-log and wire-record services by interface over file or
+ * Resolves real append-log and Agent wire services by interface over file or
  * in-memory storage. Controlled storage promises expose rewrite durability
  * without wall-clock waits. Run with `pnpm --filter @moonshot-ai/agent-core-v2
- * exec vitest run test/agent/wireRecord/persistence.test.ts`.
+ * exec vitest run test/wire/persistence.test.ts`.
  */
 
 import { randomBytes } from 'node:crypto';
@@ -19,20 +19,17 @@ import { DisposableStore } from '#/_base/di/lifecycle';
 import { TestInstantiationService } from '#/_base/di/test';
 import {
   AppendLogStore,
-  AGENT_WIRE_PROTOCOL_VERSION,
+  WIRE_PROTOCOL_VERSION,
   IFileSystemStorageService,
   IAppendLogStore,
-  type PersistedWireRecord,
+  type WireRecord,
 } from '#/index';
-import {
-  IAgentScopeContext,
-  makeAgentScopeContext,
-} from '#/agent/scopeContext/scopeContext';
-import { IAgentWireRecordService } from '#/agent/wireRecord/wireRecord';
-import { AgentWireRecordService } from '#/agent/wireRecord/wireRecordService';
+import { IWireService } from '#/wire/wire';
 import { FileStorageService } from '#/persistence/backends/node-fs/fileStorageService';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 
+import { registerTestAgentWire } from './stubs';
+
 const cleanups: string[] = [];
 const disposables: DisposableStore[] = [];
 const SCOPE = 'wire-test';
@@ -69,18 +66,12 @@ function createAppendLogHarness(storage: IFileSystemStorageService): IAppendLogS
   return ix.get(IAppendLogStore);
 }
 
-function createWireRecordHarness(log: IAppendLogStore): IAgentWireRecordService {
+function createAgentWireHarness(log: IAppendLogStore): IWireService {
   const disposable = new DisposableStore();
   disposables.push(disposable);
 
   const ix = disposable.add(new TestInstantiationService());
-  ix.stub(
-    IAgentScopeContext,
-    makeAgentScopeContext({ agentId: 'main', agentScope: SCOPE }),
-  );
-  ix.stub(IAppendLogStore, log);
-  ix.set(IAgentWireRecordService, new SyncDescriptor(AgentWireRecordService));
-  return ix.get(IAgentWireRecordService);
+  return registerTestAgentWire(ix, SCOPE, { log });
 }
 
 async function createFileAppendLogHarness(): Promise<{
@@ -148,7 +139,7 @@ describe('AppendLogStore file persistence', () => {
     const { log } = await createFileAppendLogHarness();
     log.append(SCOPE, KEY, {
       type: 'metadata',
-      protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+      protocol_version: WIRE_PROTOCOL_VERSION,
       created_at: 1,
     });
     log.append(SCOPE, KEY, {
@@ -158,11 +149,11 @@ describe('AppendLogStore file persistence', () => {
     });
     await log.close();
 
-    const records = await collect<PersistedWireRecord>(log);
+    const records = await collect<WireRecord>(log);
     expect(records).toHaveLength(2);
     expect(records[0]).toMatchObject({
       type: 'metadata',
-      protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+      protocol_version: WIRE_PROTOCOL_VERSION,
     });
     expect(records[1]!.type).toBe('turn.prompt');
   });
@@ -178,7 +169,7 @@ describe('AppendLogStore file persistence', () => {
     await log.rewrite(SCOPE, KEY, [
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
       },
       {
@@ -216,7 +207,7 @@ describe('AppendLogStore file persistence', () => {
     await log.rewrite(SCOPE, KEY, [
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
       },
       {
@@ -270,39 +261,102 @@ describe('wire record append-log persistence', () => {
     const storage = new InMemoryStorageService();
     const log = createAppendLogHarness(storage);
 
-    log.append<PersistedWireRecord>(SCOPE, KEY, {
+    log.append<WireRecord>(SCOPE, KEY, {
       type: 'turn.prompt',
       input: [{ type: 'text', text: 'one' }],
       origin: { kind: 'user' },
     });
     await log.flush();
-    await log.rewrite<PersistedWireRecord>(SCOPE, KEY, [
+    await log.rewrite<WireRecord>(SCOPE, KEY, [
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
       },
     ]);
 
-    expect(await collect<PersistedWireRecord>(log)).toEqual([
+    expect(await collect<WireRecord>(log)).toEqual([
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
       },
     ]);
   });
 });
 
-describe('AgentWireRecordService migration rewrite', () => {
+describe('WireService seal', () => {
+  it('appends the metadata envelope to an empty log', async () => {
+    const { dir, log } = await createFileAppendLogHarness();
+    const svc = createAgentWireHarness(log);
+
+    await svc.seal();
+    await log.close();
+
+    const lines = await readLines(join(dir, SCOPE, KEY));
+    expect(lines).toHaveLength(1);
+    expect(JSON.parse(lines[0]!)).toMatchObject({
+      type: 'metadata',
+      protocol_version: WIRE_PROTOCOL_VERSION,
+    });
+  });
+
+  it('is a no-op on a non-empty log', async () => {
+    const { dir, log } = await createFileAppendLogHarness();
+    log.append(SCOPE, KEY, {
+      type: 'turn.prompt',
+      input: [{ type: 'text', text: 'existing' }],
+      origin: { kind: 'user' },
+    });
+    await log.flush();
+    const svc = createAgentWireHarness(log);
+
+    await svc.seal();
+    await log.close();
+
+    const lines = await readLines(join(dir, SCOPE, KEY));
+    expect(lines).toHaveLength(1);
+    expect(JSON.parse(lines[0]!)['type']).toBe('turn.prompt');
+  });
+
+  it('seals only once across repeated calls', async () => {
+    const { dir, log } = await createFileAppendLogHarness();
+    const svc = createAgentWireHarness(log);
+
+    await svc.seal();
+    await svc.seal();
+    await log.close();
+
+    const lines = await readLines(join(dir, SCOPE, KEY));
+    expect(lines).toHaveLength(1);
+  });
+
+  it('restore after seal keeps the sealed log untouched', async () => {
+    const { dir, log } = await createFileAppendLogHarness();
+    const svc = createAgentWireHarness(log);
+
+    await svc.seal();
+    await svc.restore();
+    await log.close();
+
+    const lines = await readLines(join(dir, SCOPE, KEY));
+    expect(lines).toHaveLength(1);
+    expect(JSON.parse(lines[0]!)).toMatchObject({
+      type: 'metadata',
+      protocol_version: WIRE_PROTOCOL_VERSION,
+    });
+  });
+});
+
+describe('WireService migration rewrite', () => {
   async function seedLegacyLog(storage: InMemoryStorageService): Promise<IAppendLogStore> {
     const log = createAppendLogHarness(storage);
-    log.append<PersistedWireRecord>(SCOPE, KEY, {
+    log.append<WireRecord>(SCOPE, KEY, {
       type: 'metadata',
       protocol_version: '1.0',
       created_at: 1,
     });
-    log.append<PersistedWireRecord>(SCOPE, KEY, {
+    log.append<WireRecord>(SCOPE, KEY, {
       type: 'turn.prompt',
       input: [{ type: 'text', text: 'hi' }],
       origin: { kind: 'user' },
@@ -329,7 +383,7 @@ describe('AgentWireRecordService migration rewrite', () => {
       return originalWrite(...args);
     };
 
-    const svc = createWireRecordHarness(log);
+    const svc = createAgentWireHarness(log);
     let restored = false;
     const restorePromise = svc.restore().then(() => {
       restored = true;
@@ -340,10 +394,10 @@ describe('AgentWireRecordService migration rewrite', () => {
     releaseWrite();
     await restorePromise;
 
-    const records = await collect<PersistedWireRecord>(log);
+    const records = await collect<WireRecord>(log);
     expect(records[0]).toMatchObject({
       type: 'metadata',
-      protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+      protocol_version: WIRE_PROTOCOL_VERSION,
     });
   });
 
@@ -354,7 +408,7 @@ describe('AgentWireRecordService migration rewrite', () => {
       throw new Error('disk full');
     };
 
-    const svc = createWireRecordHarness(log);
+    const svc = createAgentWireHarness(log);
 
     await expect(svc.restore()).rejects.toThrow('disk full');
   });
diff --git a/packages/agent-core-v2/test/agent/wireRecord/resume.test.ts b/packages/agent-core-v2/test/wire/resume.test.ts
similarity index 84%
rename from packages/agent-core-v2/test/agent/wireRecord/resume.test.ts
rename to packages/agent-core-v2/test/wire/resume.test.ts
index 43596d781..92afce4d3 100644
--- a/packages/agent-core-v2/test/agent/wireRecord/resume.test.ts
+++ b/packages/agent-core-v2/test/wire/resume.test.ts
@@ -5,27 +5,28 @@ import { join } from 'pathe';
 import { describe, expect, it, vi } from 'vitest';
 
 import {
-  AGENT_WIRE_PROTOCOL_VERSION,
-  type PersistedWireRecord,
+  WIRE_PROTOCOL_VERSION,
+  IAgentGoalService,
+  type WireRecord,
   type PromptOrigin,
 } from '#/index';
 import { IAgentTaskService } from '#/agent/task/task';
 import { IAgentPlanService } from '#/agent/plan/plan';
 import { IAgentPromptService } from '#/agent/prompt/prompt';
 import { TurnModel } from '#/agent/loop/turnOps';
-import { IAgentWireService } from '#/wire/tokens';
+import { IWireService } from '#/wire/wire';
 import {
   createAgentTaskPersistence,
   type TaskServiceTestManager,
-} from '../task/stubs';
-import { createFakeHostFs, createFakeProcessRunner } from '../../tools/fixtures/fake-exec';
+} from '../agent/task/stubs';
+import { createFakeHostFs, createFakeProcessRunner } from '../tools/fixtures/fake-exec';
 import {
   DEFAULT_TEST_SYSTEM_PROMPT,
   InMemoryWireRecordPersistence,
   execEnvServices,
   homeDirServices,
   testAgent,
-} from '../../harness';
+} from '../harness';
 
 const MOCK_PROVIDER = {
   type: 'kimi',
@@ -34,7 +35,7 @@ const MOCK_PROVIDER = {
 } as const;
 
 function turnCurrentId(ctx: ReturnType<typeof testAgent>): number {
-  return ctx.get(IAgentWireService).getModel(TurnModel).nextTurnId - 1;
+  return ctx.get(IWireService).getModel(TurnModel).nextTurnId - 1;
 }
 
 describe('Agent resume', () => {
@@ -42,15 +43,15 @@ describe('Agent resume', () => {
     const persistence = new RecordingAgentPersistence([
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
         app_version: '0.0.1-old',
-      } as unknown as PersistedWireRecord,
+      } as unknown as WireRecord,
       {
         type: 'turn.prompt',
         input: [{ type: 'text', text: 'old prompt' }],
         origin: { kind: 'user' },
-      } as unknown as PersistedWireRecord,
+      } as unknown as WireRecord,
     ]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
@@ -61,7 +62,7 @@ describe('Agent resume', () => {
   });
 
   it('replays persisted records without restarting turns, compactions, plan turns, or tools', async () => {
-    const persistence = new RecordingAgentPersistence(resumeHistory() as unknown as PersistedWireRecord[]);
+    const persistence = new RecordingAgentPersistence(resumeHistory() as unknown as WireRecord[]);
     const execWithEnv = vi.fn().mockRejectedValue(new Error('Bash should not execute on resume'));
     const ctx = testAgent(
       execEnvServices({
@@ -105,7 +106,7 @@ describe('Agent resume', () => {
   });
 
   it('allocates monotonically increasing turnIds across multiple historical turns on resume', async () => {
-    const persistence = new RecordingAgentPersistence(multiTurnResumeHistory() as unknown as PersistedWireRecord[]);
+    const persistence = new RecordingAgentPersistence(multiTurnResumeHistory() as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -124,7 +125,7 @@ describe('Agent resume', () => {
   });
 
   it('restores the turn counter past goal-continuation turns that have no turn.prompt record', async () => {
-    const persistence = new RecordingAgentPersistence(goalContinuationResumeHistory() as unknown as PersistedWireRecord[]);
+    const persistence = new RecordingAgentPersistence(goalContinuationResumeHistory() as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -143,7 +144,7 @@ describe('Agent resume', () => {
   });
 
   it('keeps turnIds monotonic across repeated resume cycles', async () => {
-    const persistence = new RecordingAgentPersistence(multiTurnResumeHistory() as unknown as PersistedWireRecord[]);
+    const persistence = new RecordingAgentPersistence(multiTurnResumeHistory() as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -152,7 +153,7 @@ describe('Agent resume', () => {
     await ctx.untilTurnEnd();
     expect(turnCurrentId(ctx)).toBe(2);
 
-    const persistence2 = new RecordingAgentPersistence(persistence.records as unknown as PersistedWireRecord[]);
+    const persistence2 = new RecordingAgentPersistence(persistence.records as unknown as WireRecord[]);
     const ctx2 = testAgent({ persistence: persistence2, autoConfigure: false });
 
     await ctx2.restorePersisted();
@@ -219,7 +220,7 @@ describe('Agent resume', () => {
           toolCallId: 'call_lookup',
         },
       },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -243,7 +244,7 @@ describe('Agent resume', () => {
   });
 
   it('replays inline skill reminders after pending tool results before the next prompt', async () => {
-    const persistence = new RecordingAgentPersistence(resumeDeferredSystemReminderHistory() as unknown as PersistedWireRecord[]);
+    const persistence = new RecordingAgentPersistence(resumeDeferredSystemReminderHistory() as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -307,7 +308,7 @@ describe('Agent resume', () => {
           ],
         },
       },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -351,7 +352,7 @@ describe('Agent resume', () => {
         tokensBefore: 10,
         tokensAfter: 3,
       },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const homeDir = await mkdtemp(join(tmpdir(), 'kimi-bg-resume-delivered-'));
     try {
       const backgroundPersistence = createAgentTaskPersistence(homeDir);
@@ -416,7 +417,7 @@ describe('Agent resume', () => {
         tokensBefore: 120,
         tokensAfter: 24,
       },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -443,7 +444,7 @@ describe('Agent resume', () => {
         input: [{ type: 'text', text: 'Historical prompt' }],
         origin: { kind: 'user' },
       },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const homeDir = await mkdtemp(join(tmpdir(), 'kimi-bg-resume-undelivered-'));
     try {
       const backgroundPersistence = createAgentTaskPersistence(homeDir);
@@ -521,7 +522,7 @@ describe('Agent resume', () => {
           toolCallId: 'call_ghost',
         },
       },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -540,7 +541,7 @@ describe('Agent resume', () => {
     const persistence = new RecordingAgentPersistence([
       {
         type: 'metadata',
-        protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+        protocol_version: WIRE_PROTOCOL_VERSION,
         created_at: 1,
       },
       {
@@ -557,7 +558,7 @@ describe('Agent resume', () => {
         wallClockMs: 65_000,
         actor: 'model',
       },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -565,6 +566,119 @@ describe('Agent resume', () => {
     expect(ctx.context.get()).toHaveLength(0);
   });
 
+  it('restores an envelope-less active interval into a budget-reached paused goal', async () => {
+    const now = vi.spyOn(Date, 'now').mockReturnValue(6_000);
+    const persistence = new RecordingAgentPersistence(
+      [
+        {
+          type: 'goal.create',
+          goalId: 'goal-1',
+          objective: 'ship work',
+          time: 100,
+        },
+        {
+          type: 'goal.update',
+          status: 'paused',
+          wallClockMs: 2_000,
+          actor: 'user',
+          time: 500,
+        },
+        {
+          type: 'goal.update',
+          status: 'active',
+          budgetLimits: { wallClockBudgetMs: 6_000 },
+          actor: 'user',
+          time: 1_000,
+        },
+      ] as unknown as WireRecord[],
+      false,
+    );
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    try {
+      await ctx.restorePersisted();
+
+      const goal = ctx.get(IAgentGoalService).getGoal().goal;
+      expect(goal).toMatchObject({
+        status: 'paused',
+        wallClockMs: 7_000,
+        budget: {
+          wallClockBudgetReached: true,
+          remainingWallClockMs: 0,
+          overBudget: true,
+        },
+      });
+      expect(persistence.appended).toEqual([
+        expect.objectContaining({
+          type: 'goal.update',
+          status: 'paused',
+          reason: 'Paused after agent resume',
+          wallClockMs: 7_000,
+        }),
+      ]);
+      expect(persistence.rewritten).toContainEqual(
+        expect.objectContaining({
+          type: 'goal.update',
+          status: 'active',
+          wallClockResumedAt: 1_000,
+        }),
+      );
+    } finally {
+      now.mockRestore();
+      await ctx.dispose();
+    }
+  });
+
+  it('restores only post-checkpoint active time from a 1.3 wall-clock checkpoint', async () => {
+    const now = vi.spyOn(Date, 'now').mockReturnValue(6_000);
+    const persistence = new RecordingAgentPersistence([
+      {
+        type: 'metadata',
+        protocol_version: '1.3',
+        created_at: 1,
+      },
+      {
+        type: 'goal.create',
+        goalId: 'goal-1',
+        objective: 'ship work',
+        time: 1_000,
+      },
+      {
+        type: 'goal.account_usage',
+        goalId: 'goal-1',
+        wallClockMs: 3_000,
+        time: 4_000,
+      },
+    ] as unknown as WireRecord[]);
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    try {
+      await ctx.restorePersisted();
+
+      expect(ctx.get(IAgentGoalService).getGoal().goal).toMatchObject({
+        status: 'paused',
+        wallClockMs: 5_000,
+      });
+      expect(persistence.appended).toEqual([
+        expect.objectContaining({
+          type: 'goal.update',
+          status: 'paused',
+          wallClockMs: 5_000,
+        }),
+      ]);
+      expect(persistence.rewritten).toContainEqual(
+        expect.objectContaining({
+          type: 'goal.update',
+          wallClockMs: 3_000,
+          wallClockResumedAt: 4_000,
+        }),
+      );
+    } finally {
+      now.mockRestore();
+      await ctx.dispose();
+    }
+  });
+
   it('restores context after undo and removes undone messages from replay', async () => {
     const persistence = new RecordingAgentPersistence([
       {
@@ -649,7 +763,7 @@ describe('Agent resume', () => {
         },
       },
       { type: 'context.undo', count: 1 },
-    ] as unknown as PersistedWireRecord[]);
+    ] as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
 
     await ctx.restorePersisted();
@@ -661,30 +775,30 @@ describe('Agent resume', () => {
 });
 
 class RecordingAgentPersistence extends InMemoryWireRecordPersistence {
-  readonly appended: PersistedWireRecord[] = [];
-  rewritten: readonly PersistedWireRecord[] | undefined;
+  readonly appended: WireRecord[] = [];
+  rewritten: readonly WireRecord[] | undefined;
 
-  constructor(events: readonly PersistedWireRecord[]) {
-    super(withMetadata(events));
+  constructor(events: readonly WireRecord[], addMetadata = true) {
+    super(addMetadata ? withMetadata(events) : events);
   }
 
-  override append(input: PersistedWireRecord): void {
+  override append(input: WireRecord): void {
     this.appended.push(input);
     super.append(input);
   }
 
-  override rewrite(records: readonly PersistedWireRecord[]): void {
+  override rewrite(records: readonly WireRecord[]): void {
     this.rewritten = records;
     super.rewrite(records);
   }
 }
 
-function withMetadata(events: readonly PersistedWireRecord[]): readonly PersistedWireRecord[] {
+function withMetadata(events: readonly WireRecord[]): readonly WireRecord[] {
   if (events.length === 0 || events[0]?.type === 'metadata') return events;
   return [
     {
       type: 'metadata',
-      protocol_version: AGENT_WIRE_PROTOCOL_VERSION,
+      protocol_version: WIRE_PROTOCOL_VERSION,
       created_at: 1,
     },
     ...events,
@@ -703,7 +817,7 @@ function textContent(
   );
 }
 
-function resumeHistory(): PersistedWireRecord[] {
+function resumeHistory(): WireRecord[] {
   return [
     {
       type: 'metadata',
@@ -825,10 +939,10 @@ function resumeHistory(): PersistedWireRecord[] {
       type: 'plan_mode.enter',
       id: 'resume-plan',
     },
-  ] as unknown as PersistedWireRecord[];
+  ] as unknown as WireRecord[];
 }
 
-function resumeDeferredSystemReminderHistory(): PersistedWireRecord[] {
+function resumeDeferredSystemReminderHistory(): WireRecord[] {
   return [
     resumeConfigRecord(),
     {
@@ -903,17 +1017,17 @@ function resumeDeferredSystemReminderHistory(): PersistedWireRecord[] {
         },
       },
     },
-  ] as unknown as PersistedWireRecord[];
+  ] as unknown as WireRecord[];
 }
 
-function resumeConfigRecord(): PersistedWireRecord {
+function resumeConfigRecord(): WireRecord {
   return {
     type: 'config.update',
     cwd: process.cwd(),
     modelAlias: MOCK_PROVIDER.model,
     systemPrompt: DEFAULT_TEST_SYSTEM_PROMPT,
     thinkingLevel: 'off',
-  } as unknown as PersistedWireRecord;
+  } as unknown as WireRecord;
 }
 
 function contextAppendRecord(
@@ -923,7 +1037,7 @@ function contextAppendRecord(
     readonly text: string;
     readonly origin?: PromptOrigin;
   }[],
-): PersistedWireRecord {
+): WireRecord {
   const message = messages[0]!;
   return {
     type: 'context.append_message',
@@ -933,15 +1047,15 @@ function contextAppendRecord(
       toolCalls: [],
       origin: message.origin,
     },
-  } as unknown as PersistedWireRecord;
+  } as unknown as WireRecord;
 }
 
-function turnPromptRecord(_turnId: number, origin: PromptOrigin): PersistedWireRecord {
+function turnPromptRecord(_turnId: number, origin: PromptOrigin): WireRecord {
   return {
     type: 'turn.prompt',
     input: [],
     origin,
-  } as unknown as PersistedWireRecord;
+  } as unknown as WireRecord;
 }
 
 function canonicalPromptedTurn(
@@ -949,7 +1063,7 @@ function canonicalPromptedTurn(
   promptText: string,
   responseText: string,
   start: number,
-): PersistedWireRecord[] {
+): WireRecord[] {
   const origin: PromptOrigin = { kind: 'user' };
   return [
     contextAppendRecord(start, [{ role: 'user', text: promptText, origin }]),
@@ -962,14 +1076,14 @@ function canonicalContinuationTurn(
   turnId: number,
   responseText: string,
   start: number,
-): PersistedWireRecord[] {
+): WireRecord[] {
   return [
     turnPromptRecord(turnId, { kind: 'system_trigger', name: 'goal_continuation' }),
     contextAppendRecord(start, [{ role: 'assistant', text: responseText }]),
   ];
 }
 
-function loopEventsForTurn(turnId: string, responseText: string): PersistedWireRecord[] {
+function loopEventsForTurn(turnId: string, responseText: string): WireRecord[] {
   return [
     {
       type: 'context.append_loop_event',
@@ -1002,10 +1116,10 @@ function loopEventsForTurn(turnId: string, responseText: string): PersistedWireR
       model: MOCK_PROVIDER.model,
       usage: { inputOther: 5, output: 2, inputCacheRead: 0, inputCacheCreation: 0 },
     },
-  ] as unknown as PersistedWireRecord[];
+  ] as unknown as WireRecord[];
 }
 
-function multiTurnResumeHistory(): PersistedWireRecord[] {
+function multiTurnResumeHistory(): WireRecord[] {
   return [
     resumeConfigRecord(),
     ...canonicalPromptedTurn(0, 'First historical prompt', 'First historical response.', 0),
@@ -1013,7 +1127,7 @@ function multiTurnResumeHistory(): PersistedWireRecord[] {
   ];
 }
 
-function goalContinuationResumeHistory(): PersistedWireRecord[] {
+function goalContinuationResumeHistory(): WireRecord[] {
   return [
     resumeConfigRecord(),
     ...canonicalPromptedTurn(0, 'Goal prompt', 'Starting the goal.', 0),
diff --git a/packages/agent-core-v2/test/wire/store-event.test.ts b/packages/agent-core-v2/test/wire/store-event.test.ts
index 358774c2d..455e68ecf 100644
--- a/packages/agent-core-v2/test/wire/store-event.test.ts
+++ b/packages/agent-core-v2/test/wire/store-event.test.ts
@@ -11,9 +11,10 @@ import { InMemoryStorageService } from '#/persistence/backends/memory/inMemorySt
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { defineModel } from '#/wire/model';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from './stubs';
 
 declare module '#/app/event/eventBus' {
   interface DomainEventMap {
@@ -63,12 +64,17 @@ function setup(logKey: string): {
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
   ix.set(IEventBus, new SyncDescriptor(EventBusService));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey }]));
+  const log = ix.get(IAppendLogStore);
+  const eventBus = ix.get(IEventBus);
+  const wire = registerTestAgentWire(ix, testWireScope(SCOPE, logKey), {
+    log,
+    eventBus,
+  });
   return {
     ix,
-    log: ix.get(IAppendLogStore),
-    eventBus: ix.get(IEventBus),
-    wire: ix.get(IAgentWireService),
+    log,
+    eventBus,
+    wire,
   };
 }
 
@@ -82,9 +88,9 @@ afterEach(() => disposables.dispose());
 async function readRecords(
   target: IAppendLogStore = log,
   key = KEY,
-): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of target.read<PersistedRecord>(SCOPE, key)) {
+): Promise<WireRecord[]> {
+  const out: WireRecord[] = [];
+  for await (const record of target.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -129,7 +135,12 @@ describe('WireService Op.toEvent', () => {
     const seen: DomainEvent[] = [];
     disposables.add(replay.eventBus.subscribe((e) => seen.push(e)));
 
-    await replay.wire.replay(...records);
+    await restoreTestAgentWire(
+      replay.wire,
+      replay.log,
+      testWireScope(SCOPE, 'replay'),
+      records,
+    );
 
     expect(replay.wire.getModel(CounterModel)).toEqual({ value: 4 });
     expect(seen).toEqual([]);
diff --git a/packages/agent-core-v2/test/wire/stubs.ts b/packages/agent-core-v2/test/wire/stubs.ts
new file mode 100644
index 000000000..8c5dc22f3
--- /dev/null
+++ b/packages/agent-core-v2/test/wire/stubs.ts
@@ -0,0 +1,127 @@
+import { SyncDescriptor } from '#/_base/di/descriptors';
+import { toDisposable } from '#/_base/di/lifecycle';
+import type { ServiceRegistration, TestInstantiationService } from '#/_base/di/test';
+import { IAgentBlobService } from '#/agent/blob/agentBlobService';
+import { IAgentScopeContext, type IAgentScopeContext as AgentScopeContext } from '#/agent/scopeContext/scopeContext';
+import { IEventBus } from '#/app/event/eventBus';
+import { createHooks } from '#/hooks';
+import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
+import {
+  IWireService,
+  type IWireService as AgentWire,
+  type WireHooks,
+} from '#/wire/wire';
+import { WireService } from '#/wire/wireService';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+interface TestAgentWireDependencies {
+  readonly log?: IAppendLogStore;
+  readonly blob?: IAgentBlobService;
+  readonly eventBus?: IEventBus;
+}
+
+const noopLog: IAppendLogStore = {
+  _serviceBrand: undefined,
+  append: () => {},
+  read: async function* () {},
+  rewrite: async () => {},
+  flush: async () => {},
+  close: async () => {},
+  acquire: () => toDisposable(() => {}),
+};
+
+const noopBlob: IAgentBlobService = {
+  _serviceBrand: undefined,
+  offloadParts: async (parts) => parts,
+  loadParts: async (parts) => parts,
+  isBlobRef: () => false,
+};
+
+const noopEventBus: IEventBus = {
+  _serviceBrand: undefined,
+  publish: () => {},
+  subscribe: () => toDisposable(() => {}),
+};
+
+export function testWireScope(scope: string, journal: string): string {
+  return `${scope}/${journal}`;
+}
+
+export function stubAgentScopeContext(scope: string): AgentScopeContext {
+  return {
+    _serviceBrand: undefined,
+    agentId: 'test-agent',
+    scope: (subKey?: string): string =>
+      subKey === undefined || subKey === '' ? scope : `${scope}/${subKey}`,
+  };
+}
+
+export function registerTestAgentWire(
+  ix: TestInstantiationService,
+  scope: string,
+  dependencies: TestAgentWireDependencies = {},
+): AgentWire {
+  ix.stub(IAgentScopeContext, stubAgentScopeContext(scope));
+  ix.set(IAppendLogStore, dependencies.log ?? noopLog);
+  ix.set(IAgentBlobService, dependencies.blob ?? noopBlob);
+  ix.set(IEventBus, dependencies.eventBus ?? noopEventBus);
+  ix.set(IWireService, new SyncDescriptor(WireService));
+  return ix.get(IWireService);
+}
+
+export function registerTestAgentWireServices(
+  registration: ServiceRegistration,
+  scope = 'wire/test-agent',
+): void {
+  registration.defineInstance(IAgentScopeContext, stubAgentScopeContext(scope));
+  registration.defineInstance(IAppendLogStore, noopLog);
+  registration.defineInstance(IAgentBlobService, noopBlob);
+  registration.defineInstance(IEventBus, noopEventBus);
+  registration.define(IWireService, WireService);
+}
+
+export async function restoreTestAgentWire(
+  wire: AgentWire,
+  log: IAppendLogStore,
+  scope: string,
+  records: readonly WireRecord[],
+): Promise<void> {
+  await log.rewrite(scope, AGENT_WIRE_RECORD_KEY, records);
+  await wire.restore();
+}
+
+export function stubAgentWire(
+  flush: () => Promise<void> = async () => {},
+): AgentWire {
+  return {
+    _serviceBrand: undefined,
+    hooks: createHooks<WireHooks, keyof WireHooks>(['onDidRestore']),
+    dispatch: () => {},
+    seal: async () => {},
+    restore: async () => {},
+    flush,
+    getModel: (model) => model.initial() as never,
+  };
+}
+
+export function recordingWireLog(
+  records: WireRecord[],
+  onAppend?: (record: WireRecord) => void,
+): IAppendLogStore {
+  return {
+    _serviceBrand: undefined,
+    append: (_scope, _key, record) => {
+      records.push(record as WireRecord);
+      onAppend?.(record as WireRecord);
+    },
+    read: async function* <R>() {
+      for (const record of records) yield record as R;
+    },
+    rewrite: async (_scope, _key, next) => {
+      records.splice(0, records.length, ...(next as readonly WireRecord[]));
+    },
+    flush: async () => {},
+    close: async () => {},
+    acquire: () => toDisposable(() => {}),
+  };
+}
diff --git a/packages/agent-core-v2/test/wire/wire-compat.test.ts b/packages/agent-core-v2/test/wire/wire-compat.test.ts
index 855f217d7..a90ca1d02 100644
--- a/packages/agent-core-v2/test/wire/wire-compat.test.ts
+++ b/packages/agent-core-v2/test/wire/wire-compat.test.ts
@@ -15,9 +15,10 @@ import { FileStorageService } from '#/persistence/backends/node-fs/fileStorageSe
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { defineModel } from '#/wire/model';
-import { IAgentWireService } from '#/wire/tokens';
-import type { PersistedRecord } from '#/wire/wireService';
-import { WireService } from '#/wire/wireServiceImpl';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from './stubs';
 
 const SCOPE = 'wire';
 const KEY = 'round-trip';
@@ -57,8 +58,9 @@ function makeContainer(storage: IFileSystemStorageService, logKey: string) {
   const ix = store.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, storage);
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey }]));
-  return { ix, wire: ix.get(IAgentWireService), log: ix.get(IAppendLogStore) };
+  const log = ix.get(IAppendLogStore);
+  const wire = registerTestAgentWire(ix, testWireScope(SCOPE, logKey), { log });
+  return { ix, wire, log };
 }
 
 function makeReader(storage: IFileSystemStorageService): IAppendLogStore {
@@ -70,9 +72,9 @@ function makeReader(storage: IFileSystemStorageService): IAppendLogStore {
   return ix.get(IAppendLogStore);
 }
 
-async function collect(log: IAppendLogStore): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of log.read<PersistedRecord>(SCOPE, KEY)) {
+async function collect(log: IAppendLogStore): Promise<WireRecord[]> {
+  const out: WireRecord[] = [];
+  for await (const record of log.read<WireRecord>(testWireScope(SCOPE, KEY), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
@@ -100,19 +102,24 @@ describe('wire.jsonl round-trip', () => {
     }
 
     const replayTarget = makeContainer(storage, 'replay-target');
-    const withUnknown: PersistedRecord[] = [
+    const withUnknown: WireRecord[] = [
       ...records,
       { type: 'compat.unknown.nope', foo: 1 },
     ];
-    setUnexpectedErrorHandler(() => {});
-    let replayResult;
+    const unexpected: unknown[] = [];
+    setUnexpectedErrorHandler((error) => unexpected.push(error));
     try {
-      replayResult = await replayTarget.wire.replay(...withUnknown);
+      await restoreTestAgentWire(
+        replayTarget.wire,
+        replayTarget.log,
+        testWireScope(SCOPE, 'replay-target'),
+        withUnknown,
+      );
     } finally {
       resetUnexpectedErrorHandler();
     }
 
-    expect(replayResult.unknownRecords).toBe(1);
+    expect(unexpected).toHaveLength(1);
     expect(replayTarget.wire.getModel(CounterModel)).toEqual(
       live.wire.getModel(CounterModel),
     );
diff --git a/packages/agent-core-v2/test/wire/wireServiceImpl.test.ts b/packages/agent-core-v2/test/wire/wireService.test.ts
similarity index 53%
rename from packages/agent-core-v2/test/wire/wireServiceImpl.test.ts
rename to packages/agent-core-v2/test/wire/wireService.test.ts
index a949024eb..8e6887776 100644
--- a/packages/agent-core-v2/test/wire/wireServiceImpl.test.ts
+++ b/packages/agent-core-v2/test/wire/wireService.test.ts
@@ -2,17 +2,22 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { z } from 'zod';
 
 import { SyncDescriptor } from '#/_base/di/descriptors';
-import { DisposableStore } from '#/_base/di/lifecycle';
+import { DisposableStore, toDisposable } from '#/_base/di/lifecycle';
 import { TestInstantiationService } from '#/_base/di/test';
 import { resetUnexpectedErrorHandler, setUnexpectedErrorHandler } from '#/_base/errors/unexpectedError';
+import { IEventBus } from '#/app/event/eventBus';
+import { EventBusService } from '#/app/event/eventBusService';
 import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore';
 import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService';
 import { IAppendLogStore } from '#/persistence/interface/appendLogStore';
 import { IFileSystemStorageService } from '#/persistence/interface/storage';
 import { defineModel } from '#/wire/model';
-import { IAgentWireService } from '#/wire/tokens';
-import type { IWireService, PersistedRecord } from '#/wire/wireService';
-import { CycleError, WireService } from '#/wire/wireServiceImpl';
+import { WIRE_PROTOCOL_VERSION } from '#/wire/migration/migration';
+import { IWireService } from '#/wire/wire';
+import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record';
+import { CycleError } from '#/wire/wireService';
+
+import { registerTestAgentWire, restoreTestAgentWire, testWireScope } from './stubs';
 
 const SCOPE = 'wire';
 const KEY = 'store-test';
@@ -22,13 +27,31 @@ const trace: string[] = [];
 const CounterModel = defineModel('store.counter', () => ({ value: 0 }));
 const OtherModel = defineModel('store.other', () => ({ value: 0 }));
 
+declare module '#/app/event/eventBus' {
+  interface DomainEventMap {
+    'wire.test.counter_changed': { readonly value: number };
+    'wire.test.other_changed': { readonly value: number };
+  }
+}
+
 const counterAdd = CounterModel.defineOp('store.counter.add', {
   schema: z.object({ by: z.number() }),
   apply: (s, p) => {
     trace.push('apply.counter');
     return { value: s.value + p.by };
   },
+  toEvent: (_payload, state) => ({
+    type: 'wire.test.counter_changed' as const,
+    value: state.value,
+  }),
 });
+
+declare module '#/wire/types' {
+  interface PersistedOpMap {
+    'store.counter.add': typeof counterAdd;
+  }
+}
+
 const otherSet = OtherModel.defineOp('store.other.set', {
   schema: z.object({ value: z.number() }),
   apply: (_s, p) => {
@@ -39,6 +62,10 @@ const otherSet = OtherModel.defineOp('store.other.set', {
 const otherInc = OtherModel.defineOp('store.other.inc', {
   schema: z.object({}),
   apply: (s) => ({ value: s.value + 1 }),
+  toEvent: (_payload, state) => ({
+    type: 'wire.test.other_changed' as const,
+    value: state.value,
+  }),
 });
 const mutateCounter = CounterModel.defineOp('store.counter.mutate', {
   schema: z.object({}),
@@ -52,6 +79,7 @@ let disposables: DisposableStore;
 let ix: TestInstantiationService;
 let wire: IWireService;
 let log: IAppendLogStore;
+let eventBus: IEventBus;
 
 beforeEach(() => {
   trace.length = 0;
@@ -59,9 +87,10 @@ beforeEach(() => {
   ix = disposables.add(new TestInstantiationService());
   ix.stub(IFileSystemStorageService, new InMemoryStorageService());
   ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-  ix.set(IAgentWireService, new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: KEY }]));
+  ix.set(IEventBus, new SyncDescriptor(EventBusService));
   log = ix.get(IAppendLogStore);
-  wire = ix.get(IAgentWireService);
+  eventBus = ix.get(IEventBus);
+  wire = registerTestAgentWire(ix, testWireScope(SCOPE, KEY), { log, eventBus });
 });
 
 afterEach(() => disposables.dispose());
@@ -70,92 +99,121 @@ async function readRecords(
   target: IAppendLogStore = log,
   scope = SCOPE,
   key = KEY,
-): Promise<PersistedRecord[]> {
-  const out: PersistedRecord[] = [];
-  for await (const record of target.read<PersistedRecord>(scope, key)) {
+): Promise<WireRecord[]> {
+  const out: WireRecord[] = [];
+  for await (const record of target.read<WireRecord>(testWireScope(scope, key), AGENT_WIRE_RECORD_KEY)) {
     out.push(record);
   }
   return out;
 }
 
 describe('WireService', () => {
-  it('dispatches a single op: apply runs, record persisted, onChange fired once', async () => {
-    const changes: { state: number; prev: number }[] = [];
-    disposables.add(
-      wire.subscribe(CounterModel, (state, prev) =>
-        changes.push({ state: state.value, prev: prev.value }),
-      ),
-    );
-
+  it('dispatches a single op into model state and the journal', async () => {
     wire.dispatch(counterAdd({ by: 3 }));
 
     expect(wire.getModel(CounterModel)).toEqual({ value: 3 });
-    expect(changes).toEqual([{ state: 3, prev: 0 }]);
     expect(await readRecords()).toEqual([
       { type: 'store.counter.add', by: 3, time: expect.any(Number) },
     ]);
   });
 
-  it('applies a multi-op group atomically across two models before any onChange', () => {
-    let otherSeenByCounter: number | undefined;
-    disposables.add(
-      wire.subscribe(CounterModel, () => {
-        trace.push('change.counter');
-        otherSeenByCounter = wire.getModel(OtherModel).value;
-      }),
-    );
-    disposables.add(wire.subscribe(OtherModel, () => trace.push('change.other')));
-
+  it('applies a multi-op group across its models in order', () => {
     wire.dispatch(counterAdd({ by: 1 }), otherSet({ value: 42 }));
 
-    expect(trace).toEqual([
-      'apply.counter',
-      'apply.other',
-      'change.counter',
-      'change.other',
-    ]);
-    expect(otherSeenByCounter).toBe(42);
+    expect(trace).toEqual(['apply.counter', 'apply.other']);
     expect(wire.getModel(CounterModel)).toEqual({ value: 1 });
     expect(wire.getModel(OtherModel)).toEqual({ value: 42 });
   });
 
-  it('replays silently: apply runs, no persist, no onChange, onRestored once', async () => {
+  it('replays silently: apply runs, no event or persist, onDidRestore once', async () => {
     wire.dispatch(counterAdd({ by: 5 }));
     const records = await readRecords();
 
     const ix2 = disposables.add(new TestInstantiationService());
     ix2.stub(IFileSystemStorageService, new InMemoryStorageService());
     ix2.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
-    ix2.set(
-      IAgentWireService,
-      new SyncDescriptor(WireService, [{ logScope: SCOPE, logKey: 'replay' }]),
-    );
+    ix2.set(IEventBus, new SyncDescriptor(EventBusService));
     const log2 = ix2.get(IAppendLogStore);
-    const replayed = ix2.get(IAgentWireService);
+    const replayEventBus = ix2.get(IEventBus);
+    const replayed = registerTestAgentWire(ix2, testWireScope(SCOPE, 'replay'), {
+      log: log2,
+      eventBus: replayEventBus,
+    });
 
-    let changes = 0;
+    const events: number[] = [];
     let restored = 0;
-    disposables.add(replayed.subscribe(CounterModel, () => (changes += 1)));
     disposables.add(
-      replayed.onRestored(() => {
+      replayEventBus.subscribe('wire.test.counter_changed', (event) => events.push(event.value)),
+    );
+    disposables.add(
+      replayed.hooks.onDidRestore.register('test', async (_ctx, next) => {
         restored += 1;
+        await next();
       }),
     );
 
-    await replayed.replay(...records);
+    await restoreTestAgentWire(
+      replayed,
+      log2,
+      testWireScope(SCOPE, 'replay'),
+      records,
+    );
 
     expect(replayed.getModel(CounterModel)).toEqual({ value: 5 });
-    expect(changes).toBe(0);
+    expect(events).toEqual([]);
     expect(restored).toBe(1);
-    expect(await readRecords(log2, SCOPE, 'replay')).toEqual([]);
+    expect((await readRecords(log2, SCOPE, 'replay')).slice(1)).toEqual(records);
+  });
+
+  it('fails restore when an onDidRestore hook fails', async () => {
+    const expected = new Error('restore participant failed');
+    disposables.add(
+      wire.hooks.onDidRestore.register('failing-participant', async () => {
+        throw expected;
+      }),
+    );
+
+    await expect(wire.restore()).rejects.toBe(expected);
+  });
+
+  it('applies each current-version record before requesting the next record during restore', async () => {
+    let streamed!: IWireService;
+    const streamingLog: IAppendLogStore = {
+      _serviceBrand: undefined,
+      append: () => {},
+      read: async function* <R>() {
+        yield {
+          type: 'metadata',
+          protocol_version: WIRE_PROTOCOL_VERSION,
+          created_at: 1,
+        } as R;
+        yield { type: 'store.counter.add', by: 2 } as R;
+        expect(streamed.getModel(CounterModel)).toEqual({ value: 2 });
+        yield { type: 'store.counter.add', by: 3 } as R;
+      },
+      rewrite: async () => {},
+      flush: async () => {},
+      close: async () => {},
+      acquire: () => toDisposable(() => {}),
+    };
+    const streamingIx = disposables.add(new TestInstantiationService());
+    streamed = registerTestAgentWire(
+      streamingIx,
+      testWireScope(SCOPE, 'streaming'),
+      { log: streamingLog },
+    );
+
+    await streamed.restore();
+
+    expect(streamed.getModel(CounterModel)).toEqual({ value: 5 });
   });
 
   it('queues reentrant dispatch and drains it after the current group', () => {
     const seen: number[] = [];
     disposables.add(
-      wire.subscribe(CounterModel, (state) => {
-        seen.push(state.value);
-        if (state.value < 3) wire.dispatch(counterAdd({ by: 1 }));
+      eventBus.subscribe('wire.test.counter_changed', (event) => {
+        seen.push(event.value);
+        if (event.value < 3) wire.dispatch(counterAdd({ by: 1 }));
       }),
     );
 
@@ -166,8 +224,12 @@ describe('WireService', () => {
   });
 
   it('throws CycleError when a dispatch cascade exceeds MAX_DRAIN', () => {
-    disposables.add(wire.subscribe(CounterModel, () => wire.dispatch(otherInc({}))));
-    disposables.add(wire.subscribe(OtherModel, () => wire.dispatch(counterAdd({ by: 1 }))));
+    disposables.add(
+      eventBus.subscribe('wire.test.counter_changed', () => wire.dispatch(otherInc({}))),
+    );
+    disposables.add(
+      eventBus.subscribe('wire.test.other_changed', () => wire.dispatch(counterAdd({ by: 1 }))),
+    );
 
     expect(() => wire.dispatch(counterAdd({ by: 1 }))).toThrow(CycleError);
     try {
@@ -181,18 +243,22 @@ describe('WireService', () => {
     }
   });
 
-  it('reports and counts unknown record types during replay, skipping them', async () => {
+  it('reports unknown record types during replay and skips them', async () => {
     const unexpected: unknown[] = [];
     setUnexpectedErrorHandler((error) => unexpected.push(error));
     try {
-      const result = await wire.replay(
-        { type: 'store.counter.add', by: 2 },
-        { type: 'no.such.op', foo: 1 },
-        { type: 'store.counter.add', by: 3 },
+      await restoreTestAgentWire(
+        wire,
+        log,
+        testWireScope(SCOPE, KEY),
+        [
+          { type: 'store.counter.add', by: 2 },
+          { type: 'no.such.op', foo: 1 },
+          { type: 'store.counter.add', by: 3 },
+        ],
       );
 
       expect(wire.getModel(CounterModel)).toEqual({ value: 5 });
-      expect(result).toEqual({ unknownRecords: 1 });
       expect(unexpected).toHaveLength(1);
       expect(unexpected[0]).toMatchObject({
         code: 'wire.unknown_record',
diff --git a/packages/agent-core/CHANGELOG.md b/packages/agent-core/CHANGELOG.md
index 164f62b3e..9984eb1c3 100644
--- a/packages/agent-core/CHANGELOG.md
+++ b/packages/agent-core/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @moonshot-ai/agent-core
 
+## 0.15.5
+
+### Patch Changes
+
+- [#1769](https://github.com/MoonshotAI/kimi-code/pull/1769) [`d1ca65e`](https://github.com/MoonshotAI/kimi-code/commit/d1ca65e1de189617e9edbc54010e62d472a1de3d) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Support in-process editor hosts with session lifecycle, context, MCP configuration, and cross-platform session storage APIs.
+
 ## 0.15.4
 
 ### Patch Changes
diff --git a/packages/agent-core/package.json b/packages/agent-core/package.json
index 84999b882..d9c1dae09 100644
--- a/packages/agent-core/package.json
+++ b/packages/agent-core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/agent-core",
-  "version": "0.15.4",
+  "version": "0.15.5",
   "private": true,
   "description": "The unified agent engine for Kimi",
   "license": "MIT",
diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index b3a17b752..52f2864dd 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -25,9 +25,11 @@ import type { ContextMessage } from '../context/types';
 import { stripDynamicToolContext } from '../context/dynamic-tools';
 import { isAbortError } from '../../loop/errors';
 import {
+  findAPIStatusError,
   retryBackoffDelays,
   sleepForRetry,
 } from '../../loop/retry';
+import { LLMRequestTraceState } from '../../loop/llm';
 import {
   renderTodoList,
   TODO_STORE_KEY,
@@ -86,6 +88,11 @@ export class FullCompaction {
   // stop an overflow -> compact -> overflow loop when compaction can no
   // longer shrink the request below the model window.
   private consecutiveOverflowCompactions = 0;
+  // Trace id (`x-trace-id`, Kimi/KFC only) of the latest summarizer request,
+  // updated on every attempt — success or failure — so a compaction cancelled
+  // mid-request can still be attributed to its server-side request.
+  private lastSummarizerTraceId: string | undefined;
+  private activeSummarizerTrace: LLMRequestTraceState | undefined;
   protected readonly strategy: CompactionStrategy;
 
   constructor(
@@ -109,6 +116,13 @@ export class FullCompaction {
     return this.compacting !== null;
   }
 
+  /** Trace id (`x-trace-id`, Kimi/KFC only) of the latest summarizer request. */
+  get lastTraceId(): string | undefined {
+    return this.activeSummarizerTrace !== undefined
+      ? this.activeSummarizerTrace.traceId
+      : this.lastSummarizerTraceId;
+  }
+
   getEffectiveMaxContextTokens(): number {
     const configured = this.agent.config.modelCapabilities.max_context_tokens;
     const modelAlias = this.agent.config.modelAlias;
@@ -390,6 +404,10 @@ export class FullCompaction {
     const originalHistory = [...this.agent.context.history];
     const tokensBefore = estimateTokensForMessages(originalHistory);
     let retryCount = 0;
+    // Reset per round: a failure before any response headers arrive (network
+    // error / local abort) must report no trace id, not a previous round's.
+    this.lastSummarizerTraceId = undefined;
+    this.activeSummarizerTrace = undefined;
     try {
       await this.triggerPreCompactHook(data, tokensBefore, signal);
 
@@ -450,9 +468,14 @@ export class FullCompaction {
         ];
         const estimatedCompactionRequestTokens = this.estimateRequestTokens(messages);
         try {
+          const trace = new LLMRequestTraceState();
+          this.activeSummarizerTrace = trace;
           const generateOptions: GenerateOptionsWithRequestLogFields = {
             signal,
             requestLogFields: { kind: 'compaction', droppedCount },
+            onTraceId: (traceId) => {
+              trace.capture(traceId);
+            },
           };
           const response = await this.agent.generate(
             provider,
@@ -462,6 +485,9 @@ export class FullCompaction {
             undefined,
             generateOptions,
           );
+          // Multi-round compaction keeps the latest round's request trace id.
+          this.lastSummarizerTraceId = response.traceId ?? undefined;
+          this.activeSummarizerTrace = undefined;
           if (response.finishReason === 'truncated') {
             throw new CompactionTruncatedError();
           }
@@ -469,6 +495,12 @@ export class FullCompaction {
           summary = extractCompactionSummary(response);
           break;
         } catch (error) {
+          // A failed request usually still returns response headers, so its
+          // trace id rides along on the converted status error.
+          const statusError = findAPIStatusError(error);
+          if (statusError?.traceId !== null && statusError?.traceId !== undefined) {
+            this.activeSummarizerTrace?.capture(statusError.traceId);
+          }
           // A request-body-size rejection (HTTP 413) or an image-format
           // rejection is first retried with media parts replaced by text
           // markers: accumulated base64 payloads are the usual 413 culprit,
@@ -601,6 +633,7 @@ export class FullCompaction {
         retry_count: retryCount,
         round: 1,
         thinking_effort: this.agent.config.thinkingEffort,
+        trace_id: this.lastTraceId,
         ...(usage === null
           ? {}
           : { input_tokens: inputTotal(usage), output_tokens: usage.output }),
@@ -622,6 +655,7 @@ export class FullCompaction {
         retry_count: retryCount,
         thinking_effort: this.agent.config.thinkingEffort,
         error_type: error instanceof Error ? error.name : 'Unknown',
+        trace_id: this.lastTraceId,
       });
       if (
         isKimiError(error) &&
diff --git a/packages/agent-core/src/agent/config/index.ts b/packages/agent-core/src/agent/config/index.ts
index c8e3678ce..29d9cf255 100644
--- a/packages/agent-core/src/agent/config/index.ts
+++ b/packages/agent-core/src/agent/config/index.ts
@@ -31,7 +31,10 @@ export class ConfigState {
   private _cwd: string;
   private _modelAlias: string | undefined;
   private _profileName: string | undefined;
-  private _unforcedThinkingEffort: ThinkingEffort = 'off';
+  // `undefined` until an effort has actually been resolved: a bare modelAlias
+  // update must then fall through to the model's own default instead of
+  // treating the never-chosen initial "off" as an explicit user choice.
+  private _unforcedThinkingEffort: ThinkingEffort | undefined;
   private _thinkingEffort: ThinkingEffort = 'off';
   private _systemPrompt: string = '';
 
@@ -46,6 +49,7 @@ export class ConfigState {
     const targetAlias = changed.modelAlias ?? this._modelAlias;
     const targetProvider = this.tryResolvedProviderConfigFor(targetAlias);
     const targetModel = this.modelForThinking(targetAlias, targetProvider);
+    const kimiProtocol = targetProvider?.provider.type === 'kimi';
     const kimiProvider = targetProvider?.type === 'kimi';
     let unforcedThinkingEffort: ThinkingEffort | undefined;
     let thinkingEffort: ThinkingEffort | undefined;
@@ -54,14 +58,19 @@ export class ConfigState {
         changed.thinkingEffort,
         this.agent.kimiConfig?.thinking,
         targetModel,
-        kimiProvider,
+        kimiProtocol,
       );
     } else if (changed.modelAlias !== undefined) {
+      // A bare model switch carries the previously resolved effort over to the
+      // new model. Before any effort was resolved (fresh session bootstrap)
+      // `undefined` lets resolveThinkingEffort fall through to the model
+      // default — computed from the resolved provider, whose capabilities and
+      // efforts include the provider-level protocol inference.
       unforcedThinkingEffort = resolveThinkingEffort(
-        this._modelAlias === undefined ? undefined : this._unforcedThinkingEffort,
+        this._unforcedThinkingEffort,
         this.agent.kimiConfig?.thinking,
         targetModel,
-        kimiProvider,
+        kimiProtocol,
       );
     }
     if (unforcedThinkingEffort !== undefined) {
@@ -100,13 +109,16 @@ export class ConfigState {
     if (this.hasProvider && (changed.cwd !== undefined || changed.modelAlias)) {
       this.agent.tools.initializeBuiltinTools();
     }
+    if (thinkingEffort !== undefined || changed.modelAlias !== undefined) {
+      this.agent.warnAboutCurrentAnthropicThinkingEffort();
+    }
     this.agent.emitStatusUpdated(thinkingEffort !== undefined);
   }
 
   setThinkingEffort(effort: ThinkingEffort): void {
     const model = this.currentModel;
-    const kimiProvider = this.tryResolvedProviderConfig()?.type === 'kimi';
-    if (!supportsThinkingEffort(effort, model, kimiProvider)) {
+    const kimiProtocol = this.tryResolvedProviderConfig()?.provider.type === 'kimi';
+    if (!supportsThinkingEffort(effort, model, kimiProtocol)) {
       const efforts = model?.supportEfforts ?? [];
       const supported = efforts.length === 0 ? 'off' : ['off', ...efforts].join(', ');
       throw new KimiError(
diff --git a/packages/agent-core/src/agent/config/thinking.ts b/packages/agent-core/src/agent/config/thinking.ts
index 9b5e64bb7..727063b6d 100644
--- a/packages/agent-core/src/agent/config/thinking.ts
+++ b/packages/agent-core/src/agent/config/thinking.ts
@@ -50,9 +50,9 @@ export function defaultThinkingEffortFor(model: ModelAlias | undefined): Thinkin
 export function supportsThinkingEffort(
   effort: ThinkingEffort,
   model: ModelAlias | undefined,
-  kimiProvider: boolean,
+  kimiProtocol: boolean,
 ): boolean {
-  if (!kimiProvider || effort === 'off') return true;
+  if (!kimiProtocol || effort === 'off') return true;
   const effective = model === undefined ? undefined : effectiveModelAlias(model);
   if (!supportsThinking(effective)) return false;
   const efforts = effortsFor(effective);
@@ -62,7 +62,7 @@ export function supportsThinkingEffort(
 function normalizeThinkingEffortForModel(
   effort: ThinkingEffort,
   model: ModelAlias | undefined,
-  kimiProvider: boolean,
+  kimiProtocol: boolean,
 ): ThinkingEffort {
   const effective = model === undefined ? undefined : effectiveModelAlias(model);
   if (effort === 'off' && effective?.capabilities?.includes('always_thinking') !== true) {
@@ -70,7 +70,7 @@ function normalizeThinkingEffortForModel(
   }
 
   const efforts = effortsFor(effective);
-  if (!kimiProvider) {
+  if (!kimiProtocol) {
     return effort === 'on' && efforts.length > 0
       ? defaultThinkingEffortFor(effective)
       : effort;
@@ -91,15 +91,15 @@ function normalizeThinkingEffortForModel(
  *   2. `thinking.enabled === false` forces `'off'`;
  *   3. otherwise `thinking.effort` when set, else the model's default effort.
  *
- * The `always_thinking` constraint is enforced here and only here: when a
- * model declares `always_thinking`, an `'off'` result is clamped back to the
- * model's default effort so thinking can never be disabled for it.
+ * The `always_thinking` constraint is enforced locally only for the Kimi wire
+ * protocol. Compatible protocols receive the requested value unchanged so
+ * their backend can make the final capability decision.
  */
 export function resolveThinkingEffort(
   requested: ThinkingEffort | undefined,
   config: ThinkingConfig | undefined,
   model: ModelAlias | undefined,
-  kimiProvider = false,
+  kimiProtocol = false,
 ): ThinkingEffort {
   const effectiveModel = model === undefined ? undefined : effectiveModelAlias(model);
   let effort: ThinkingEffort;
@@ -111,7 +111,11 @@ export function resolveThinkingEffort(
     effort = config?.effort ?? defaultThinkingEffortFor(effectiveModel);
   }
 
-  if (effort === 'off' && effectiveModel?.capabilities?.includes('always_thinking') === true) {
+  if (
+    kimiProtocol &&
+    effort === 'off' &&
+    effectiveModel?.capabilities?.includes('always_thinking') === true
+  ) {
     // always_thinking forces thinking on, but an explicitly configured effort
     // is still honored — `enabled = false` only expresses the intent to
     // disable, it should not also discard a chosen effort. Fall back to the
@@ -119,5 +123,5 @@ export function resolveThinkingEffort(
     effort = config?.effort ?? defaultThinkingEffortFor(effectiveModel);
   }
 
-  return normalizeThinkingEffortForModel(effort, effectiveModel, kimiProvider);
+  return normalizeThinkingEffortForModel(effort, effectiveModel, kimiProtocol);
 }
diff --git a/packages/agent-core/src/agent/context/index.ts b/packages/agent-core/src/agent/context/index.ts
index 798fc6e32..3934ac3b0 100644
--- a/packages/agent-core/src/agent/context/index.ts
+++ b/packages/agent-core/src/agent/context/index.ts
@@ -5,7 +5,7 @@ import { ErrorCodes, KimiError } from '../../errors';
 import type { LoopRecordedEvent } from '../../loop';
 import { extractImageCompressionCaptions } from '../../tools/support/image-compress';
 import { estimateTokens, estimateTokensForMessages } from '../../utils/tokens';
-import { escapeXml } from '../../utils/xml-escape';
+import { escapeXml, escapeXmlAttr } from '../../utils/xml-escape';
 import {
   COMPACT_USER_MESSAGE_MAX_TOKENS,
   COMPACTION_ELISION_VARIANT,
@@ -41,6 +41,10 @@ export * from './dynamic-tools';
 const TOOL_INTERRUPTED_ON_RESUME_OUTPUT =
   'Tool execution was interrupted before its result was recorded. Do not assume the tool completed successfully.';
 
+const IMPORT_CONTEXT_GUIDANCE =
+  'This is a prior conversation history that may be relevant to the current session. ' +
+  'Please review this context and use it to inform your responses.';
+
 // Invariant: _history must not contain an unresolved tool call exchange except
 // at the tail. When the tail is unresolved, pendingToolResultIds is exactly the
 // set of missing tool result ids for that tail exchange; appendMessage keeps
@@ -180,6 +184,72 @@ export class ContextMemory {
     this.agent.emitStatusUpdated();
   }
 
+  importContext(content: string, source: string): void {
+    if (content.trim().length === 0) {
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, 'Imported context cannot be empty', {
+        details: { reason: 'import_content_empty' },
+      });
+    }
+    const normalizedSource = source.trim();
+    if (normalizedSource.length === 0) {
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, 'Imported context source cannot be empty', {
+        details: { reason: 'import_source_empty' },
+      });
+    }
+
+    const message: ContextMessage = {
+      role: 'user',
+      content: [
+        {
+          type: 'text',
+          text:
+            `<system>The user has imported context from ${escapeXml(normalizedSource)}. ` +
+            `${IMPORT_CONTEXT_GUIDANCE}</system>`,
+        },
+        {
+          type: 'text',
+          text:
+            `<imported_context source="${escapeXmlAttr(normalizedSource)}">\n` +
+            `${content}\n</imported_context>`,
+        },
+      ],
+      toolCalls: [],
+      origin: USER_PROMPT_ORIGIN,
+    };
+    const currentTokenCount = this.tokenCountWithPending;
+    const importTokenCount = estimateTokensForMessages([message]);
+    const totalTokenCount = currentTokenCount + importTokenCount;
+    const maxContextTokens = this.agent.config.modelCapabilities.max_context_tokens;
+    if (maxContextTokens > 0 && totalTokenCount > maxContextTokens) {
+      throw new KimiError(
+        ErrorCodes.CONTEXT_OVERFLOW,
+        'Imported content is too large for the current model context ' +
+          `(~${String(importTokenCount)} import tokens + ${String(currentTokenCount)} existing ` +
+          `= ~${String(totalTokenCount)} total > ${String(maxContextTokens)} token limit). ` +
+          'Please import a smaller file or session.',
+        {
+          details: {
+            reason: 'import_context_overflow',
+            importTokenCount,
+            currentTokenCount,
+            totalTokenCount,
+            maxContextTokens,
+          },
+        },
+      );
+    }
+
+    this.appendMessage(message);
+    this.updateTokenCount(totalTokenCount);
+  }
+
+  updateTokenCount(tokenCount: number): void {
+    this.agent.records.logRecord({ type: 'context.update_token_count', tokenCount });
+    this._tokenCount = tokenCount;
+    this.tokenCountCoveredMessageCount = this._history.length;
+    this.agent.emitStatusUpdated();
+  }
+
   undo(count: number): void {
     if (count <= 0) return;
     if (this._history.length === 0) return;
@@ -654,6 +724,10 @@ export class ContextMemory {
           arguments: event.args === undefined ? null : JSON.stringify(event.args),
           extras: event.extras,
         });
+        if (event.display !== undefined) {
+          openStep.toolCallDisplays ??= {};
+          openStep.toolCallDisplays[event.toolCallId] = event.display;
+        }
         this.pendingToolResultIds.add(event.toolCallId);
         return;
       }
diff --git a/packages/agent-core/src/agent/context/types.ts b/packages/agent-core/src/agent/context/types.ts
index d16b0c520..f4f6f7a4e 100644
--- a/packages/agent-core/src/agent/context/types.ts
+++ b/packages/agent-core/src/agent/context/types.ts
@@ -1,6 +1,7 @@
 import type { ContentPart, Message } from '@moonshot-ai/kosong';
 
 import type { SkillSource } from '../../skill';
+import type { ToolInputDisplay } from '../../tools/display';
 import type { BackgroundTaskStatus } from '../background';
 
 export interface UserPromptOrigin {
@@ -103,6 +104,11 @@ export type PromptOrigin =
 export type ContextMessage = Message & {
   readonly origin?: PromptOrigin | undefined;
   readonly isError?: boolean;
+  /**
+   * UI-only input displays keyed by tool call id. These are rebuilt from the
+   * persisted loop events for resume/replay and stripped before provider calls.
+   */
+  toolCallDisplays?: Record<string, ToolInputDisplay>;
   /**
    * Tool-result side channel rendered to the model but never to UIs; see
    * `ExecutableToolResult.note`. Appended to the projected tool message at
diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
index 49da2182c..cc57dc146 100644
--- a/packages/agent-core/src/agent/index.ts
+++ b/packages/agent-core/src/agent/index.ts
@@ -6,7 +6,7 @@ import { ErrorCodes, KimiError, makeErrorPayload } from '#/errors';
 import { log } from '#/logging/logger';
 import type { Logger } from '#/logging/types';
 import type { AgentAPI, AgentEvent, KimiConfig, SDKAgentRPC, UsageStatus } from '#/rpc';
-import { generate } from '@moonshot-ai/kosong';
+import { generate, type ChatProvider } from '@moonshot-ai/kosong';
 
 import type { EnabledPluginSessionStart, PluginCommandDef } from '#/plugin';
 import { expandCommandArguments } from '../plugin/commands';
@@ -162,6 +162,15 @@ export class Agent {
   private additionalDirs: readonly string[];
   private activeProfile?: ResolvedAgentProfile;
   private brandHome?: string;
+  private readonly emittedThinkingEffortWarnings = new Set<string>();
+  private readonly pendingThinkingEffortWarnings: Array<{
+    readonly code: string;
+    readonly message: string;
+    readonly modelAlias: string | undefined;
+    readonly model: string;
+    readonly effort: string;
+    readonly knownEfforts: string | undefined;
+  }> = [];
   private readonly systemPromptContextProvider?: (() => Promise<PreparedSystemPromptContext>) | undefined;
 
   constructor(options: AgentOptions) {
@@ -269,6 +278,7 @@ export class Agent {
         // before dispatching), so it must not leave a request trace or a
         // diagnostic log line claiming a request was sent.
         if (requestOptions?.signal?.aborted !== true) {
+          this.warnAboutAnthropicThinkingEffort(provider, modelAlias);
           this.llmRequestLogger.logRequest({
             provider,
             modelAlias,
@@ -303,6 +313,107 @@ export class Agent {
     };
   }
 
+  private warnAboutAnthropicThinkingEffort(
+    provider: ChatProvider,
+    modelAlias: string | undefined,
+  ): void {
+    if (provider.name !== 'anthropic') return;
+    const effort = provider.thinkingEffort;
+    if (effort === null || effort === 'on') return;
+
+    let warning:
+      | { readonly code: string; readonly message: string; readonly knownEfforts?: string }
+      | undefined;
+    try {
+      const resolved =
+        modelAlias === undefined
+          ? undefined
+          : this.modelProvider?.resolveProviderConfig(modelAlias);
+      if (resolved === undefined) return;
+
+      if (effort === 'off') {
+        if (resolved.alwaysThinking !== true) return;
+        warning = {
+          code: 'anthropic-thinking-cannot-disable',
+          message: `Model "${provider.modelName}" declares always-on thinking. The configured effort "off" will be sent unchanged to the Anthropic-compatible backend.`,
+        };
+      } else {
+        const supportEfforts = resolved.supportEfforts?.filter((value) => value.length > 0);
+        if (supportEfforts === undefined || supportEfforts.length === 0) return;
+        if (supportEfforts.includes(effort)) return;
+        warning = {
+          code: 'anthropic-thinking-effort-not-listed',
+          message: `Thinking effort "${effort}" is not listed for model "${provider.modelName}" (known: ${supportEfforts.join(', ')}). The configured value will be sent unchanged to the Anthropic-compatible backend.`,
+          knownEfforts: supportEfforts.join(','),
+        };
+      }
+    } catch {
+      // Capability diagnostics must never turn an otherwise sendable request
+      // into a client-side failure.
+      return;
+    }
+
+    if (warning === undefined) return;
+    const key = [warning.code, modelAlias, provider.modelName, effort, warning.knownEfforts].join(
+      '\u0000',
+    );
+    if (this.emittedThinkingEffortWarnings.has(key)) return;
+    this.emittedThinkingEffortWarnings.add(key);
+    const pending = {
+      code: warning.code,
+      message: warning.message,
+      modelAlias,
+      model: provider.modelName,
+      effort,
+      knownEfforts: warning.knownEfforts,
+    };
+    if (this.records.restoring) {
+      this.pendingThinkingEffortWarnings.push(pending);
+      return;
+    }
+    this.publishAnthropicThinkingEffortWarning(pending);
+  }
+
+  private publishAnthropicThinkingEffortWarning(
+    warning: (typeof this.pendingThinkingEffortWarnings)[number],
+  ): void {
+    try {
+      this.log.warn(warning.message, {
+        modelAlias: warning.modelAlias,
+        model: warning.model,
+        effort: warning.effort,
+        knownEfforts: warning.knownEfforts,
+      });
+    } catch {
+      // Diagnostics must never block resume or request dispatch.
+    }
+    try {
+      const delivery = this.rpc?.emitEvent?.({
+        type: 'warning',
+        code: warning.code,
+        message: warning.message,
+      });
+      void delivery?.catch(() => {});
+    } catch {
+      // Diagnostics must never block resume or request dispatch.
+    }
+  }
+
+  private flushPendingAnthropicThinkingEffortWarnings(): void {
+    for (const warning of this.pendingThinkingEffortWarnings.splice(0)) {
+      this.publishAnthropicThinkingEffortWarning(warning);
+    }
+  }
+
+  warnAboutCurrentAnthropicThinkingEffort(): void {
+    try {
+      if (!this.config.hasProvider) return;
+      this.warnAboutAnthropicThinkingEffort(this.config.provider, this.config.modelAlias);
+    } catch {
+      // A capability warning must never make config replay or session resume fail.
+    }
+  }
+
   get llm(): KosongLLM {
     // All provider-level request config (thinking, sampling params, thinking.keep)
     // is applied in ConfigState.provider so compaction shares it. See get provider().
@@ -370,6 +481,7 @@ export class Agent {
 
   async resume(options?: AgentRecordsReplayOptions): Promise<{ warning?: string }> {
     const result = await this.records.replay(options);
+    this.flushPendingAnthropicThinkingEffortWarnings();
     try {
       this.replayBuilder.postRestoring = true;
       this.goal.normalizeAfterReplay();
@@ -397,7 +509,10 @@ export class Agent {
       },
       cancel: (payload) => {
         if (this.turn.hasActiveTurn) {
-          this.telemetry.track('cancel', { from: 'streaming' });
+          this.telemetry.track('cancel', {
+            from: 'streaming',
+            trace_id: this.turn.activeRequestTraceId(),
+          });
         }
         this.turn.cancel(payload.turnId);
       },
@@ -468,7 +583,10 @@ export class Agent {
       },
       cancelCompaction: () => {
         if (this.fullCompaction.isCompacting) {
-          this.telemetry.track('cancel', { from: 'compacting' });
+          this.telemetry.track('cancel', {
+            from: 'compacting',
+            trace_id: this.fullCompaction.lastTraceId,
+          });
         }
         this.fullCompaction.cancel();
       },
@@ -488,6 +606,15 @@ export class Agent {
       clearContext: () => {
         this.context.clear();
       },
+      importContext: (payload) => {
+        if (this.turn.hasActiveTurn || this.fullCompaction.isCompacting) {
+          throw new KimiError(
+            ErrorCodes.TURN_AGENT_BUSY,
+            'Cannot import context while the agent is busy',
+          );
+        }
+        this.context.importContext(payload.content, payload.source);
+      },
       activateSkill: (payload) => {
         if (this.skills === null) {
           throw new KimiError(ErrorCodes.SKILL_NOT_FOUND, `Skill "${payload.name}" was not found`);
diff --git a/packages/agent-core/src/agent/permission/index.ts b/packages/agent-core/src/agent/permission/index.ts
index 3d901becf..dbc4b0855 100644
--- a/packages/agent-core/src/agent/permission/index.ts
+++ b/packages/agent-core/src/agent/permission/index.ts
@@ -166,6 +166,7 @@ export class PermissionManager {
           duration_ms: Date.now() - startedAt,
           session_cache_written: false,
           has_feedback: false,
+          trace_id: context.traceId,
         });
         void this.agent.hooks?.fireAndForgetTrigger?.('PermissionResult', {
           matcherValue: name,
@@ -230,6 +231,7 @@ export class PermissionManager {
       duration_ms: Date.now() - startedAt,
       session_cache_written: sessionApprovalRule !== undefined,
       has_feedback: response.feedback !== undefined && response.feedback.length > 0,
+      trace_id: context.traceId,
     });
 
     const resolved = result.resolveApproval?.(response);
diff --git a/packages/agent-core/src/agent/records/index.ts b/packages/agent-core/src/agent/records/index.ts
index 6873c5277..8ee39dc67 100644
--- a/packages/agent-core/src/agent/records/index.ts
+++ b/packages/agent-core/src/agent/records/index.ts
@@ -99,6 +99,9 @@ function restoreAgentRecord(agent: Agent, input: AgentRecord): void {
         }
       }
       return;
+    case 'context.update_token_count':
+      agent.context.updateTokenCount(input.tokenCount);
+      return;
     case 'context.clear':
       agent.context.clear();
       return;
diff --git a/packages/agent-core/src/agent/records/types.ts b/packages/agent-core/src/agent/records/types.ts
index fed30c675..77310021f 100644
--- a/packages/agent-core/src/agent/records/types.ts
+++ b/packages/agent-core/src/agent/records/types.ts
@@ -95,6 +95,7 @@ export interface AgentRecordEvents {
 
   'context.append_message': { message: ContextMessage };
   'context.append_loop_event': { event: LoopRecordedEvent };
+  'context.update_token_count': { tokenCount: number };
   'context.clear': {};
   'context.apply_compaction': CompactionResult;
   'context.undo': { count: number };
diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 59b311639..13a26eeba 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -521,6 +521,15 @@ export class ToolManager {
     // builtin/user tool names. The split keeps every caller on one string[].
     this.enabledTools = new Set(names.filter((name) => !isMcpToolName(name)));
     this.mcpAccessPatterns = names.filter((name) => isMcpToolName(name));
+    // Builtin construction reads the enabled set (Bash/Agent bake
+    // `allowBackground` from the Task* trio), and the constructor may already
+    // have built the map while the enabled set was still empty. The lazy
+    // re-init in `get tools()` only fires on an empty map, so rebuild here —
+    // otherwise a profile applied after construction (every subagent) keeps
+    // the construction-time capabilities.
+    if (this.agent.config.hasProvider) {
+      this.initializeBuiltinTools();
+    }
   }
 
   copyLoopToolsFrom(source: ToolManager): void {
@@ -703,6 +712,7 @@ export class ToolManager {
           allowBackground,
           autoBackgroundOnTimeout:
             this.agent.kimiConfig?.background?.bashAutoBackgroundOnTimeout ?? true,
+          backgroundTimeoutS: this.agent.kimiConfig?.background?.bashTaskTimeoutS,
         }),
         (modelCapabilities.image_in || modelCapabilities.video_in) &&
           new b.ReadMediaFileTool(
diff --git a/packages/agent-core/src/agent/turn/index.ts b/packages/agent-core/src/agent/turn/index.ts
index 957ecc247..3136aa688 100644
--- a/packages/agent-core/src/agent/turn/index.ts
+++ b/packages/agent-core/src/agent/turn/index.ts
@@ -27,6 +27,7 @@ import { isAbortError, isMaxStepsExceededError } from '../../loop/errors';
 import {
   createLoopEventDispatcher,
   runTurn,
+  type LLMRequestTrace,
   type ExecutableToolResult,
   type LoopEvent,
   type LoopRecordedEvent,
@@ -123,13 +124,19 @@ export class TurnFlow {
   private steerBuffer: BufferedSteer[] = [];
   private turnId = -1;
   private activeTurn: 'resuming' | ActiveTurn | null = null;
-  private readonly toolCallStartedAt = new Map<string, { name: string; startedAt: number }>();
+  private readonly toolCallStartedAt = new Map<
+    string,
+    { name: string; startedAt: number; traceId: string | undefined }
+  >();
   private readonly toolCallDupType = new Map<string, 'normal' | 'cross_step'>();
   private readonly stepToolCallKeys = new Map<number, Set<string>>();
   private readonly telemetryModeByTurn = new Map<number, 'agent' | 'plan'>();
   private readonly currentStepByTurn = new Map<number, number>();
   private readonly interruptedTelemetryTurnIds = new Set<number>();
+  private readonly interruptedTraceIdByTurn = new Map<number, string | undefined>();
   private readonly stepFailureByTurn = new Map<number, LoopTurnInterruptedEvent>();
+  private activeRequestTrace: LLMRequestTrace | undefined;
+  private latestTraceId: string | undefined;
   private currentStep = 0;
 
   constructor(protected readonly agent: Agent) {}
@@ -280,6 +287,10 @@ export class TurnFlow {
     return this.turnId;
   }
 
+  activeRequestTraceId(): string | undefined {
+    return this.activeRequestTrace?.traceId;
+  }
+
   get hasActiveTurn(): boolean {
     return this.activeTurn !== null && this.activeTurn !== 'resuming';
   }
@@ -521,7 +532,7 @@ export class TurnFlow {
     const telemetryMode = this.telemetryMode();
     this.telemetryModeByTurn.set(turnId, telemetryMode);
     this.currentStepByTurn.set(turnId, 0);
-    this.agent.telemetry.track('turn_started', { mode: telemetryMode, ...this.requestProtocolProps() });
+    this.agent.telemetry.track('turn_started', { turn_id: turnId, mode: telemetryMode, ...this.requestProtocolProps() });
     this.agent.fullCompaction.resetForTurn();
     this.agent.usage.beginTurn();
     this.agent.emitEvent({ type: 'turn.started', turnId, origin });
@@ -590,6 +601,17 @@ export class TurnFlow {
           if (inputTokens !== undefined) {
             properties['input_tokens'] = inputTokens;
           }
+          // The failed request's own trace id: from the error response
+          // headers when it is a status error; otherwise from the in-flight
+          // capture — a failure after response headers arrived (mid-stream
+          // decode error, empty response) carries no trace on the error
+          // itself, but the request's headers were captured. Failures before
+          // any response (network errors, local aborts) leave the per-step
+          // capture empty, so those still report no trace.
+          const traceId = this.activeRequestTrace?.traceId;
+          if (traceId !== undefined) {
+            properties['trace_id'] = traceId;
+          }
           this.agent.telemetry.track('api_error', properties);
         }
       }
@@ -618,11 +640,19 @@ export class TurnFlow {
         inputData: { turnId, reason: 'cancelled' },
       });
     }
+    const terminalTraceId =
+      ended.reason === 'completed'
+        ? this.latestTraceId
+        : this.interruptedTraceIdByTurn.has(turnId)
+          ? this.interruptedTraceIdByTurn.get(turnId)
+          : this.activeRequestTrace?.traceId;
     this.agent.telemetry.track('turn_ended', {
+      turn_id: turnId,
       reason: ended.reason,
       duration_ms: ended.durationMs,
       mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
       ...this.requestProtocolProps(),
+      trace_id: terminalTraceId,
     });
     this.agent.emitEvent(ended);
     // Release the active turn in the same frame as turn.ended for a standalone
@@ -656,12 +686,16 @@ export class TurnFlow {
         turnId,
         this.currentStepByTurn.get(turnId) ?? this.currentStep,
         interruptReason,
+        this.activeRequestTrace?.traceId,
       );
     }
     this.telemetryModeByTurn.delete(turnId);
     this.currentStepByTurn.delete(turnId);
     this.interruptedTelemetryTurnIds.delete(turnId);
+    this.interruptedTraceIdByTurn.delete(turnId);
     this.stepFailureByTurn.delete(turnId);
+    this.activeRequestTrace = undefined;
+    this.latestTraceId = undefined;
     return { event: ended, stopReason: completedStopReason, blockedByUserPromptHook };
   }
 
@@ -769,6 +803,10 @@ export class TurnFlow {
               this.agent.log.warn('goal token accounting failed', { error });
             }
           },
+          onRequestTrace: (trace) => {
+            this.activeRequestTrace = trace;
+            deduper.beginStep(trace);
+          },
           hooks: {
             beforeStep: async ({ signal: stepSignal }) => {
               this.agent.microCompaction.detect();
@@ -781,7 +819,6 @@ export class TurnFlow {
               // re-injected later, so append them only after compaction runs.
               this.flushSteerBuffer();
               await this.agent.injection.inject();
-              deduper.beginStep();
               return;
             },
             afterStep: async ({ usage }) => {
@@ -1014,7 +1051,15 @@ export class TurnFlow {
       this.beginTrackedStep(turnId, event.step);
       return;
     }
+    if (event.type === 'step.end') {
+      // Final write: the completed step's last attempt wins over any earlier
+      // mid-stream capture (e.g. from a retried attempt).
+      this.latestTraceId = event.traceId;
+      this.activeRequestTrace = undefined;
+      return;
+    }
     if (event.type === 'turn.interrupted') {
+      this.interruptedTraceIdByTurn.set(turnId, event.traceId);
       if (event.reason === 'error' && event.activeStep !== undefined) {
         this.stepFailureByTurn.set(turnId, event);
       }
@@ -1022,6 +1067,7 @@ export class TurnFlow {
         turnId,
         interruptedStep(event),
         event.interruptReason ?? telemetryInterruptReason(event.reason, false),
+        event.traceId,
       );
       return;
     }
@@ -1031,6 +1077,7 @@ export class TurnFlow {
   private beginTrackedStep(turnId: number, step: number): void {
     this.currentStepByTurn.set(turnId, step);
     this.currentStep = step;
+    this.activeRequestTrace = undefined;
     if (!this.stepToolCallKeys.has(step)) {
       this.stepToolCallKeys.set(step, new Set());
     }
@@ -1038,7 +1085,13 @@ export class TurnFlow {
 
   private trackToolLifecycle(event: LoopEvent, turnId: number): void {
     if (event.type === 'tool.call') {
-      const dupType = this.trackDuplicateToolCall(turnId, event.step, event.name, event.args);
+      const dupType = this.trackDuplicateToolCall(
+        turnId,
+        event.step,
+        event.name,
+        event.args,
+        event.traceId,
+      );
       this.toolCallDupType.set(
         event.toolCallId,
         dupType === 'cross_step' ? 'cross_step' : 'normal',
@@ -1046,6 +1099,7 @@ export class TurnFlow {
       this.toolCallStartedAt.set(event.toolCallId, {
         name: event.name,
         startedAt: Date.now(),
+        traceId: event.traceId,
       });
       return;
     }
@@ -1057,10 +1111,12 @@ export class TurnFlow {
       this.toolCallDupType.delete(event.toolCallId);
       const outcome = telemetryToolOutcome(event.result);
       const properties: Record<string, TelemetryPropertyValue> = {
+        turn_id: turnId,
         tool_name: started.name,
         outcome,
         duration_ms: Date.now() - started.startedAt,
         dup_type: dupType,
+        trace_id: event.traceId ?? started.traceId,
       };
       const errorType = outcome === 'error' ? telemetryToolErrorType(event.result) : undefined;
       if (errorType !== undefined) {
@@ -1075,6 +1131,7 @@ export class TurnFlow {
     step: number,
     toolName: string,
     args: unknown,
+    traceId: string | undefined,
   ): 'normal' | 'same_step' | 'cross_step' {
     const argsText = canonicalTelemetryArgs(args);
     const key = `${toolName}\u0000${argsText}`;
@@ -1097,6 +1154,7 @@ export class TurnFlow {
       tool_name: toolName,
       dup_type: dupType,
       args_hash: createHash('sha256').update(argsText).digest('hex').slice(0, 8),
+      trace_id: traceId,
     });
     return dupType;
   }
@@ -1112,14 +1170,18 @@ export class TurnFlow {
     turnId: number,
     atStep: number,
     interruptReason: TelemetryInterruptReason,
+    traceId: string | undefined,
   ): void {
     if (this.interruptedTelemetryTurnIds.has(turnId)) return;
     this.interruptedTelemetryTurnIds.add(turnId);
+    this.interruptedTraceIdByTurn.set(turnId, traceId);
     this.agent.telemetry.track('turn_interrupted', {
+      turn_id: turnId,
       mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
       at_step: atStep,
       interrupt_reason: interruptReason,
       ...this.requestProtocolProps(),
+      trace_id: traceId,
     });
   }
 
diff --git a/packages/agent-core/src/agent/turn/kosong-llm.ts b/packages/agent-core/src/agent/turn/kosong-llm.ts
index 2e0e4beea..893ea13fd 100644
--- a/packages/agent-core/src/agent/turn/kosong-llm.ts
+++ b/packages/agent-core/src/agent/turn/kosong-llm.ts
@@ -122,6 +122,7 @@ export class KosongLLM implements LLM {
       onRequestStart: markRequestStart,
       onRequestSent: markRequestSent,
       onStreamEnd: markStreamEnd,
+      onTraceId: (traceId) => params.trace?.capture(traceId),
       requestLogFields: params.requestLogFields,
     };
 
@@ -157,6 +158,7 @@ export class KosongLLM implements LLM {
         firstChunkAt === undefined
           ? undefined
           : buildStreamTiming(requestStartedAt, requestSentAt, firstChunkAt, streamEndedAt, decodeStats),
+      traceId: result.traceId ?? undefined,
     };
 
     return response;
diff --git a/packages/agent-core/src/agent/turn/tool-dedup.ts b/packages/agent-core/src/agent/turn/tool-dedup.ts
index 605408777..f57679c8f 100644
--- a/packages/agent-core/src/agent/turn/tool-dedup.ts
+++ b/packages/agent-core/src/agent/turn/tool-dedup.ts
@@ -1,6 +1,7 @@
 import type { ContentPart } from '@moonshot-ai/kosong';
 
 import type { TelemetryClient } from '../../telemetry';
+import type { LLMRequestTrace } from '../../loop/llm';
 import type { ExecutableToolResult } from '../../loop/types';
 
 import { canonicalTelemetryArgs } from './canonical-args';
@@ -129,12 +130,16 @@ export class ToolCallDeduplicator {
   private consecutiveKey: string | null = null;
   private consecutiveCount = 0;
   private readonly telemetry: TelemetryClient | undefined;
+  private requestTrace: LLMRequestTrace | undefined;
 
-  constructor(options?: { readonly telemetry?: TelemetryClient | undefined }) {
+  constructor(options?: {
+    readonly telemetry?: TelemetryClient | undefined;
+  }) {
     this.telemetry = options?.telemetry;
   }
 
-  beginStep(): void {
+  beginStep(trace?: LLMRequestTrace): void {
+    this.requestTrace = trace;
     for (const deferred of this.stepDeferreds.values()) {
       deferred.resolve({
         output: 'Tool call deduplicated but original result was lost',
@@ -247,6 +252,7 @@ export class ToolCallDeduplicator {
         tool_name: toolName,
         repeat_count: streak,
         action,
+        trace_id: this.requestTrace?.traceId,
       });
     }
 
diff --git a/packages/agent-core/src/config/index.ts b/packages/agent-core/src/config/index.ts
index b4c9799d7..b34ef5653 100644
--- a/packages/agent-core/src/config/index.ts
+++ b/packages/agent-core/src/config/index.ts
@@ -1,6 +1,7 @@
 export * from './merge';
 export * from './model';
 export * from './path';
+export * from './print-defaults';
 export * from './resolve';
 export * from './schema';
 export * from './toml';
diff --git a/packages/agent-core/src/config/model.ts b/packages/agent-core/src/config/model.ts
index c31ea35c7..b8a19f5a3 100644
--- a/packages/agent-core/src/config/model.ts
+++ b/packages/agent-core/src/config/model.ts
@@ -1,16 +1,20 @@
-import type { ModelAlias } from './schema';
+import {
+  BUDGET_THINKING_EFFORTS,
+  inferAnthropicModelProfile,
+  matchKnownAnthropicModelProfile,
+} from '@moonshot-ai/kosong/providers/anthropic-profile';
 
-export function effectiveModelAlias(alias: ModelAlias): ModelAlias {
+import type { ModelAlias, ProviderType } from './schema';
+
+export function effectiveModelAlias(
+  alias: ModelAlias,
+  providerType?: ProviderType,
+): ModelAlias {
   const { overrides, ...base } = alias;
-  if (overrides === undefined) return alias;
-
-  const effective: ModelAlias = {
-    ...base,
-    ...overrides,
-  };
+  const effective: ModelAlias = overrides === undefined ? alias : { ...base, ...overrides };
 
   if (
-    overrides.supportEfforts !== undefined &&
+    overrides?.supportEfforts !== undefined &&
     overrides.defaultEffort === undefined &&
     effective.defaultEffort !== undefined &&
     !overrides.supportEfforts.includes(effective.defaultEffort)
@@ -18,7 +22,41 @@ export function effectiveModelAlias(alias: ModelAlias): ModelAlias {
     delete effective.defaultEffort;
   }
 
-  return effective;
+  return withAnthropicProfile(effective, providerType);
+}
+
+function withAnthropicProfile(model: ModelAlias, providerType?: ProviderType): ModelAlias {
+  const protocol = model.protocol ?? providerType;
+  // The inferred fallback profile exists for third-party Anthropic-compatible
+  // endpoints whose model name encodes no known Claude version. Kimi providers
+  // — including managed models routed through protocol = "anthropic" — declare
+  // thinking efforts via the catalog, so they never receive the fallback.
+  // Callers without provider context fall back to name matching only.
+  const profile =
+    providerType !== undefined && providerType !== 'kimi' && protocol === 'anthropic'
+      ? inferAnthropicModelProfile(model.model)
+      : matchKnownAnthropicModelProfile(model.model);
+  if (profile === undefined) return model;
+
+  const capability = profile.canDisableThinking ? 'thinking' : 'always_thinking';
+  const capabilities = model.capabilities ?? [];
+  const hasCapability = capabilities.some(
+    (candidate) => candidate.trim().toLowerCase() === capability,
+  );
+  // `adaptive_thinking = false` opts the endpoint out of the adaptive API, so
+  // the catalog must not advertise adaptive-only efforts (xhigh/max) — this
+  // mirrors the budget branch of kosong's resolveThinkingProfile.
+  const supportEfforts =
+    model.supportEfforts ??
+    (model.adaptiveThinking === false ? [...BUDGET_THINKING_EFFORTS] : [...profile.efforts]);
+
+  return {
+    ...model,
+    capabilities: hasCapability ? capabilities : [...capabilities, capability],
+    supportEfforts,
+    defaultEffort:
+      model.defaultEffort ?? (supportEfforts.includes('high') ? 'high' : undefined),
+  };
 }
 
 export function effectiveModelAliases(
diff --git a/packages/agent-core/src/config/print-defaults.ts b/packages/agent-core/src/config/print-defaults.ts
new file mode 100644
index 000000000..22cd91fc5
--- /dev/null
+++ b/packages/agent-core/src/config/print-defaults.ts
@@ -0,0 +1,55 @@
+import type { KimiConfig } from './schema';
+
+/**
+ * Print-mode (`kimi -p`) defaults for the v1 engine. A headless run should not
+ * be cut short by limits meant for interactive use, so every value here is
+ * "effectively unbounded". Explicit user config always wins over these.
+ */
+
+/**
+ * Wall-clock ceiling (seconds) for the drain/steer wait once the main turn
+ * ends: 10 years ≈ unbounded.
+ */
+export const PRINT_WAIT_CEILING_S_DEFAULT = 315_360_000;
+
+/** Cap on extra turns steered by background-task completions: ≈ unbounded. */
+export const PRINT_MAX_TURNS_DEFAULT = 100_000;
+
+/**
+ * Per-subagent (`Agent` / `AgentSwarm`, foreground and background) timeout:
+ * `0` = no timeout (the interactive default is 2 hours). A headless run must
+ * never have a subagent killed by a wall-clock cap; only the model itself may
+ * stop one.
+ */
+export const PRINT_SUBAGENT_TIMEOUT_MS_DEFAULT = 0;
+
+/**
+ * Background Bash task timeout: `0` = no timeout (the interactive default is
+ * 600s). Also covers foreground commands re-armed after being moved to the
+ * background on timeout, so a headless run never kills a command it detached.
+ */
+export const PRINT_BASH_TASK_TIMEOUT_S_DEFAULT = 0;
+
+/**
+ * Merge print-mode defaults into the config bound to a new session. Only
+ * values the user left unset are filled (per-key spread order).
+ *
+ * `background` gets only the `bashTaskTimeoutS` fill: the print background
+ * *mode* defaults live next to the consuming code in `Session`
+ * (`resolvePrintBackgroundMode`, `waitForBackgroundTasksOnPrint`,
+ * `handlePrintMainTurnCompleted`), because `printBackgroundMode`'s fallback
+ * must keep honoring the legacy `keep_alive_on_exit` → `'drain'` mapping.
+ */
+export function applyPrintModeConfigDefaults(config: KimiConfig): KimiConfig {
+  return {
+    ...config,
+    // `0` is already what an unset maxStepsPerTurn means (unlimited); the
+    // explicit value just pins the print-mode contract.
+    loopControl: { maxStepsPerTurn: 0, ...config.loopControl },
+    background: {
+      bashTaskTimeoutS: PRINT_BASH_TASK_TIMEOUT_S_DEFAULT,
+      ...config.background,
+    },
+    subagent: { timeoutMs: PRINT_SUBAGENT_TIMEOUT_MS_DEFAULT, ...config.subagent },
+  };
+}
diff --git a/packages/agent-core/src/config/schema.ts b/packages/agent-core/src/config/schema.ts
index 6c11e3537..06e7c9d30 100644
--- a/packages/agent-core/src/config/schema.ts
+++ b/packages/agent-core/src/config/schema.ts
@@ -133,6 +133,13 @@ export const BackgroundConfigSchema = z.object({
    * instead of killing it. Defaults to true when unset.
    */
   bashAutoBackgroundOnTimeout: z.boolean().optional(),
+  /**
+   * Default timeout (seconds) for background Bash tasks when the call omits
+   * `timeout`, also used to re-arm foreground commands moved to the
+   * background. `0` means no timeout. Explicit per-call `timeout` values are
+   * unaffected. Defaults to the Bash tool's built-in 600s when unset.
+   */
+  bashTaskTimeoutS: z.number().int().min(0).optional(),
   killGracePeriodMs: z.number().int().min(0).optional(),
   printWaitCeilingS: z.number().int().min(1).optional(),
   printBackgroundMode: z.enum(['exit', 'drain', 'steer']).optional(),
@@ -142,7 +149,11 @@ export const BackgroundConfigSchema = z.object({
 export type BackgroundConfig = z.infer<typeof BackgroundConfigSchema>;
 
 export const SubagentConfigSchema = z.object({
-  timeoutMs: z.number().int().min(1).optional(),
+  /**
+   * Per-subagent (`Agent` / `AgentSwarm`, foreground and background) timeout
+   * in milliseconds. `0` means no timeout. Defaults to 2 hours when unset.
+   */
+  timeoutMs: z.number().int().min(0).optional(),
 });
 
 export type SubagentConfig = z.infer<typeof SubagentConfigSchema>;
@@ -232,6 +243,10 @@ export const McpServerHttpConfigSchema = z.object({
   transport: z.literal('http'),
   url: z.string().url(),
   headers: StringRecordSchema.optional(),
+  // Backward-compatible UI marker. OAuth is still discovered from a remote
+  // server's 401 response; this flag only records that the user explicitly
+  // chose OAuth and lets hosts expose login/reset controls before connecting.
+  auth: z.literal('oauth').optional(),
   // Indirect secret reference: the bearer token is looked up from
   // `process.env[bearerTokenEnvVar]` at connection time, never committed.
   bearerTokenEnvVar: z.string().min(1).optional(),
@@ -244,6 +259,7 @@ export const McpServerSseConfigSchema = z.object({
   transport: z.literal('sse'),
   url: z.string().url(),
   headers: StringRecordSchema.optional(),
+  auth: z.literal('oauth').optional(),
   // Indirect secret reference: the bearer token is looked up from
   // `process.env[bearerTokenEnvVar]` at connection time, never committed.
   bearerTokenEnvVar: z.string().min(1).optional(),
diff --git a/packages/agent-core/src/index.ts b/packages/agent-core/src/index.ts
index 97ccf3f06..25236a7d2 100644
--- a/packages/agent-core/src/index.ts
+++ b/packages/agent-core/src/index.ts
@@ -10,6 +10,7 @@ export * from './plugin';
 export { buildReplay } from './agent/replay/build';
 export {
   flushDiagnosticLogs,
+  flushDiagnosticLogsSync,
   getRootLogger,
   log,
   redact,
diff --git a/packages/agent-core/src/logging/index.ts b/packages/agent-core/src/logging/index.ts
index 51be3b8a6..ab8ec689d 100644
--- a/packages/agent-core/src/logging/index.ts
+++ b/packages/agent-core/src/logging/index.ts
@@ -14,6 +14,7 @@ export { LOG_LEVEL_RANK, levelEnabled } from './types';
 export {
   __resetRootLoggerForTest,
   flushDiagnosticLogs,
+  flushDiagnosticLogsSync,
   getRootLogger,
   log,
   redact,
diff --git a/packages/agent-core/src/logging/logger.ts b/packages/agent-core/src/logging/logger.ts
index c8b507bd1..6a8b64a26 100644
--- a/packages/agent-core/src/logging/logger.ts
+++ b/packages/agent-core/src/logging/logger.ts
@@ -276,6 +276,16 @@ export function flushDiagnosticLogs(): Promise<boolean> {
   return getRootInternal().flush();
 }
 
+/**
+ * Synchronous variant for crash / emergency-exit paths that call
+ * `process.exit()` on the same tick: pending entries are appended with
+ * `appendFileSync`, so they survive the immediate exit that would otherwise
+ * drop everything still sitting in the async queue.
+ */
+export function flushDiagnosticLogsSync(): void {
+  getRootInternal().flushSync();
+}
+
 class LoggerImpl implements Logger {
   constructor(private readonly boundCtx: LogContext) {}
 
diff --git a/packages/agent-core/src/loop/events.ts b/packages/agent-core/src/loop/events.ts
index 5b19e3633..6b6998a35 100644
--- a/packages/agent-core/src/loop/events.ts
+++ b/packages/agent-core/src/loop/events.ts
@@ -43,6 +43,12 @@ export interface LoopStepEndEvent {
   readonly providerFinishReason?: FinishReason | undefined;
   readonly rawFinishReason?: string | undefined;
   readonly messageId?: string | undefined;
+  /**
+   * Provider trace identifier from the `x-trace-id` response header of this
+   * step's final request attempt (Kimi/KFC only). Telemetry-only; must not
+   * drive loop control.
+   */
+  readonly traceId?: string;
 }
 
 export interface LoopStepRetryingEvent {
@@ -80,6 +86,7 @@ export interface LoopToolCallEvent {
   readonly description?: string | undefined;
   readonly display?: ToolInputDisplay | undefined;
   readonly extras?: Record<string, unknown> | undefined;
+  readonly traceId?: string;
 }
 
 export interface LoopToolResultEvent {
@@ -87,6 +94,7 @@ export interface LoopToolResultEvent {
   readonly parentUuid: string;
   readonly toolCallId: string;
   readonly result: ExecutableToolResult;
+  readonly traceId?: string;
 }
 
 export interface LoopTurnInterruptedEvent {
@@ -100,6 +108,7 @@ export interface LoopTurnInterruptedEvent {
    * cancel vs. any other abort; `max_steps`/`error` mirror `reason`.
    */
   readonly interruptReason?: LoopInterruptCause | undefined;
+  readonly traceId?: string;
 }
 
 export interface LoopTextDeltaEvent {
diff --git a/packages/agent-core/src/loop/index.ts b/packages/agent-core/src/loop/index.ts
index 78796ce86..9e070cc03 100644
--- a/packages/agent-core/src/loop/index.ts
+++ b/packages/agent-core/src/loop/index.ts
@@ -67,6 +67,7 @@ export type {
   LLMChatParams,
   LLMChatResponse,
   LLMRequestLogFields,
+  LLMRequestTrace,
   LLMStreamTiming,
   ToolCallDelta,
 } from './llm';
diff --git a/packages/agent-core/src/loop/llm.ts b/packages/agent-core/src/loop/llm.ts
index 49a14689d..160c4dac6 100644
--- a/packages/agent-core/src/loop/llm.ts
+++ b/packages/agent-core/src/loop/llm.ts
@@ -68,6 +68,22 @@ export interface LLMStreamTiming {
   readonly clientConsumeMs?: number;
 }
 
+export interface LLMRequestTrace {
+  readonly traceId: string | undefined;
+}
+
+export class LLMRequestTraceState implements LLMRequestTrace {
+  traceId: string | undefined;
+
+  reset(): void {
+    this.traceId = undefined;
+  }
+
+  capture(traceId: string | null | undefined): void {
+    this.traceId = traceId ?? undefined;
+  }
+}
+
 export interface LLMChatParams {
   messages: Message[];
   tools: readonly Tool[];
@@ -90,6 +106,7 @@ export interface LLMChatParams {
    * order. Durable transcript writes receive completed blocks only.
    */
   onThinkPart?: ((part: ThinkPart) => Promise<void> | void) | undefined;
+  trace?: LLMRequestTraceState;
 }
 
 export interface LLMChatResponse {
@@ -99,6 +116,8 @@ export interface LLMChatResponse {
   messageId?: string;
   usage: TokenUsage;
   streamTiming?: LLMStreamTiming;
+  /** Provider trace identifier from the `x-trace-id` response header (Kimi/KFC only). */
+  traceId?: string;
 }
 
 export interface LLM {
diff --git a/packages/agent-core/src/loop/retry.ts b/packages/agent-core/src/loop/retry.ts
index 863e67ea8..0a675a174 100644
--- a/packages/agent-core/src/loop/retry.ts
+++ b/packages/agent-core/src/loop/retry.ts
@@ -1,5 +1,6 @@
 import { sleep } from '@antfu/utils';
 
+import { APIStatusError } from '@moonshot-ai/kosong';
 import type { Logger } from '#/logging/types';
 
 import { abortable } from '../utils/abort';
@@ -7,14 +8,17 @@ import type { LoopEventDispatcher } from './events';
 import { isAbortError } from './errors';
 import type { LLM, LLMChatParams, LLMChatResponse } from './llm';
 
-export const DEFAULT_MAX_RETRY_ATTEMPTS = 3;
+// Default retry budget per step: 10 attempts (9 retries). With the
+// exponential ramp below the backoff climbs 0.5s, 1s, 2s … up to the 32s
+// cap, giving roughly 2–3 minutes of total wait — enough to ride out a
+// typical provider overload window (sustained 429s) instead of surfacing
+// the error after a couple of quick retries.
+export const DEFAULT_MAX_RETRY_ATTEMPTS = 10;
 
 const BASE_DELAY_MS = 500;
-// Per-attempt backoff cap (32s). With the default 3 attempts the ramp
-// (0.5s, 1s) never reaches the cap, so interactive runs are unaffected; it
-// only matters for high-attempt configs (e.g. eval harnesses with
-// `max_retries_per_step = 10`), where it lets retries ride out multi-minute
-// provider overload instead of giving up after a few seconds of backoff.
+// Per-attempt backoff cap (32s). The default 10-attempt ramp reaches the
+// cap on the 7th retry, so most of the budget is spent at the cap waiting
+// out multi-minute provider overload.
 const MAX_DELAY_MS = 32_000;
 const RETRY_FACTOR = 2;
 // Up to 25% jitter on top of the exponential base to avoid herd retries.
@@ -36,9 +40,13 @@ export async function chatWithRetry(input: ChatWithRetryInput): Promise<LLMChatR
 
   if (input.llm.isRetryableError === undefined || maxAttempts <= 1) {
     const effectiveMaxAttempts = Math.max(maxAttempts, 1);
+    input.params.trace?.reset();
     try {
-      return await input.llm.chat(paramsForAttempt(input, 1, effectiveMaxAttempts));
+      const response = await input.llm.chat(paramsForAttempt(input, 1, effectiveMaxAttempts));
+      input.params.trace?.capture(response.traceId);
+      return response;
     } catch (error) {
+      captureAttemptTraceId(input, error);
       logRequestFailure(input, error, 1, effectiveMaxAttempts);
       throw error;
     }
@@ -47,9 +55,13 @@ export async function chatWithRetry(input: ChatWithRetryInput): Promise<LLMChatR
   const delays = retryBackoffDelays(maxAttempts);
 
   for (let attempt = 1; ; attempt += 1) {
+    input.params.trace?.reset();
     try {
-      return await input.llm.chat(paramsForAttempt(input, attempt, maxAttempts));
+      const response = await input.llm.chat(paramsForAttempt(input, attempt, maxAttempts));
+      input.params.trace?.capture(response.traceId);
+      return response;
     } catch (error) {
+      captureAttemptTraceId(input, error);
       if (attempt >= maxAttempts || !input.llm.isRetryableError(error)) {
         logRequestFailure(input, error, attempt, maxAttempts);
         throw error;
@@ -91,6 +103,34 @@ function logRequestFailure(
   });
 }
 
+/**
+ * Surface a failed attempt's trace id through the same early-capture channel
+ * as a successful attempt. A status-error response still carried response
+ * headers, so its `x-trace-id` is available on the converted error; writing
+ * it here (before the failure propagates to the loop's `turn.interrupted`
+ * dispatch) lets turn-level telemetry attribute the turn to the failed
+ * request rather than the previous successful one. Mid-stream failures were
+ * already captured by the attempt's request trace; failures before any
+ * response (network errors, local aborts) keep the attempt-start reset.
+ */
+function captureAttemptTraceId(input: ChatWithRetryInput, error: unknown): void {
+  const statusError = findAPIStatusError(error);
+  if (statusError?.traceId !== null && statusError?.traceId !== undefined) {
+    input.params.trace?.capture(statusError.traceId);
+  }
+}
+
+export function findAPIStatusError(error: unknown): APIStatusError | undefined {
+  let current = error;
+  const visited = new Set<unknown>();
+  while (current !== null && typeof current === 'object' && !visited.has(current)) {
+    if (current instanceof APIStatusError) return current;
+    visited.add(current);
+    current = (current as { cause?: unknown }).cause;
+  }
+  return undefined;
+}
+
 function paramsForAttempt(
   input: ChatWithRetryInput,
   attempt: number,
diff --git a/packages/agent-core/src/loop/run-turn.ts b/packages/agent-core/src/loop/run-turn.ts
index f681e7399..f1a785467 100644
--- a/packages/agent-core/src/loop/run-turn.ts
+++ b/packages/agent-core/src/loop/run-turn.ts
@@ -18,7 +18,7 @@ import {
   isMaxStepsExceededError,
 } from './errors';
 import type { LoopInterruptReason, LoopEventDispatcher, LoopTurnInterruptedEvent } from './events';
-import type { LLM } from './llm';
+import type { LLM, LLMRequestTrace } from './llm';
 import { executeLoopStep } from './turn-step';
 import type {
   ExecutableTool,
@@ -83,6 +83,7 @@ export interface RunTurnInput {
   readonly recordStepUsage?:
     | ((usage: TokenUsage) => RecordStepUsageResult | void | Promise<RecordStepUsageResult | void>)
     | undefined;
+  readonly onRequestTrace?: (trace: LLMRequestTrace) => void;
 }
 
 export async function runTurn(input: RunTurnInput): Promise<TurnResult> {
@@ -103,12 +104,14 @@ export async function runTurn(input: RunTurnInput): Promise<TurnResult> {
     maxSteps,
     maxRetryAttempts,
     recordStepUsage: hostRecordStepUsage,
+    onRequestTrace,
   } = input;
   let usage: TokenUsage = emptyUsage();
   let steps = 0;
   // Normal exits overwrite this with the completed step's stop reason.
   let stopReason: LoopTurnStopReason = 'end_turn';
   let activeStep: number | undefined;
+  let activeRequestTrace: LLMRequestTrace | undefined;
   // Once a step only succeeded via the media-degraded resend, later steps of
   // this turn build from the degraded projection directly: the full-media
   // history is deterministically over the provider's body-size limit, so
@@ -124,6 +127,10 @@ export async function runTurn(input: RunTurnInput): Promise<TurnResult> {
     usage = addUsage(usage, stepUsage);
     return hostRecordStepUsage?.(stepUsage);
   };
+  const captureRequestTrace = (trace: LLMRequestTrace): void => {
+    activeRequestTrace = trace;
+    onRequestTrace?.(trace);
+  };
 
   try {
     while (true) {
@@ -135,6 +142,7 @@ export async function runTurn(input: RunTurnInput): Promise<TurnResult> {
 
       steps += 1;
       activeStep = steps;
+      activeRequestTrace = undefined;
       const stepResult = await executeLoopStep({
         turnId,
         signal,
@@ -166,6 +174,7 @@ export async function runTurn(input: RunTurnInput): Promise<TurnResult> {
         currentStep: steps,
         maxRetryAttempts,
         recordUsage: recordStepUsage,
+        onRequestTrace: captureRequestTrace,
       });
       activeStep = undefined;
       mediaDegradedActive = mediaDegradedActive || stepResult.mediaDegradedResendUsed === true;
@@ -197,11 +206,29 @@ export async function runTurn(input: RunTurnInput): Promise<TurnResult> {
       // programmatic abort so telemetry can tell the two apart.
       const interruptReason =
         isUserCancellation(signal.reason) || isUserCancellation(error) ? 'user_cancelled' : 'aborted';
-      dispatchEvent(makeInterruptedEvent('aborted', steps, activeStep, undefined, interruptReason));
+      dispatchEvent(
+        makeInterruptedEvent(
+          'aborted',
+          steps,
+          activeStep,
+          undefined,
+          interruptReason,
+          activeRequestTrace?.traceId,
+        ),
+      );
       return { stopReason: 'aborted', steps, usage };
     }
     const reason: LoopInterruptReason = isMaxStepsExceededError(error) ? 'max_steps' : 'error';
-    dispatchEvent(makeInterruptedEvent(reason, steps, activeStep, errorMessage(error)));
+    dispatchEvent(
+      makeInterruptedEvent(
+        reason,
+        steps,
+        activeStep,
+        errorMessage(error),
+        reason,
+        activeRequestTrace?.traceId,
+      ),
+    );
     throw error;
   }
 
@@ -214,6 +241,7 @@ function makeInterruptedEvent(
   activeStep: number | undefined,
   message?: string | undefined,
   interruptReason: LoopTurnInterruptedEvent['interruptReason'] = reason,
+  traceId?: string,
 ): LoopTurnInterruptedEvent {
   return {
     type: 'turn.interrupted',
@@ -222,5 +250,6 @@ function makeInterruptedEvent(
     ...(activeStep !== undefined ? { activeStep } : {}),
     ...(message !== undefined ? { message } : {}),
     interruptReason,
+    traceId,
   };
 }
diff --git a/packages/agent-core/src/loop/tool-call.ts b/packages/agent-core/src/loop/tool-call.ts
index 264b4ede5..a90fcdbbc 100644
--- a/packages/agent-core/src/loop/tool-call.ts
+++ b/packages/agent-core/src/loop/tool-call.ts
@@ -28,7 +28,7 @@ import { isUserCancellation } from '../utils/abort';
 import { errorMessage, isAbortError } from './errors';
 import type { LoopEventDispatcher, LoopToolCallEvent } from './events';
 import { parseToolCallArguments } from './tool-args-parse';
-import type { LLM, LLMChatResponse } from './llm';
+import type { LLM, LLMChatResponse, LLMRequestTrace } from './llm';
 import { ToolAccesses } from './tool-access';
 import { ToolScheduler, type ToolCallTask } from './tool-scheduler';
 import type {
@@ -46,6 +46,18 @@ const GRACE_TIMEOUT_MS = 2_000;
 const TOOL_OUTPUT_EMPTY = 'Tool output is empty.';
 const TOOL_OUTPUT_NON_TEXT = 'Tool returned non-text content.';
 
+/**
+ * Output for a tool call the step never executed: the provider stream broke
+ * off (paused / overloaded / token limit), so running the call — whose
+ * arguments may be truncated mid-stream — would be unsafe. The wording tells
+ * the model the call did not run and invites a clean re-issue instead of
+ * assumptions about the outcome.
+ */
+const UNEXECUTED_TOOL_CALL_OUTPUT =
+  'This tool call was not executed: the model response ended before tool execution could start ' +
+  '(the provider stream was interrupted). Do not assume the tool ran — ' +
+  're-issue the call if it is still needed.';
+
 const validators = new WeakMap<ExecutableTool, ToolArgsValidator>();
 
 /**
@@ -73,6 +85,7 @@ export interface ToolCallStepContext {
   readonly turnId: string;
   readonly currentStep: number;
   readonly stepUuid: string;
+  readonly trace: LLMRequestTrace;
 }
 
 interface ToolCallBatchContext extends ToolCallStepContext {
@@ -160,6 +173,7 @@ export async function runToolCallBatch(
         parentUuid: result.toolCall.id,
         toolCallId: result.toolCall.id,
         result: result.result,
+        traceId: step.trace.traceId,
       });
     }
   } finally {
@@ -171,6 +185,53 @@ export async function runToolCallBatch(
   return { stopTurn };
 }
 
+/**
+ * Record tool calls from a response the step will NOT execute: the provider
+ * stream broke off (paused / overloaded / token limit), so running the calls
+ * — whose arguments may be truncated mid-stream — would be unsafe. Dropping
+ * them silently is not an option either: it loses the model's intent and,
+ * when the response carried no other usable content, persists an assistant
+ * message strict providers reject as empty. Each call is recorded with
+ * sanitized arguments (unparseable JSON, e.g. truncated by an interrupted
+ * stream, becomes `{}`) and immediately closed with a synthetic error result,
+ * so the exchange stays wire-valid and the model learns the calls never ran.
+ */
+export async function recordUnexecutedToolCalls(
+  step: ToolCallStepContext,
+  response: LLMChatResponse,
+): Promise<void> {
+  for (const toolCall of response.toolCalls) {
+    const parsedArgs = parseToolCallArguments(toolCall.arguments);
+    if (parsedArgs.parseFailed) {
+      step.log?.debug('recording unexecuted tool call with unparseable arguments', {
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        rawLength: toolCall.arguments?.length ?? 0,
+        error: parsedArgs.error,
+      });
+    }
+    await step.dispatchEvent({
+      type: 'tool.call',
+      uuid: toolCall.id,
+      turnId: step.turnId,
+      step: step.currentStep,
+      stepUuid: step.stepUuid,
+      toolCallId: toolCall.id,
+      name: toolCall.name,
+      args: parsedArgs.data,
+      extras: toolCall.extras,
+      traceId: step.trace.traceId,
+    });
+    await step.dispatchEvent({
+      type: 'tool.result',
+      parentUuid: toolCall.id,
+      toolCallId: toolCall.id,
+      result: { output: UNEXECUTED_TOOL_CALL_OUTPUT, isError: true },
+      traceId: step.trace.traceId,
+    });
+  }
+}
+
 /**
  * Provider-order validation pass. It does not run hooks, spawn tools, or write
  * events. Validator compilation may populate the local cache.
@@ -368,6 +429,7 @@ async function runPrepareToolExecutionHook(
       args,
       turnId,
       stepNumber: currentStep,
+      traceId: step.trace.traceId,
       signal,
       llm,
     });
@@ -422,6 +484,7 @@ async function runAuthorizeToolExecutionHook(
       execution,
       turnId,
       stepNumber: currentStep,
+      traceId: step.trace.traceId,
       signal,
       llm,
     });
@@ -504,6 +567,7 @@ async function finalizePendingToolResult(
       result: pendingResult.result,
       turnId,
       stepNumber: currentStep,
+      traceId: step.trace.traceId,
       signal,
       llm,
     });
@@ -552,6 +616,7 @@ async function executeTool(
   const executePromise = execution.execute({
     turnId,
     toolCallId: toolCall.id,
+    traceId: step.trace.traceId,
     metadata,
     signal,
     onUpdate: (update) => {
@@ -723,5 +788,6 @@ async function dispatchToolCall(
     description: displayFields?.description,
     display: displayFields?.display,
     extras: toolCall.extras,
+    traceId: step.trace.traceId,
   });
 }
diff --git a/packages/agent-core/src/loop/turn-step.ts b/packages/agent-core/src/loop/turn-step.ts
index ca110a408..2890cab7e 100644
--- a/packages/agent-core/src/loop/turn-step.ts
+++ b/packages/agent-core/src/loop/turn-step.ts
@@ -19,9 +19,15 @@ import type { Logger } from '#/logging/types';
 
 import type { LoopEventDispatcher } from './events';
 import { errorMessage } from './errors';
-import type { LLM, LLMChatParams, LLMChatResponse } from './llm';
+import {
+  LLMRequestTraceState,
+  type LLM,
+  type LLMChatParams,
+  type LLMChatResponse,
+  type LLMRequestTrace,
+} from './llm';
 import { chatWithRetry } from './retry';
-import { runToolCallBatch, type ToolCallStepContext } from './tool-call';
+import { recordUnexecutedToolCalls, runToolCallBatch, type ToolCallStepContext } from './tool-call';
 import type {
   ExecutableTool,
   LoopHooks,
@@ -67,6 +73,7 @@ export interface ExecuteLoopStepDeps {
   readonly currentStep: number;
   readonly maxRetryAttempts?: number;
   readonly recordUsage: (usage: TokenUsage) => RecordStepUsageResult | void | Promise<RecordStepUsageResult | void>;
+  readonly onRequestTrace?: (trace: LLMRequestTrace) => void;
 }
 
 export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
@@ -105,6 +112,7 @@ export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
     currentStep,
     maxRetryAttempts,
     recordUsage,
+    onRequestTrace,
   } = deps;
 
   if (hooks?.beforeStep !== undefined) {
@@ -130,6 +138,7 @@ export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
   signal.throwIfAborted();
 
   const stepUuid = randomUUID();
+  const trace = new LLMRequestTraceState();
 
   const step: ToolCallStepContext = {
     tools: stepTools,
@@ -142,6 +151,7 @@ export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
     turnId,
     currentStep,
     stepUuid,
+    trace,
   };
 
   await dispatchEvent({
@@ -150,6 +160,7 @@ export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
     turnId,
     step: currentStep,
   });
+  onRequestTrace?.(trace);
 
   const chatParams: LLMChatParams = {
     messages,
@@ -159,6 +170,7 @@ export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
       initialMediaProjection === 'normal'
         ? undefined
         : { projection: initialMediaProjection },
+    trace,
     ...createChatStreamingCallbacks({
       dispatchEvent,
       turnId,
@@ -391,6 +403,19 @@ export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
   if (effectiveStopReason === 'tool_use') {
     const toolBatch = await runToolCallBatch(step, response);
     if (toolBatch.stopTurn) effectiveStopReason = 'end_turn';
+  } else if (
+    (stopReason === 'paused' || stopReason === 'unknown' || stopReason === 'max_tokens') &&
+    response.toolCalls.length > 0
+  ) {
+    // The provider stream broke off (paused / overloaded / token limit) while
+    // the response still carries tool calls — possibly cut off mid-arguments.
+    // Record each call and close it with a synthetic interrupted result:
+    // dropping them would lose the model's intent and can persist an
+    // assistant message strict providers reject as empty. Filtered responses
+    // keep their existing behavior (calls vanish): persisting flagged content
+    // risks re-triggering the filter on every resend, and a well-formed
+    // tool_use response stopped by usage recording keeps its skip behavior.
+    await recordUnexecutedToolCalls(step, response);
   }
 
   // When a tool batch runs, it drains paired `tool.result` events even when
@@ -411,6 +436,7 @@ export async function executeLoopStep(deps: ExecuteLoopStepDeps): Promise<{
     llmServerDecodeMs: response.streamTiming?.serverDecodeMs,
     llmClientConsumeMs: response.streamTiming?.clientConsumeMs,
     messageId: response.messageId,
+    traceId: response.traceId,
     ...stepEndProviderDiagnostics(response, effectiveStopReason),
   });
 
diff --git a/packages/agent-core/src/loop/types.ts b/packages/agent-core/src/loop/types.ts
index 63810fbb0..3d361552b 100644
--- a/packages/agent-core/src/loop/types.ts
+++ b/packages/agent-core/src/loop/types.ts
@@ -125,6 +125,7 @@ export interface ToolUpdate {
 export interface ExecutableToolContext {
   readonly turnId: string;
   readonly toolCallId: string;
+  readonly traceId?: string;
   readonly metadata?: unknown;
   readonly signal: AbortSignal;
   readonly onUpdate?: ((update: ToolUpdate) => void) | undefined;
@@ -170,6 +171,7 @@ export interface LoopStepHookContext {
 }
 
 export interface ToolExecutionHookContext extends LoopStepHookContext {
+  readonly traceId?: string;
   readonly toolCall: ToolCall;
   readonly toolCalls: readonly ToolCall[];
   readonly tool?: ExecutableTool | undefined;
diff --git a/packages/agent-core/src/mcp/client-stdio.ts b/packages/agent-core/src/mcp/client-stdio.ts
index 9810bc0e9..998bd7ba0 100644
--- a/packages/agent-core/src/mcp/client-stdio.ts
+++ b/packages/agent-core/src/mcp/client-stdio.ts
@@ -3,6 +3,7 @@ import type { McpServerStdioConfig } from '#/config/schema';
 import { proxyEnvForChild, reconcileChildNoProxy } from '#/utils/proxy';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { win32 } from 'node:path';
 import { isAbsolute, resolve } from 'pathe';
 
 import {
@@ -218,12 +219,22 @@ class BoundedTail {
   }
 }
 
-function resolveStdioCwd(configCwd: string | undefined, defaultCwd: string | undefined): string | undefined {
+export function resolveStdioCwd(configCwd: string | undefined, defaultCwd: string | undefined): string | undefined {
   if (configCwd === undefined) return defaultCwd;
+  if (defaultCwd !== undefined && isWindowsAbsolutePath(defaultCwd)) {
+    return win32.resolve(defaultCwd, configCwd).replaceAll('\\', '/');
+  }
+  if (isWindowsAbsolutePath(configCwd)) {
+    return win32.resolve(configCwd).replaceAll('\\', '/');
+  }
   if (defaultCwd !== undefined && !isAbsolute(configCwd)) return resolve(defaultCwd, configCwd);
   return configCwd;
 }
 
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || /^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(value);
+}
+
 // Inherit the parent's env so PATH/HOME/etc. survive — otherwise `npx`/`uvx`
 // style stdio servers fail to launch even with a valid config. `config.env`
 // overrides on conflict. A node child does not inherit our in-process undici
diff --git a/packages/agent-core/src/mcp/config-loader.ts b/packages/agent-core/src/mcp/config-loader.ts
index 26cd8a7ee..2500acfcd 100644
--- a/packages/agent-core/src/mcp/config-loader.ts
+++ b/packages/agent-core/src/mcp/config-loader.ts
@@ -1,4 +1,5 @@
 import { readFile, stat } from 'node:fs/promises';
+import { win32 } from 'node:path';
 import { dirname, isAbsolute, join, normalize, resolve } from 'pathe';
 
 import { resolveKimiHome } from '#/config/path';
@@ -138,9 +139,19 @@ function normalizeStdioCwd(config: McpServerConfig, cwdBase: string): McpServerC
 }
 
 function resolvePath(base: string, value: string): string {
+  if (isWindowsAbsolutePath(base)) {
+    return win32.resolve(base, value).replaceAll('\\', '/');
+  }
+  if (isWindowsAbsolutePath(value)) {
+    return win32.resolve(value).replaceAll('\\', '/');
+  }
   return isAbsolute(value) ? normalize(value) : resolve(base, value);
 }
 
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || /^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(value);
+}
+
 function isFileNotFound(error: unknown): boolean {
   return getErrorCode(error) === 'ENOENT';
 }
diff --git a/packages/agent-core/src/mcp/connection-manager.ts b/packages/agent-core/src/mcp/connection-manager.ts
index a9bc5e447..258c19107 100644
--- a/packages/agent-core/src/mcp/connection-manager.ts
+++ b/packages/agent-core/src/mcp/connection-manager.ts
@@ -386,7 +386,7 @@ export class McpConnectionManager {
     // rather than hijacking them into the OAuth flow — the real error is more
     // actionable than "run /mcp-config login" for a server that doesn't speak
     // OAuth.
-    if (entry.config.headers !== undefined) return false;
+    if (entry.config.headers !== undefined && entry.config.auth !== 'oauth') return false;
     return isUnauthorizedLikeError(error);
   }
 
diff --git a/packages/agent-core/src/mcp/global-config.ts b/packages/agent-core/src/mcp/global-config.ts
new file mode 100644
index 000000000..99ca3add7
--- /dev/null
+++ b/packages/agent-core/src/mcp/global-config.ts
@@ -0,0 +1,165 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'pathe';
+
+import { resolveKimiHome } from '#/config/path';
+import { McpServerConfigSchema, type McpServerConfig } from '#/config/schema';
+import { ErrorCodes, KimiError } from '#/errors';
+import { atomicWrite } from '#/utils/fs';
+
+export type GlobalMcpServerConfig = McpServerConfig & { readonly name: string };
+
+interface GlobalMcpConfigFile {
+  readonly raw: Record<string, unknown>;
+  readonly rawServers: Record<string, unknown>;
+  readonly servers: readonly GlobalMcpServerConfig[];
+}
+
+export class GlobalMcpConfigStore {
+  readonly path: string;
+
+  constructor(homeDir?: string) {
+    this.path = join(resolveKimiHome(homeDir), 'mcp.json');
+  }
+
+  async list(): Promise<readonly GlobalMcpServerConfig[]> {
+    return (await this.read()).servers;
+  }
+
+  async get(name: string): Promise<GlobalMcpServerConfig> {
+    const normalizedName = normalizeServerName(name);
+    const server = (await this.read()).servers.find((entry) => entry.name === normalizedName);
+    if (server !== undefined) return server;
+    throw serverNotFound(normalizedName);
+  }
+
+  async add(server: GlobalMcpServerConfig): Promise<readonly GlobalMcpServerConfig[]> {
+    const normalized = parseServerInput(server);
+    const file = await this.read();
+    if (Object.hasOwn(file.rawServers, normalized.name)) {
+      throw new KimiError(
+        ErrorCodes.REQUEST_INVALID,
+        `MCP server "${normalized.name}" already exists`,
+      );
+    }
+    await this.write(file, {
+      ...file.rawServers,
+      [normalized.name]: persistedEntry(normalized),
+    });
+    return this.list();
+  }
+
+  async update(server: GlobalMcpServerConfig): Promise<readonly GlobalMcpServerConfig[]> {
+    const normalized = parseServerInput(server);
+    const file = await this.read();
+    if (!Object.hasOwn(file.rawServers, normalized.name)) {
+      throw serverNotFound(normalized.name);
+    }
+    await this.write(file, {
+      ...file.rawServers,
+      [normalized.name]: persistedEntry(normalized),
+    });
+    return this.list();
+  }
+
+  async remove(name: string): Promise<readonly GlobalMcpServerConfig[]> {
+    const normalizedName = normalizeServerName(name);
+    const file = await this.read();
+    if (!Object.hasOwn(file.rawServers, normalizedName)) return file.servers;
+    const nextServers = Object.fromEntries(
+      Object.entries(file.rawServers).filter(([entryName]) => entryName !== normalizedName),
+    );
+    await this.write(file, nextServers);
+    return this.list();
+  }
+
+  private async read(): Promise<GlobalMcpConfigFile> {
+    let text: string;
+    try {
+      text = await readFile(this.path, 'utf-8');
+    } catch (error: unknown) {
+      if (errorCode(error) === 'ENOENT') {
+        return { raw: {}, rawServers: {}, servers: [] };
+      }
+      throw configError(`Failed to read ${this.path}: ${describeError(error)}`, error);
+    }
+
+    if (text.trim().length === 0) {
+      return { raw: {}, rawServers: {}, servers: [] };
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(text) as unknown;
+    } catch (error: unknown) {
+      throw configError(`Invalid JSON in ${this.path}: ${describeError(error)}`, error);
+    }
+    if (!isRecord(parsed)) {
+      throw configError(`Invalid MCP config in ${this.path}: expected a JSON object`);
+    }
+    const rawServersValue = parsed['mcpServers'];
+    if (rawServersValue !== undefined && !isRecord(rawServersValue)) {
+      throw configError(`Invalid MCP config in ${this.path}: "mcpServers" must be an object`);
+    }
+    const rawServers = rawServersValue ?? {};
+    const servers = Object.entries(rawServers).map(([name, value]) => parseServer(name, value));
+    return { raw: parsed, rawServers, servers };
+  }
+
+  private async write(
+    file: GlobalMcpConfigFile,
+    rawServers: Record<string, unknown>,
+  ): Promise<void> {
+    await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+    await atomicWrite(
+      this.path,
+      `${JSON.stringify({ ...file.raw, mcpServers: rawServers }, null, 2)}\n`,
+    );
+  }
+}
+
+function parseServerInput(server: GlobalMcpServerConfig): GlobalMcpServerConfig {
+  return parseServer(normalizeServerName(server.name), server);
+}
+
+function parseServer(name: string, value: unknown): GlobalMcpServerConfig {
+  const result = McpServerConfigSchema.safeParse(value);
+  if (!result.success) {
+    throw configError(
+      `Invalid MCP server "${name}" in global config: ${result.error.message}`,
+      result.error,
+    );
+  }
+  return { name, ...result.data };
+}
+
+function persistedEntry(server: GlobalMcpServerConfig): McpServerConfig {
+  const { name: _name, ...entry } = server;
+  return entry;
+}
+
+function normalizeServerName(name: string): string {
+  const normalized = name.trim();
+  if (normalized.length > 0) return normalized;
+  throw new KimiError(ErrorCodes.REQUEST_INVALID, 'MCP server name cannot be empty');
+}
+
+function serverNotFound(name: string): KimiError {
+  return new KimiError(ErrorCodes.MCP_SERVER_NOT_FOUND, `MCP server "${name}" was not found`);
+}
+
+function configError(message: string, cause?: unknown): KimiError {
+  return new KimiError(ErrorCodes.CONFIG_INVALID, message, { cause });
+}
+
+function errorCode(error: unknown): unknown {
+  if (!isRecord(error)) return undefined;
+  return error['code'];
+}
+
+function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
diff --git a/packages/agent-core/src/mcp/index.ts b/packages/agent-core/src/mcp/index.ts
index d0fef23f6..c49777076 100644
--- a/packages/agent-core/src/mcp/index.ts
+++ b/packages/agent-core/src/mcp/index.ts
@@ -1,4 +1,5 @@
 export * from './connection-manager';
+export * from './global-config';
 export * from './oauth';
 export * from './session-config';
 export * from './tool-naming';
diff --git a/packages/agent-core/src/profile/default/coder.yaml b/packages/agent-core/src/profile/default/coder.yaml
index 90584f311..b439ce8ec 100644
--- a/packages/agent-core/src/profile/default/coder.yaml
+++ b/packages/agent-core/src/profile/default/coder.yaml
@@ -8,13 +8,25 @@ promptVars:
 whenToUse: |
   Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.
 tools:
+  - Agent
+  - AgentSwarm
   - Bash
-  - Read
-  - ReadMediaFile
+  - CronCreate
+  - CronDelete
+  - CronList
+  - Edit
+  - EnterPlanMode
+  - ExitPlanMode
   - Glob
   - Grep
-  - Write
-  - Edit
+  - Read
+  - ReadMediaFile
+  - Skill
+  - TaskList
+  - TaskOutput
+  - TaskStop
+  - TodoList
   - WebSearch
   - FetchURL
+  - Write
   - mcp__*
diff --git a/packages/agent-core/src/rpc/core-api.ts b/packages/agent-core/src/rpc/core-api.ts
index 8bef899e0..ec6d825f5 100644
--- a/packages/agent-core/src/rpc/core-api.ts
+++ b/packages/agent-core/src/rpc/core-api.ts
@@ -19,6 +19,7 @@ import type { KimiConfig, KimiConfigPatch, McpServerConfig } from '#/config';
 import type { ExperimentalFeatureState } from '#/flags';
 import type { ResumeSessionResult } from '#/rpc/resumed';
 import type { SessionMeta } from '#/session';
+import type { GlobalMcpServerConfig } from '#/mcp/global-config';
 import type { ContentPart } from '@moonshot-ai/kosong';
 import type { SessionWarning } from '@moonshot-ai/protocol';
 
@@ -42,7 +43,7 @@ export type PromptPart = Extract<ContentPart, { type: 'text' | 'image_url' | 'vi
 export type PromptInput = readonly PromptPart[];
 
 export type EmptyPayload = {};
-export type SessionMetadataPatch = Partial<Omit<SessionMeta, 'agents'>>;
+export type SessionMetadataPatch = Partial<Omit<SessionMeta, 'agents' | 'additionalDirs'>>;
 
 export interface ClientTelemetryInfo {
   readonly id?: string | undefined;
@@ -72,10 +73,16 @@ export interface ArchiveSessionPayload {
   readonly sessionId: string;
 }
 
+export interface DeleteSessionPayload {
+  readonly sessionId: string;
+}
+
 export interface ResumeSessionPayload {
   readonly sessionId: string;
   readonly mcpServers?: Readonly<Record<string, McpServerConfig>>;
   readonly additionalDirs?: readonly string[];
+  /** Include persisted subagent states in the returned replay snapshot. */
+  readonly includeSubagents?: boolean;
 }
 
 export interface ReloadSessionPayload {
@@ -94,6 +101,11 @@ export interface ForkSessionPayload {
   readonly id?: string;
   readonly title?: string;
   readonly metadata?: JsonObject;
+  /**
+   * Zero-based index of the user-visible turn to retain through. When omitted,
+   * the complete session is copied (the existing fork behavior).
+   */
+  readonly turnIndex?: number;
 }
 
 export interface ShellEnvironment {
@@ -227,6 +239,12 @@ export interface BeginCompactionPayload {
 export interface UndoHistoryPayload {
   readonly count: number;
 }
+export interface ImportContextPayload {
+  /** Raw text supplied by the host. Core does not perform file I/O. */
+  readonly content: string;
+  /** User-facing description of the source, for example `file 'notes.md'`. */
+  readonly source: string;
+}
 export interface RegisterToolPayload {
   readonly name: string;
   readonly description: string;
@@ -301,6 +319,43 @@ export interface ReconnectMcpServerPayload {
   readonly name: string;
 }
 
+export type { GlobalMcpServerConfig } from '#/mcp/global-config';
+
+export interface PutGlobalMcpServerPayload {
+  readonly server: GlobalMcpServerConfig;
+}
+
+export interface GlobalMcpServerNamePayload {
+  readonly name: string;
+}
+
+export type BeginGlobalMcpServerAuthResult =
+  | { readonly status: 'already-authorized' }
+  | {
+      readonly status: 'authorization-required';
+      readonly flowId: string;
+      readonly authorizationUrl: string;
+    };
+
+export interface CompleteGlobalMcpServerAuthPayload {
+  readonly flowId: string;
+  readonly timeoutMs?: number;
+}
+
+export interface CancelGlobalMcpServerAuthPayload {
+  readonly flowId: string;
+}
+
+export interface TestGlobalMcpServerPayload {
+  readonly name: string;
+  readonly cwd?: string;
+}
+
+export interface GlobalMcpServerTestResult {
+  readonly success: boolean;
+  readonly output: string;
+}
+
 export interface InstallPluginPayload {
   readonly source: string;
 }
@@ -410,6 +465,7 @@ export interface AgentAPI {
   stopBackground: (payload: StopBackgroundPayload) => void;
   detachBackground: (payload: DetachBackgroundPayload) => BackgroundTaskInfo | undefined;
   clearContext: (payload: EmptyPayload) => void;
+  importContext: (payload: ImportContextPayload) => void;
   activateSkill: (payload: ActivateSkillPayload) => void;
   activatePluginCommand: (payload: ActivatePluginCommandPayload) => void;
   startBtw: (payload: EmptyPayload) => string;
@@ -456,9 +512,21 @@ export interface CoreAPI extends SessionAPIWithId {
   getConfigDiagnostics: (payload: EmptyPayload) => ConfigDiagnostics;
   setKimiConfig: (payload: SetKimiConfigPayload) => KimiConfig;
   removeKimiProvider: (payload: RemoveKimiProviderPayload) => KimiConfig;
+  listGlobalMcpServers: (payload: EmptyPayload) => readonly GlobalMcpServerConfig[];
+  addGlobalMcpServer: (payload: PutGlobalMcpServerPayload) => readonly GlobalMcpServerConfig[];
+  updateGlobalMcpServer: (payload: PutGlobalMcpServerPayload) => readonly GlobalMcpServerConfig[];
+  removeGlobalMcpServer: (payload: GlobalMcpServerNamePayload) => readonly GlobalMcpServerConfig[];
+  beginGlobalMcpServerAuth: (
+    payload: GlobalMcpServerNamePayload,
+  ) => BeginGlobalMcpServerAuthResult;
+  completeGlobalMcpServerAuth: (payload: CompleteGlobalMcpServerAuthPayload) => void;
+  cancelGlobalMcpServerAuth: (payload: CancelGlobalMcpServerAuthPayload) => void;
+  resetGlobalMcpServerAuth: (payload: GlobalMcpServerNamePayload) => void;
+  testGlobalMcpServer: (payload: TestGlobalMcpServerPayload) => GlobalMcpServerTestResult;
   createSession: (payload: CreateSessionPayload) => SessionSummary;
   closeSession: (payload: CloseSessionPayload) => void;
   archiveSession: (payload: ArchiveSessionPayload) => void;
+  deleteSession: (payload: DeleteSessionPayload) => void;
   resumeSession: (payload: ResumeSessionPayload) => ResumeSessionResult;
   reloadSession: (payload: ReloadSessionPayload) => ResumeSessionResult;
   forkSession: (payload: ForkSessionPayload) => ResumeSessionResult;
diff --git a/packages/agent-core/src/rpc/core-impl.ts b/packages/agent-core/src/rpc/core-impl.ts
index 2b12ad013..cee495263 100644
--- a/packages/agent-core/src/rpc/core-impl.ts
+++ b/packages/agent-core/src/rpc/core-impl.ts
@@ -13,6 +13,7 @@ import { getCoreVersion } from '#/version';
 import { resolveThinkingEffort } from '../agent/config/thinking';
 import { Agent } from '../agent';
 import {
+  applyPrintModeConfigDefaults,
   ensureKimiHome,
   loadRuntimeConfigSafe,
   mergeConfigPatch,
@@ -24,6 +25,7 @@ import {
   resolveKimiHome,
   writeConfigFile,
   type KimiConfig,
+  type McpRemoteServerConfig,
   type McpServerConfig,
   type MoonshotServiceConfig,
 } from '../config';
@@ -33,7 +35,16 @@ import {
   type ExperimentalFeatureState,
 } from '../flags';
 import type { Logger } from '../logging/types';
-import { resolveSessionMcpConfig, mergeCallerMcpServers, type SessionMcpConfig } from '../mcp';
+import {
+  AlreadyAuthorizedError,
+  GlobalMcpConfigStore,
+  McpConnectionManager,
+  McpOAuthService,
+  resolveSessionMcpConfig,
+  mergeCallerMcpServers,
+  type BeginAuthorizationResult,
+  type SessionMcpConfig,
+} from '../mcp';
 import { Session, type SessionMeta, type SessionSkillConfig } from '../session';
 import { exportSessionDirectory } from '../session/export';
 import {
@@ -48,6 +59,7 @@ import {
 } from '../session/provider-manager';
 import { SessionAPIImpl } from '../session/rpc';
 import { normalizeWorkDir, SessionStore } from '../session/store/index';
+import { touchWorkspaceRegistry } from '../session/store/workspace-registry-file';
 import {
   noopTelemetryClient,
   withTelemetryContext,
@@ -62,22 +74,29 @@ import type {
   AddAdditionalDirPayload,
   AddAdditionalDirResult,
   ArchiveSessionPayload,
+  BeginGlobalMcpServerAuthResult,
   BeginCompactionPayload,
+  CancelGlobalMcpServerAuthPayload,
   CancelPayload,
   CancelPlanPayload,
   CancelShellCommandPayload,
   CloseSessionPayload,
+  CompleteGlobalMcpServerAuthPayload,
   ConfigDiagnostics,
   CoreAPI,
   CoreInfo,
   CreateGoalPayload,
   CreateSessionPayload,
+  DeleteSessionPayload,
   DetachBackgroundPayload,
   ClientTelemetryInfo,
   EmptyPayload,
   EnterSwarmPayload,
   GoalSnapshot,
   GoalToolResult,
+  GlobalMcpServerConfig,
+  GlobalMcpServerNamePayload,
+  GlobalMcpServerTestResult,
   ExportSessionPayload,
   ExportSessionResult,
   ForkSessionPayload,
@@ -87,6 +106,7 @@ import type {
   GetKimiConfigPayload,
   GetPluginInfoPayload,
   InstallPluginPayload,
+  ImportContextPayload,
   ListSessionsPayload,
   ListWorkspaceSkillsPayload,
   McpServerInfo,
@@ -94,6 +114,7 @@ import type {
   PluginInfo,
   PluginSummary,
   PromptPayload,
+  PutGlobalMcpServerPayload,
   RunShellCommandPayload,
   ReconnectMcpServerPayload,
   RegisterToolPayload,
@@ -116,6 +137,7 @@ import type {
   PluginCommandDef,
   SteerPayload,
   StopBackgroundPayload,
+  TestGlobalMcpServerPayload,
   UndoHistoryPayload,
   UnregisterToolPayload,
   UpdateSessionMetadataPayload,
@@ -131,11 +153,15 @@ const KIMI_CODE_PROVIDER_NAME = 'managed:kimi-code';
 const KIMI_CODE_BASE_URL_ENV = 'KIMI_CODE_BASE_URL';
 const KIMI_CODE_OAUTH_HOST_ENV = 'KIMI_CODE_OAUTH_HOST';
 const KIMI_OAUTH_HOST_ENV = 'KIMI_OAUTH_HOST';
+const DEFAULT_GLOBAL_MCP_AUTH_TIMEOUT_MS = 15 * 60 * 1000;
 type AgentScopedPayload<T> = T & { readonly agentId: string };
 type SessionScopedPayload<T> = T & { readonly sessionId: string };
 type SessionAgentPayload<T> = SessionScopedPayload<AgentScopedPayload<T>>;
 type RenameSessionRequest = SessionScopedPayload<RenameSessionPayload>;
 type UpdateSessionMetadataRequest = SessionScopedPayload<UpdateSessionMetadataPayload>;
+interface GlobalMcpOAuthFlow {
+  readonly flow: BeginAuthorizationResult;
+}
 
 export interface KimiCoreOptions {
   readonly homeDir?: string | undefined;
@@ -146,6 +172,12 @@ export interface KimiCoreOptions {
   readonly skillDirs?: readonly string[];
   readonly telemetry?: TelemetryClient | undefined;
   readonly appVersion?: string;
+  /**
+   * Host UI mode (`'print'` for `kimi -p`, `'cli'` for the TUI, ...). When
+   * `'print'`, sessions are created with the print-mode config defaults from
+   * `applyPrintModeConfigDefaults` (user-set values still win).
+   */
+  readonly uiMode?: string | undefined;
 }
 
 export class KimiCore implements PromisableMethods<CoreAPI> {
@@ -165,11 +197,16 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
   private readonly resolveOAuthTokenProvider: OAuthTokenProviderResolver | undefined;
   private readonly skillDirs: readonly string[];
   private readonly sessionStore: SessionStore;
+  private readonly globalMcpConfig: GlobalMcpConfigStore;
+  private readonly globalMcpOAuth: McpOAuthService;
+  private readonly globalMcpOAuthFlows = new Map<string, GlobalMcpOAuthFlow>();
   readonly plugins: PluginManager;
   private pluginsReady: Promise<void>;
   private pluginsLoadError: Error | undefined;
   private readonly appVersion: string | undefined;
   private readonly experimentalFlags: FlagResolver;
+  /** `true` when the host runs `kimi -p` (v1 print mode); see `withPrintModeDefaults`. */
+  private readonly printMode: boolean;
   /** Owner-scoped [image] limits; reload pushes the new config via setConfig. */
   readonly imageLimits: ImageLimits;
 
@@ -190,6 +227,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     this.skillDirs = options.skillDirs ?? [];
     this.telemetry = options.telemetry ?? noopTelemetryClient;
     this.appVersion = options.appVersion;
+    this.printMode = options.uiMode === 'print';
     ensureKimiHome(this.homeDir);
     // Schema errors degrade (invalid sections are dropped with warnings) so a
     // typo cannot prevent startup, but a file that cannot be used at all —
@@ -211,6 +249,8 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     );
     this.imageLimits = new ImageLimits(process.env, this.config.image);
     this.sessionStore = new SessionStore(this.homeDir);
+    this.globalMcpConfig = new GlobalMcpConfigStore(this.homeDir);
+    this.globalMcpOAuth = new McpOAuthService({ kimiHomeDir: this.homeDir });
     this.plugins = new PluginManager({ kimiHomeDir: this.homeDir });
     // Capture the error rather than swallow it: mutators and explicit /plugins
     // reads rethrow so the user sees what's wrong; createSession/resumeSession
@@ -235,10 +275,19 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     const options = input;
     const workDir = requiredWorkDir('createSession', options.workDir);
     const config = this.reloadProviderManager();
+    const sessionConfig = this.withPrintModeDefaults(config);
     const id = options.id ?? createSessionId();
     const modelAlias = options.model ?? config.defaultModel;
     const model = modelAlias !== undefined ? config.models?.[modelAlias] : undefined;
-    const thinkingEffort = resolveThinkingEffort(options.thinking, config.thinking, model);
+    // Forward only an explicitly requested effort. With no explicit value the
+    // initial effort is left to ConfigState.update(), which resolves it from
+    // the resolved provider — that carries the provider-level protocol context
+    // a raw model alias lacks (e.g. provider type "anthropic" with a custom
+    // model name must default to the inferred profile effort, not "off").
+    const thinkingEffort =
+      options.thinking === undefined
+        ? undefined
+        : resolveThinkingEffort(options.thinking, config.thinking, model);
     const permissionMode = options.permission ?? config.defaultPermissionMode;
     const baseMcpConfig = await resolveSessionMcpConfig({
       cwd: workDir,
@@ -268,6 +317,12 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       id,
       workDir,
     });
+    // Register the cwd in the shared workspaces catalog (`<homeDir>/workspaces.json`,
+    // also read by the agent-core-v2 server) so TUI-created sessions surface as
+    // workspaces. Best-effort: the catalog is a hint, never session state.
+    await touchWorkspaceRegistry(this.homeDir, workDir).catch((error: unknown) => {
+      log.warn('workspace registry touch failed', { workDir, error: String(error) });
+    });
     const result: SessionSummary = {
       ...summary,
       metadata: options.metadata,
@@ -291,13 +346,13 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       kaos: parentKaos.withCwd(workDir),
       persistenceKaos,
       toolServices: runtime,
-      config,
+      config: sessionConfig,
       id,
       homedir: summary.sessionDir,
       kimiHomeDir: this.homeDir,
       rpc: proxyWithExtraPayload(await this.sdk, { sessionId: summary.id }),
       providerManager: this.resolveProviderManager(summary.id),
-      background: config.background,
+      background: sessionConfig.background,
       hooks: [...(config.hooks ?? []), ...this.plugins.enabledHooks()],
       permissionRules: config.permission?.rules,
       skills: this.resolveSessionSkillConfig(config),
@@ -372,6 +427,11 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     await this.sessionStore.archive(sessionId);
   }
 
+  async deleteSession({ sessionId }: DeleteSessionPayload): Promise<void> {
+    await this.closeSession({ sessionId });
+    await this.sessionStore.delete(sessionId);
+  }
+
   async resumeSession(input: ResumeSessionPayload): Promise<ResumeSessionResult> {
     return this.resumeSessionWithOverrides(input, {});
   }
@@ -406,11 +466,15 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       if (overrides.kaos !== undefined) {
         active.setToolKaos(overrides.kaos.withCwd(summary.workDir));
       }
-      await active.setAdditionalDirs(additionalDirs);
-      return withAdditionalDirs(await resumeSessionResult(summary, active), active);
+      await active.setBaseAdditionalDirs(additionalDirs);
+      return withAdditionalDirs(
+        await resumeSessionResult(summary, active, undefined, input.includeSubagents),
+        active,
+      );
     }
 
     const config = this.reloadProviderManager();
+    const sessionConfig = this.withPrintModeDefaults(config);
     const baseMcpConfig = await resolveSessionMcpConfig({
       cwd: summary.workDir,
       homeDir: this.homeDir,
@@ -427,13 +491,13 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       kaos: parentKaos.withCwd(summary.workDir),
       persistenceKaos,
       toolServices: runtime,
-      config,
+      config: sessionConfig,
       id: summary.id,
       homedir: summary.sessionDir,
       kimiHomeDir: this.homeDir,
       rpc: proxyWithExtraPayload(await this.sdk, { sessionId: summary.id }),
       providerManager: this.resolveProviderManager(summary.id),
-      background: config.background,
+      background: sessionConfig.background,
       hooks: [...(config.hooks ?? []), ...this.plugins.enabledHooks()],
       permissionRules: config.permission?.rules,
       skills: this.resolveSessionSkillConfig(config),
@@ -465,7 +529,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       // (and any SDK caller's resumeState) reflects the refreshed plugin context.
       await session.appendPluginSessionStartReminder();
     }
-    return resumeSessionResult(summary, session, warning);
+    return resumeSessionResult(summary, session, warning, input.includeSubagents);
   }
 
   async reloadSession(input: ReloadSessionPayload): Promise<ResumeSessionResult> {
@@ -514,6 +578,7 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
       targetId: id,
       title: input.title,
       metadata: input.metadata,
+      turnIndex: input.turnIndex,
     });
     return this.resumeSession({ sessionId: id });
   }
@@ -610,6 +675,100 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     return this.reloadRuntimeConfig();
   }
 
+  async listGlobalMcpServers(_input?: EmptyPayload): Promise<readonly GlobalMcpServerConfig[]> {
+    return this.globalMcpConfig.list();
+  }
+
+  async addGlobalMcpServer(
+    { server }: PutGlobalMcpServerPayload,
+  ): Promise<readonly GlobalMcpServerConfig[]> {
+    return this.globalMcpConfig.add(server);
+  }
+
+  async updateGlobalMcpServer(
+    { server }: PutGlobalMcpServerPayload,
+  ): Promise<readonly GlobalMcpServerConfig[]> {
+    return this.globalMcpConfig.update(server);
+  }
+
+  async removeGlobalMcpServer(
+    { name }: GlobalMcpServerNamePayload,
+  ): Promise<readonly GlobalMcpServerConfig[]> {
+    return this.globalMcpConfig.remove(name);
+  }
+
+  async beginGlobalMcpServerAuth(
+    { name }: GlobalMcpServerNamePayload,
+  ): Promise<BeginGlobalMcpServerAuthResult> {
+    const server = await this.globalMcpConfig.get(name);
+    const config = requireOAuthMcpServer(server);
+    try {
+      const flow = await this.globalMcpOAuth.beginAuthorization(server.name, config.url);
+      const flowId = randomUUID();
+      this.globalMcpOAuthFlows.set(flowId, { flow });
+      return {
+        status: 'authorization-required',
+        flowId,
+        authorizationUrl: flow.authorizationUrl.toString(),
+      };
+    } catch (error) {
+      if (error instanceof AlreadyAuthorizedError) {
+        return { status: 'already-authorized' };
+      }
+      throw error;
+    }
+  }
+
+  async completeGlobalMcpServerAuth(
+    { flowId, timeoutMs }: CompleteGlobalMcpServerAuthPayload,
+    options: { readonly signal?: AbortSignal } = {},
+  ): Promise<void> {
+    const active = this.globalMcpOAuthFlows.get(flowId);
+    if (active === undefined) {
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, `Unknown MCP OAuth flow: ${flowId}`);
+    }
+    try {
+      await active.flow.complete({
+        signal: options.signal,
+        timeoutMs: timeoutMs ?? DEFAULT_GLOBAL_MCP_AUTH_TIMEOUT_MS,
+      });
+    } finally {
+      this.globalMcpOAuthFlows.delete(flowId);
+    }
+  }
+
+  async cancelGlobalMcpServerAuth(
+    { flowId }: CancelGlobalMcpServerAuthPayload,
+  ): Promise<void> {
+    const active = this.globalMcpOAuthFlows.get(flowId);
+    if (active === undefined) return;
+    this.globalMcpOAuthFlows.delete(flowId);
+    await active.flow.cancel();
+  }
+
+  async resetGlobalMcpServerAuth({ name }: GlobalMcpServerNamePayload): Promise<void> {
+    const server = await this.globalMcpConfig.get(name);
+    const config = requireRemoteMcpServer(server);
+    this.globalMcpOAuth.invalidate(server.name, config.url);
+  }
+
+  async testGlobalMcpServer(
+    { name, cwd }: TestGlobalMcpServerPayload,
+  ): Promise<GlobalMcpServerTestResult> {
+    const server = await this.globalMcpConfig.get(name);
+    const config = mcpConfigWithoutName(server);
+    const manager = new McpConnectionManager({
+      stdioCwd: cwd,
+      oauthService: this.globalMcpOAuth,
+    });
+    try {
+      await manager.connectAll({ [server.name]: config });
+      return standaloneMcpTestResult(server.name, manager);
+    } finally {
+      await manager.shutdown();
+    }
+  }
+
   prompt({ sessionId, ...payload }: SessionAgentPayload<PromptPayload>) {
     return this.sessionApi(sessionId).prompt(payload);
   }
@@ -710,6 +869,10 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     return this.sessionApi(sessionId).clearContext(payload);
   }
 
+  importContext({ sessionId, ...payload }: SessionAgentPayload<ImportContextPayload>) {
+    return this.sessionApi(sessionId).importContext(payload);
+  }
+
   activateSkill({
     sessionId,
     ...payload
@@ -1101,6 +1264,16 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     return this.config;
   }
 
+  /**
+   * Config bound to a newly created/resumed session. In print mode (`kimi -p`,
+   * v1) the print-mode defaults are merged in; explicit user config wins. The
+   * raw `this.config` is left untouched so `getKimiConfig` and config writes
+   * still round-trip the user's file values.
+   */
+  private withPrintModeDefaults(config: KimiConfig): KimiConfig {
+    return this.printMode ? applyPrintModeConfigDefaults(config) : config;
+  }
+
   private clearRuntimeCache(): void {
     if (this.runtimeOverride !== undefined) return;
     this.runtime = undefined;
@@ -1143,6 +1316,57 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
   }
 }
 
+function requireRemoteMcpServer(server: GlobalMcpServerConfig): McpRemoteServerConfig {
+  const config = mcpConfigWithoutName(server);
+  if (config.transport !== 'stdio') return config;
+  throw new KimiError(
+    ErrorCodes.REQUEST_INVALID,
+    `MCP server "${server.name}" does not use a remote transport`,
+  );
+}
+
+function requireOAuthMcpServer(server: GlobalMcpServerConfig): McpRemoteServerConfig {
+  const config = requireRemoteMcpServer(server);
+  if (config.bearerTokenEnvVar !== undefined) {
+    throw new KimiError(
+      ErrorCodes.REQUEST_INVALID,
+      `MCP server "${server.name}" uses a static bearer token`,
+    );
+  }
+  if (config.headers !== undefined && config.auth !== 'oauth') {
+    throw new KimiError(
+      ErrorCodes.REQUEST_INVALID,
+      `MCP server "${server.name}" uses static headers and is not marked for OAuth`,
+    );
+  }
+  return config;
+}
+
+function mcpConfigWithoutName(server: GlobalMcpServerConfig): McpServerConfig {
+  const { name: _name, ...config } = server;
+  return config;
+}
+
+function standaloneMcpTestResult(
+  name: string,
+  manager: McpConnectionManager,
+): GlobalMcpServerTestResult {
+  const entry = manager.get(name);
+  if (entry?.status !== 'connected') {
+    return {
+      success: false,
+      output: entry?.error ?? `MCP server "${name}" finished with status ${entry?.status ?? 'unknown'}`,
+    };
+  }
+  const tools = manager.resolved(name)?.rawTools ?? [];
+  const lines = [
+    `Connected to MCP server "${name}".`,
+    `Available tools: ${tools.length}`,
+    ...tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ''}`),
+  ];
+  return { success: true, output: lines.join('\n') };
+}
+
 async function createRuntimeConfig(input: {
   readonly config: KimiConfig;
   readonly kimiRequestHeaders?: Record<string, string> | undefined;
@@ -1242,7 +1466,23 @@ async function resumeSessionResult(
   summary: SessionSummary,
   session: Session,
   warning?: string,
+  includeSubagents = false,
 ): Promise<ResumeSessionResult> {
+  if (includeSubagents) {
+    const persistedAgentIds = Object.keys(session.metadata.agents).filter(
+      (agentId) => agentId !== 'main',
+    );
+    const resumedAgents = await Promise.allSettled(
+      persistedAgentIds.map((agentId) => session.ensureAgentResumed(agentId)),
+    );
+    for (const [index, result] of resumedAgents.entries()) {
+      if (result.status === 'fulfilled') continue;
+      session.log.warn('persisted subagent replay unavailable during session resume', {
+        agentId: persistedAgentIds[index],
+        error: result.reason,
+      });
+    }
+  }
   const api = new SessionAPIImpl(session);
   const agents: Record<string, ResumedAgentState> = {};
   for (const [agentId, entry] of session.agents) {
diff --git a/packages/agent-core/src/rpc/events.ts b/packages/agent-core/src/rpc/events.ts
index bf98c4f76..0a0e688e7 100644
--- a/packages/agent-core/src/rpc/events.ts
+++ b/packages/agent-core/src/rpc/events.ts
@@ -23,6 +23,7 @@ export type {
   SessionCreatedEvent,
   SessionMetaUpdatedEvent,
   SessionStatusChangedEvent,
+  SessionWorkChangedEvent,
   SkillActivatedEvent,
   SubagentCompletedEvent,
   SubagentFailedEvent,
diff --git a/packages/agent-core/src/services/index.ts b/packages/agent-core/src/services/index.ts
index a76c6d95c..e24af838c 100644
--- a/packages/agent-core/src/services/index.ts
+++ b/packages/agent-core/src/services/index.ts
@@ -86,7 +86,7 @@ export {
   WorkspaceRootNotFoundError,
 } from './workspace/workspaceRegistry';
 export type { WorkspacePatch } from './workspace/workspaceRegistry';
-export { WorkspaceRegistryService, detectGit } from './workspace/workspaceRegistryService';
+export { WorkspaceRegistryService } from './workspace/workspaceRegistryService';
 export {
   IWorkspaceFsService,
   WorkspaceFsNotAbsoluteError,
diff --git a/packages/agent-core/src/services/modelCatalog/modelCatalog.ts b/packages/agent-core/src/services/modelCatalog/modelCatalog.ts
index 46b83fb07..c47532be1 100644
--- a/packages/agent-core/src/services/modelCatalog/modelCatalog.ts
+++ b/packages/agent-core/src/services/modelCatalog/modelCatalog.ts
@@ -1,5 +1,5 @@
 import { createDecorator } from '../../di';
-import { effectiveModelAlias, type KimiConfig, type ModelAlias, type ProviderConfig } from '../../config';
+import { effectiveModelAlias, type KimiConfig, type ModelAlias, type ProviderConfig, type ProviderType } from '../../config';
 import type {
   ModelCatalogItem,
   ProviderCatalogItem,
@@ -57,8 +57,9 @@ export class ModelNotFoundError extends Error {
 export function toProtocolModel(
   modelId: string,
   alias: ModelAlias,
+  providerType?: ProviderType,
 ): ModelCatalogItem {
-  const effective = effectiveModelAlias(alias);
+  const effective = effectiveModelAlias(alias, providerType);
   return {
     provider: effective.provider,
     model: modelId,
diff --git a/packages/agent-core/src/services/modelCatalog/modelCatalogService.ts b/packages/agent-core/src/services/modelCatalog/modelCatalogService.ts
index 69418ca6a..db70fdebf 100644
--- a/packages/agent-core/src/services/modelCatalog/modelCatalogService.ts
+++ b/packages/agent-core/src/services/modelCatalog/modelCatalogService.ts
@@ -1,5 +1,5 @@
 import { Disposable, InstantiationType, registerSingleton } from '../../di';
-import type { KimiConfig, ProviderConfig } from '../../config';
+import type { KimiConfig, ModelAlias, ProviderConfig, ProviderType } from '../../config';
 import type {
   ModelCatalogItem,
   ProviderCatalogItem,
@@ -61,7 +61,7 @@ export class ModelCatalogService
   async listModels(): Promise<readonly ModelCatalogItem[]> {
     const config = await this._readConfig();
     return Object.entries(config.models ?? {}).map(([modelId, alias]) =>
-      toProtocolModel(modelId, alias),
+      toProtocolModel(modelId, alias, this._providerTypeOf(config, alias)),
     );
   }
 
@@ -94,10 +94,19 @@ export class ModelCatalogService
     const updatedAlias = updated.models?.[modelId] ?? alias;
     return {
       default_model: modelId,
-      model: toProtocolModel(modelId, updatedAlias),
+      model: toProtocolModel(
+        modelId,
+        updatedAlias,
+        this._providerTypeOf(updated, updatedAlias),
+      ),
     };
   }
 
+  private _providerTypeOf(config: KimiConfig, alias: ModelAlias): ProviderType | undefined {
+    const providerId = alias.provider ?? config.defaultProvider;
+    return config.providers[providerId ?? '']?.type;
+  }
+
   async refreshOAuthProviderModels(): Promise<RefreshOAuthProviderModelsResponse> {
     return this.refreshProviderModels({ scope: 'oauth' });
   }
diff --git a/packages/agent-core/src/services/session/session.ts b/packages/agent-core/src/services/session/session.ts
index fde54ddcc..3f16e1389 100644
--- a/packages/agent-core/src/services/session/session.ts
+++ b/packages/agent-core/src/services/session/session.ts
@@ -21,7 +21,7 @@ import {
 } from '@moonshot-ai/protocol';
 
 export interface SessionListQuery extends CursorQuery {
-  status?: import('@moonshot-ai/protocol').SessionStatus;
+  busy?: boolean;
   workDir?: string;
   includeArchive?: boolean;
   /** When true, hide sessions the user has never interacted with (no prompt yet). */
@@ -120,7 +120,7 @@ export function toProtocolSession(
     title,
     created_at: new Date(summary.createdAt).toISOString(),
     updated_at: new Date(summary.updatedAt).toISOString(),
-    status: 'idle',
+    busy: false,
     archived: summary.archived === true,
     last_prompt: summary.lastPrompt,
     metadata: mergedMetadata,
diff --git a/packages/agent-core/src/services/session/sessionService.ts b/packages/agent-core/src/services/session/sessionService.ts
index b1c59fa01..39de8d585 100644
--- a/packages/agent-core/src/services/session/sessionService.ts
+++ b/packages/agent-core/src/services/session/sessionService.ts
@@ -12,10 +12,10 @@ import {
   type Message,
   type PageResponse,
   type Session,
+  type SessionPendingInteraction,
   type SessionChildCreate,
   type SessionCreate,
   type SessionFork,
-  type SessionStatus,
   type SessionStatusResponse,
   type SessionUpdate,
   type SessionWarning,
@@ -44,6 +44,13 @@ const DEFAULT_UNDO_MESSAGE_PAGE_SIZE = 50;
 const MAX_UNDO_MESSAGE_PAGE_SIZE = 100;
 const CHILD_SESSION_KIND = 'child';
 
+interface SessionWorkFacts {
+  readonly busy: boolean;
+  readonly mainTurnActive: boolean;
+  readonly pendingInteraction: SessionPendingInteraction;
+  readonly lastTurnReason?: 'completed' | 'cancelled' | 'failed';
+}
+
 function asJsonObject(value: Record<string, unknown>): JsonObject {
   return value as unknown as JsonObject;
 }
@@ -96,9 +103,11 @@ export class SessionService extends Disposable implements ISessionService {
   private readonly _onDidClose = this._register(new Emitter<{ sessionId: string }>());
   readonly onDidClose = this._onDidClose.event;
 
-  private readonly _statusBySession = new Map<string, SessionStatus>();
+  private readonly _workFactsBySession = new Map<string, SessionWorkFacts>();
   private readonly _activeTurns = new Set<string>();
-  private readonly _abortedTurns = new Set<string>();
+  /** MAIN-agent latest turn outcome per session — an orthogonal wire fact
+   *  clients may present as an "aborted" tag (busy=false + cancelled/failed). */
+  private readonly _lastTurnReasonBySession = new Map<string, 'completed' | 'cancelled' | 'failed'>();
   private _promptService: IPromptService | undefined;
 
   constructor(
@@ -121,64 +130,64 @@ export class SessionService extends Disposable implements ISessionService {
   }
 
   /**
-   * Compute the session lifecycle status from live daemon state.
-   *
-   * Priority:
-   *   1. awaiting_approval — pending approvals exist
-   *   2. awaiting_question — pending questions exist
-   *   3. running           — active prompt or active turn
-   *   4. aborted           — last turn ended as cancelled/failed and no new work started
-   *   5. idle              — everything else
+   * Compute the orthogonal work and interaction facts projected onto the wire.
    */
-  private _computeStatus(sessionId: string): SessionStatus {
-    if (this.approvalService.listPending(sessionId).length > 0) {
-      return 'awaiting_approval';
-    }
-    if (this.questionService.listPending(sessionId).length > 0) {
-      return 'awaiting_question';
-    }
-    if (
+  private _computeWorkFacts(sessionId: string): SessionWorkFacts {
+    const hasPendingApproval = this.approvalService.listPending(sessionId).length > 0;
+    const hasPendingQuestion = this.questionService.listPending(sessionId).length > 0;
+    const mainTurnActive =
       this.promptService.getCurrentPromptId(sessionId) !== undefined ||
-      this._activeTurns.has(sessionId)
-    ) {
-      return 'running';
-    }
-    if (this._abortedTurns.has(sessionId)) {
-      return 'aborted';
-    }
-    return 'idle';
+      this._activeTurns.has(sessionId);
+    return {
+      busy: mainTurnActive || hasPendingApproval || hasPendingQuestion,
+      mainTurnActive,
+      pendingInteraction: hasPendingApproval
+        ? 'approval'
+        : hasPendingQuestion
+          ? 'question'
+          : 'none',
+      lastTurnReason: this._lastTurnReasonBySession.get(sessionId),
+    };
   }
 
   /**
-   * Overwrite the placeholder status on a protocol Session with the live value,
-   * and remember the last status we returned so status-change events can be
-   * emitted only when the live state actually moves.
+   * Overwrite the placeholders on a protocol Session with live facts and
+   * remember them so work-change events fire only on real transitions.
    */
   private _patchSessionStatus(session: Session): Session {
-    const status = this._computeStatus(session.id);
-    session.status = status;
-    this._statusBySession.set(session.id, status);
+    const facts = this._computeWorkFacts(session.id);
+    session.busy = facts.busy;
+    session.main_turn_active = facts.mainTurnActive;
+    session.pending_interaction = facts.pendingInteraction;
+    session.last_turn_reason = facts.lastTurnReason;
+    this._workFactsBySession.set(session.id, facts);
     return session;
   }
 
   /**
-   * Publish `event.session.status_changed` when the computed status for a
-   * session differs from the last one we announced. Called after every relevant
-   * lifecycle event so the session list stays in sync.
+   * Publish `event.session.work_changed` when any projected fact changes.
    */
   private _emitStatusChanged(sessionId: string): void {
-    const previous = this._statusBySession.get(sessionId) ?? 'idle';
-    const next = this._computeStatus(sessionId);
-    if (previous === next) return;
+    const previous = this._workFactsBySession.get(sessionId);
+    const next = this._computeWorkFacts(sessionId);
+    if (
+      previous?.busy === next.busy &&
+      previous.mainTurnActive === next.mainTurnActive &&
+      previous.pendingInteraction === next.pendingInteraction &&
+      previous.lastTurnReason === next.lastTurnReason
+    ) {
+      return;
+    }
 
-    this._statusBySession.set(sessionId, next);
+    this._workFactsBySession.set(sessionId, next);
     this.eventService.publish({
-      type: 'event.session.status_changed',
+      type: 'event.session.work_changed',
       agentId: 'main',
       sessionId,
-      status: next,
-      previous_status: previous,
-      current_prompt_id: this.promptService.getCurrentPromptId(sessionId),
+      busy: next.busy,
+      main_turn_active: next.mainTurnActive,
+      pending_interaction: next.pendingInteraction,
+      last_turn_reason: next.lastTurnReason,
     } as unknown as Event);
   }
 
@@ -190,26 +199,24 @@ export class SessionService extends Disposable implements ISessionService {
     switch (type) {
       case 'turn.started': {
         this._activeTurns.add(sessionId);
-        this._abortedTurns.delete(sessionId);
+        // A fresh turn means no current outcome — drop the previous turn's
+        // terminal reason so the running turn doesn't keep reporting it.
+        this._lastTurnReasonBySession.delete(sessionId);
         this._emitStatusChanged(sessionId);
         break;
       }
       case 'turn.ended': {
         this._activeTurns.delete(sessionId);
-        const reason = (event as { reason?: string }).reason;
-        if (reason === 'cancelled' || reason === 'failed' || reason === 'blocked') {
-          this._abortedTurns.add(sessionId);
-        } else {
-          this._abortedTurns.delete(sessionId);
+        const reason = (event as { reason?: unknown }).reason;
+        if (reason === 'blocked') {
+          this._lastTurnReasonBySession.set(sessionId, 'failed');
+        } else if (reason === 'completed' || reason === 'cancelled' || reason === 'failed') {
+          this._lastTurnReasonBySession.set(sessionId, reason);
         }
         this._emitStatusChanged(sessionId);
         break;
       }
-      case 'prompt.submitted': {
-        this._abortedTurns.delete(sessionId);
-        this._emitStatusChanged(sessionId);
-        break;
-      }
+      case 'prompt.submitted':
       case 'prompt.completed':
       case 'prompt.aborted':
       case 'event.approval.requested':
@@ -288,7 +295,7 @@ export class SessionService extends Disposable implements ISessionService {
     );
 
     const filtered =
-      query.status !== undefined ? items.filter((s) => s.status === query.status) : items;
+      query.busy !== undefined ? items.filter((s) => s.busy === query.busy) : items;
 
     return { items: filtered, has_more: hasMore };
   }
@@ -401,9 +408,7 @@ export class SessionService extends Disposable implements ISessionService {
       ),
     );
     const filtered =
-      query.status !== undefined
-        ? items.filter((session) => session.status === query.status)
-        : items;
+      query.busy !== undefined ? items.filter((session) => session.busy === query.busy) : items;
 
     return {
       items: filtered,
@@ -461,7 +466,7 @@ export class SessionService extends Disposable implements ISessionService {
     const agentState = this.promptService.getAgentStateSnapshot(id);
 
     return {
-      status: this._computeStatus(id),
+      busy: this._computeWorkFacts(id).busy,
       model: config.modelAlias ?? config.provider?.model,
       thinking_level: config.thinkingEffort,
       permission: permission.mode,
@@ -547,9 +552,9 @@ export class SessionService extends Disposable implements ISessionService {
     }
     await this.core.rpc.archiveSession({ sessionId: id });
     this._onDidClose.fire({ sessionId: id });
-    this._statusBySession.delete(id);
+    this._workFactsBySession.delete(id);
     this._activeTurns.delete(id);
-    this._abortedTurns.delete(id);
+    this._lastTurnReasonBySession.delete(id);
     return { archived: true };
   }
 
diff --git a/packages/agent-core/src/services/workspace/index.ts b/packages/agent-core/src/services/workspace/index.ts
index 0da7cfa79..64eea759b 100644
--- a/packages/agent-core/src/services/workspace/index.ts
+++ b/packages/agent-core/src/services/workspace/index.ts
@@ -4,7 +4,7 @@ export {
   WorkspaceRootNotFoundError,
   type WorkspacePatch,
 } from './workspaceRegistry';
-export { WorkspaceRegistryService, detectGit } from './workspaceRegistryService';
+export { WorkspaceRegistryService } from './workspaceRegistryService';
 export {
   IWorkspaceFsService,
   WorkspaceFsNotAbsoluteError,
diff --git a/packages/agent-core/src/services/workspace/workspaceFsService.ts b/packages/agent-core/src/services/workspace/workspaceFsService.ts
index e12d6b9df..d9a4b9b59 100644
--- a/packages/agent-core/src/services/workspace/workspaceFsService.ts
+++ b/packages/agent-core/src/services/workspace/workspaceFsService.ts
@@ -16,7 +16,6 @@ import {
   WorkspaceFsNotFoundError,
   WorkspaceFsPermissionError,
 } from './workspaceFs';
-import { detectGit } from './workspaceRegistryService';
 
 export class WorkspaceFsService extends Disposable implements IWorkspaceFsService {
   readonly _serviceBrand: undefined;
@@ -46,22 +45,11 @@ export class WorkspaceFsService extends Disposable implements IWorkspaceFsServic
     }
     const dirOnly = dirents.filter((d) => d.isDirectory());
 
-    const entries: FsBrowseEntry[] = await Promise.all(
-      dirOnly.map(async (d) => {
-        const childAbs = join(realTarget, d.name);
-        const git = await detectGit(childAbs);
-        const base: FsBrowseEntry = {
-          name: d.name,
-          path: childAbs,
-          is_dir: true,
-          is_git_repo: git.is_git_repo,
-        };
-        if (git.branch !== null) {
-          return { ...base, branch: git.branch };
-        }
-        return base;
-      }),
-    );
+    const entries: FsBrowseEntry[] = dirOnly.map((d) => ({
+      name: d.name,
+      path: join(realTarget, d.name),
+      is_dir: true,
+    }));
 
     entries.sort(compareBrowseEntries);
 
diff --git a/packages/agent-core/src/services/workspace/workspaceRegistryService.ts b/packages/agent-core/src/services/workspace/workspaceRegistryService.ts
index aa5886c2a..cc4b3b637 100644
--- a/packages/agent-core/src/services/workspace/workspaceRegistryService.ts
+++ b/packages/agent-core/src/services/workspace/workspaceRegistryService.ts
@@ -19,25 +19,12 @@ import {
   WorkspaceRootNotFoundError,
   type WorkspacePatch,
 } from './workspaceRegistry';
-
-const WORKSPACE_REGISTRY_FILE = 'workspaces.json';
-const WORKSPACE_REGISTRY_VERSION = 1;
-
-interface WorkspaceRegistryEntry {
-  root: string;
-  name: string;
-  created_at: string;
-  last_opened_at: string;
-}
-
-interface WorkspaceRegistryFile {
-  version: number;
-  workspaces: Record<string, WorkspaceRegistryEntry>;
-  /** Workspace ids the user explicitly removed. Their session buckets stay on
-   *  disk, so derived workspaces (computed from the session index) must skip
-   *  them to keep deletion durable. */
-  deleted_workspace_ids: string[];
-}
+import {
+  readWorkspaceRegistryFile,
+  writeWorkspaceRegistryFile,
+  type WorkspaceRegistryEntry,
+  type WorkspaceRegistryFile,
+} from '../../session/store/workspace-registry-file';
 
 type WorkspaceRegistryEvent =
   | { type: 'event.workspace.created'; workspace: Workspace }
@@ -49,7 +36,6 @@ export class WorkspaceRegistryService extends Disposable implements IWorkspaceRe
 
   private readonly homeDir: string;
   private readonly sessionsDir: string;
-  private readonly registryPath: string;
   private opQueue: Promise<unknown> = Promise.resolve();
 
   constructor(
@@ -60,7 +46,6 @@ export class WorkspaceRegistryService extends Disposable implements IWorkspaceRe
     super();
     this.homeDir = env.homeDir;
     this.sessionsDir = join(env.homeDir, 'sessions');
-    this.registryPath = join(env.homeDir, WORKSPACE_REGISTRY_FILE);
   }
 
   async list(): Promise<Workspace[]> {
@@ -258,16 +243,12 @@ export class WorkspaceRegistryService extends Disposable implements IWorkspaceRe
     entry: WorkspaceRegistryEntry,
     sessionCount?: number,
   ): Promise<Workspace> {
-    const [{ is_git_repo, branch }, session_count] = await Promise.all([
-      detectGit(entry.root),
-      sessionCount ?? countActiveSessions(join(this.sessionsDir, workspaceId)),
-    ]);
+    const session_count =
+      sessionCount ?? (await countActiveSessions(join(this.sessionsDir, workspaceId)));
     return {
       id: workspaceId,
       root: entry.root,
       name: entry.name,
-      is_git_repo,
-      branch,
       created_at: entry.created_at,
       last_opened_at: entry.last_opened_at,
       session_count,
@@ -298,81 +279,13 @@ export class WorkspaceRegistryService extends Disposable implements IWorkspaceRe
   }
 
   private async readRegistry(): Promise<WorkspaceRegistryFile> {
-    let raw: string;
-    try {
-      raw = await fsp.readFile(this.registryPath, 'utf8');
-    } catch (err) {
-      const code = (err as NodeJS.ErrnoException).code;
-      if (code === 'ENOENT' || code === 'ENOTDIR') {
-        return { version: WORKSPACE_REGISTRY_VERSION, workspaces: {}, deleted_workspace_ids: [] };
-      }
-      throw err;
-    }
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch (err) {
-      this.logger.warn(
-        { path: this.registryPath, err: String(err) },
-        'workspaces.json malformed; treating as empty',
-      );
-      return { version: WORKSPACE_REGISTRY_VERSION, workspaces: {}, deleted_workspace_ids: [] };
-    }
-    if (
-      typeof parsed !== 'object' ||
-      parsed === null ||
-      typeof (parsed as { workspaces?: unknown }).workspaces !== 'object' ||
-      (parsed as { workspaces?: unknown }).workspaces === null
-    ) {
-      this.logger.warn(
-        { path: this.registryPath },
-        'workspaces.json missing required keys; treating as empty',
-      );
-      return { version: WORKSPACE_REGISTRY_VERSION, workspaces: {}, deleted_workspace_ids: [] };
-    }
-    const rawWorkspaces = (parsed as { workspaces: Record<string, unknown> }).workspaces;
-    const workspaces: Record<string, WorkspaceRegistryEntry> = {};
-    for (const [id, value] of Object.entries(rawWorkspaces)) {
-      const entry = this.sanitizeEntry(value);
-      if (entry !== null) {
-        workspaces[id] = entry;
-      }
-    }
-    const version =
-      typeof (parsed as { version?: unknown }).version === 'number'
-        ? (parsed as { version: number }).version
-        : WORKSPACE_REGISTRY_VERSION;
-    const rawDeleted = (parsed as { deleted_workspace_ids?: unknown }).deleted_workspace_ids;
-    const deleted_workspace_ids = Array.isArray(rawDeleted)
-      ? rawDeleted.filter((id): id is string => typeof id === 'string')
-      : [];
-    return { version, workspaces, deleted_workspace_ids };
-  }
-
-  private sanitizeEntry(value: unknown): WorkspaceRegistryEntry | null {
-    if (typeof value !== 'object' || value === null) return null;
-    const v = value as Partial<WorkspaceRegistryEntry>;
-    if (
-      typeof v.root !== 'string' ||
-      typeof v.name !== 'string' ||
-      typeof v.created_at !== 'string' ||
-      typeof v.last_opened_at !== 'string'
-    ) {
-      return null;
-    }
-    return {
-      root: v.root,
-      name: v.name,
-      created_at: v.created_at,
-      last_opened_at: v.last_opened_at,
-    };
+    return readWorkspaceRegistryFile(this.homeDir, (context, message) =>
+      this.logger.warn(context, message),
+    );
   }
 
   private async writeRegistry(file: WorkspaceRegistryFile): Promise<void> {
-    await fsp.mkdir(dirname(this.registryPath), { recursive: true, mode: 0o700 });
-    const tmp = `${this.registryPath}.tmp`;
-    await fsp.writeFile(tmp, JSON.stringify(file, null, 2), 'utf8');
-    await fsp.rename(tmp, this.registryPath);
+    await writeWorkspaceRegistryFile(this.homeDir, file);
   }
 
   private runExclusive<T>(op: () => Promise<T>): Promise<T> {
@@ -390,52 +303,6 @@ export class WorkspaceRegistryService extends Disposable implements IWorkspaceRe
   }
 }
 
-export interface GitInfo {
-  is_git_repo: boolean;
-  branch: string | null;
-}
-
-export async function detectGit(root: string): Promise<GitInfo> {
-  let dotGit: Stats;
-  try {
-    dotGit = await fsp.lstat(join(root, '.git'));
-  } catch {
-    return { is_git_repo: false, branch: null };
-  }
-
-  let gitDir: string;
-  if (dotGit.isDirectory()) {
-    gitDir = join(root, '.git');
-  } else if (dotGit.isFile()) {
-    let text: string;
-    try {
-      text = await fsp.readFile(join(root, '.git'), 'utf8');
-    } catch {
-      return { is_git_repo: false, branch: null };
-    }
-    const m = /^gitdir:\s*(.+)$/m.exec(text);
-    if (m === null) return { is_git_repo: false, branch: null };
-    const ref = m[1] ?? '';
-    if (ref === '') return { is_git_repo: false, branch: null };
-    gitDir = ref.trim();
-
-    if (!gitDir.startsWith('/')) {
-      gitDir = join(root, gitDir);
-    }
-  } else {
-    return { is_git_repo: false, branch: null };
-  }
-
-  let head: string;
-  try {
-    head = (await fsp.readFile(join(gitDir, 'HEAD'), 'utf8')).trim();
-  } catch {
-    return { is_git_repo: true, branch: null };
-  }
-  const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
-  return { is_git_repo: true, branch: ref ? (ref[1] ?? null) : null };
-}
-
 async function countActiveSessions(dir: string): Promise<number> {
   let dirents;
   try {
diff --git a/packages/agent-core/src/session/export/session-export.ts b/packages/agent-core/src/session/export/session-export.ts
index e4e625722..056374cdf 100644
--- a/packages/agent-core/src/session/export/session-export.ts
+++ b/packages/agent-core/src/session/export/session-export.ts
@@ -47,9 +47,10 @@ export async function exportSessionDirectory(input: {
     }
   }
 
+  const now = new Date();
   const manifest = buildExportManifest({
     summary: input.summary,
-    now: new Date(),
+    now,
     version: input.request.version,
     sessionScan,
     sessionLogPath: hasSessionLog ? SESSION_LOG_REL : undefined,
@@ -61,7 +62,7 @@ export async function exportSessionDirectory(input: {
   const outputPath =
     input.request.outputPath !== undefined
       ? resolve(input.request.outputPath)
-      : resolve(`${input.summary.id}.zip`);
+      : resolve(defaultExportZipName(input.summary.id, now));
 
   const entries = await writeExportZip({
     outputPath,
@@ -79,6 +80,12 @@ export async function exportSessionDirectory(input: {
   };
 }
 
+function defaultExportZipName(sessionId: string, now: Date): string {
+  const shortId = sessionId.slice(0, 8);
+  const timestamp = now.toISOString().replaceAll(/[-:]/g, '').replace(/T/, '-').slice(0, 15);
+  return `kimi-debug-${shortId}-${timestamp}.zip`;
+}
+
 async function readOptionalFile(path: string): Promise<Buffer | undefined> {
   try {
     return await readFile(path);
diff --git a/packages/agent-core/src/session/index.ts b/packages/agent-core/src/session/index.ts
index f8f40de5f..0f7ec8d23 100644
--- a/packages/agent-core/src/session/index.ts
+++ b/packages/agent-core/src/session/index.ts
@@ -17,6 +17,8 @@ import {
   appendWorkspaceAdditionalDir,
   normalizeAdditionalDirs,
   parseBooleanEnv,
+  PRINT_MAX_TURNS_DEFAULT,
+  PRINT_WAIT_CEILING_S_DEFAULT,
   readWorkspaceAdditionalDirs,
   resolveWorkspaceAdditionalDirs,
   resolveConfigValue,
@@ -99,9 +101,9 @@ export interface SessionSkillConfig {
 }
 
 export interface AgentMeta {
-  readonly homedir: string;
+  readonly homedir?: string;
   readonly type: AgentType;
-  readonly parentAgentId: string | null;
+  readonly parentAgentId?: string | null;
   readonly swarmItem?: string;
 }
 
@@ -130,6 +132,10 @@ export interface SessionMeta {
    *  session directory is self-describing and the global session index does not
    *  have to be trusted for the (one-way-hashed) workDir. */
   workDir?: string;
+  /** Directories added for this session only. Unlike workspace local config,
+   *  these follow the session across close/resume without affecting any other
+   *  session opened in the same workspace. */
+  additionalDirs?: string[];
   agents: Record<string, AgentMeta>;
   custom: Record<string, any>;
 }
@@ -176,6 +182,7 @@ export class Session {
   private toolKaos: Kaos;
   private persistenceKaos: Kaos;
   private additionalDirs: readonly string[];
+  private sessionAdditionalDirs: readonly string[] = [];
   private readonly pluginCommands: readonly PluginCommandDef[];
   private agentIdCounter = 0;
   private readonly skillsReady: Promise<void>;
@@ -261,6 +268,10 @@ export class Session {
     }
   }
 
+  async setBaseAdditionalDirs(additionalDirs: readonly string[]): Promise<void> {
+    await this.setAdditionalDirs([...additionalDirs, ...this.sessionAdditionalDirs]);
+  }
+
   async addAdditionalDir(
     path: string,
     persist = true,
@@ -278,6 +289,22 @@ export class Session {
     const workspace = await readWorkspaceAdditionalDirs(systemKaos, cwd);
     const additionalDirs = await resolveWorkspaceAdditionalDirs(systemKaos, cwd, [path]);
     const nextAdditionalDirs = normalizeAdditionalDirs([...this.additionalDirs, ...additionalDirs]);
+    const nextSessionAdditionalDirs = normalizeAdditionalDirs([
+      ...this.sessionAdditionalDirs,
+      ...additionalDirs,
+    ]);
+    const previousMetadata = this.metadata;
+    this.metadata = {
+      ...this.metadata,
+      additionalDirs: nextSessionAdditionalDirs,
+    };
+    try {
+      await this.writeMetadata();
+    } catch (error) {
+      this.metadata = previousMetadata;
+      throw error;
+    }
+    this.sessionAdditionalDirs = nextSessionAdditionalDirs;
     await this.setAdditionalDirs(nextAdditionalDirs);
     this.notifyAdditionalDirAdded(path, false, workspace.configPath);
     return {
@@ -320,7 +347,14 @@ export class Session {
   async resume(): Promise<{ warning?: string }> {
     await this.skillsReady;
     this.log.info('session resume', { app_version: this.options.appVersion });
-    const { agents } = await this.readMetadata();
+    const { agents, additionalDirs = [] } = await this.readMetadata();
+    const cwd = this.toolKaos.getcwd();
+    this.sessionAdditionalDirs = await resolveWorkspaceAdditionalDirs(
+      this.systemContextKaos(cwd),
+      cwd,
+      additionalDirs,
+    );
+    await this.setBaseAdditionalDirs(this.additionalDirs);
     this.agents.clear();
     // Only the main agent is needed to reopen the session; subagents replay
     // lazily when an RPC or Agent(resume=...) call asks for their state.
@@ -451,7 +485,8 @@ export class Session {
    * `resolvePrintBackgroundMode`): `print_background_mode = "drain"`, or the
    * legacy `keep_alive_on_exit = true` fallback. In every other mode it returns
    * immediately. The wait is bounded by `background.print_wait_ceiling_s`
-   * (default 3600s) so a wedged task cannot keep the process alive forever.
+   * (default `PRINT_WAIT_CEILING_S_DEFAULT`, effectively unbounded) so a wedged
+   * task can still be given up on eventually.
    *
    * Terminal notifications are suppressed for each task while we wait, so a task
    * completing cannot `turn.steer` the (already finished) main agent into launching
@@ -460,7 +495,7 @@ export class Session {
   async waitForBackgroundTasksOnPrint(): Promise<void> {
     if (this.resolvePrintBackgroundMode() !== 'drain') return;
 
-    const ceilingS = this.options.background?.printWaitCeilingS ?? 3600;
+    const ceilingS = this.options.background?.printWaitCeilingS ?? PRINT_WAIT_CEILING_S_DEFAULT;
     const timeoutMs = ceilingS * 1000;
     const deadline = Date.now() + timeoutMs;
 
@@ -518,7 +553,9 @@ export class Session {
    * `background.print_background_mode` is authoritative when set. Otherwise we
    * fall back to the legacy `background.keep_alive_on_exit` mapping so existing
    * configs keep their behavior: `keep_alive_on_exit = true` ⇒ `'drain'`
-   * (suppress + drain background tasks before exit), otherwise `'exit'`.
+   * (suppress + drain background tasks before exit). When neither is set the
+   * mode defaults to `'steer'`: a headless run stays alive while background
+   * tasks are pending so their completions can steer new main turns.
    */
   private resolvePrintBackgroundMode(): 'exit' | 'drain' | 'steer' {
     const configured = this.options.background?.printBackgroundMode;
@@ -530,7 +567,7 @@ export class Session {
       defaultValue: false,
       parseEnv: parseBooleanEnv,
     });
-    return keepAliveOnExit ? 'drain' : 'exit';
+    return keepAliveOnExit ? 'drain' : 'steer';
   }
 
   private countActiveBackgroundTasks(): number {
@@ -547,13 +584,13 @@ export class Session {
    * `'continue'` when the driver must stay alive so a background-task completion
    * can `turn.steer` the main agent into a new turn.
    *
-   *  - 'exit'  : finish immediately (default).
+   *  - 'exit'  : finish immediately.
    *  - 'drain' : suppress + drain background tasks, then finish (legacy
    *              `keep_alive_on_exit = true` behavior).
    *  - 'steer' : while background tasks are still pending, return 'continue' so
    *              completions steer new main turns; finish once quiescent, or when
    *              the wall-clock ceiling (`print_wait_ceiling_s`) or the turn cap
-   *              (`print_max_turns`) is reached.
+   *              (`print_max_turns`) is reached. This is the default mode.
    */
   async handlePrintMainTurnCompleted(): Promise<'finish' | 'continue'> {
     const mode = this.resolvePrintBackgroundMode();
@@ -564,8 +601,8 @@ export class Session {
     }
 
     // 'steer'
-    const ceilingS = this.options.background?.printWaitCeilingS ?? 3600;
-    const maxTurns = this.options.background?.printMaxTurns ?? 50;
+    const ceilingS = this.options.background?.printWaitCeilingS ?? PRINT_WAIT_CEILING_S_DEFAULT;
+    const maxTurns = this.options.background?.printMaxTurns ?? PRINT_MAX_TURNS_DEFAULT;
     const now = Date.now();
     this.printSteerDeadline ??= now + ceilingS * 1000;
     this.printSteerTurns += 1;
@@ -989,7 +1026,13 @@ export class Session {
         : await this.resumeAgent(parentAgentId, [...stack, id]);
 
     try {
-      const agent = this.instantiateAgent(id, meta.homedir, meta.type, {}, parentAgentId);
+      const agent = this.instantiateAgent(
+        id,
+        join(this.options.homedir, 'agents', id),
+        meta.type,
+        {},
+        parentAgentId,
+      );
       const result = await agent.resume();
       this.restoreAgentProfileHandle(agent, meta, parent?.agent);
       this.agents.set(id, agent);
diff --git a/packages/agent-core/src/session/provider-manager.ts b/packages/agent-core/src/session/provider-manager.ts
index 5a84fdeaa..4a4bdcdc7 100644
--- a/packages/agent-core/src/session/provider-manager.ts
+++ b/packages/agent-core/src/session/provider-manager.ts
@@ -97,7 +97,6 @@ export class ProviderManager implements ModelProvider {
       );
     }
 
-    const effectiveAlias = effectiveModelAlias(alias);
     const providerName = alias.provider ?? this.config.defaultProvider;
     if (providerName === undefined) {
       throw new KimiError(
@@ -114,6 +113,8 @@ export class ProviderManager implements ModelProvider {
       );
     }
 
+    const effectiveAlias = effectiveModelAlias(alias, providerConfig.type);
+
     if (!Number.isInteger(effectiveAlias.maxContextSize) || effectiveAlias.maxContextSize <= 0) {
       throw new KimiError(
         ErrorCodes.CONFIG_INVALID,
@@ -129,6 +130,7 @@ export class ProviderManager implements ModelProvider {
       effectiveAlias.maxOutputSize,
       effectiveAlias.reasoningKey,
       this.options.promptCacheKey,
+      effectiveAlias.supportEfforts,
       effectiveAlias.adaptiveThinking,
       alias.betaApi,
     );
@@ -254,6 +256,7 @@ function toKosongProviderConfig(
   maxOutputSize: number | undefined,
   reasoningKey: string | undefined,
   promptCacheKey: string | undefined,
+  supportEfforts: readonly string[] | undefined,
   adaptiveThinking: boolean | undefined,
   betaApi: boolean | undefined,
 ): KosongProviderConfig {
@@ -271,6 +274,7 @@ function toKosongProviderConfig(
             : baseUrl,
         apiKey: providerApiKey(provider),
         ...(maxOutputSize !== undefined ? { defaultMaxTokens: maxOutputSize } : {}),
+        supportEfforts,
         ...(adaptiveThinking !== undefined ? { adaptiveThinking } : {}),
         ...(provider.type === 'kimi' ? { kimiThinking: true } : {}),
         ...(betaApi !== undefined ? { betaApi } : {}),
diff --git a/packages/agent-core/src/session/rpc.ts b/packages/agent-core/src/session/rpc.ts
index bbc85c776..a2e6f0c1e 100644
--- a/packages/agent-core/src/session/rpc.ts
+++ b/packages/agent-core/src/session/rpc.ts
@@ -16,6 +16,7 @@ import type {
   EnterSwarmPayload,
   GetBackgroundOutputPayload,
   GetBackgroundPayload,
+  ImportContextPayload,
   McpServerInfo,
   McpStartupMetrics,
   PromptPayload,
@@ -218,6 +219,10 @@ export class SessionAPIImpl implements PromisableMethods<SessionAPI> {
     return (await this.getAgent(agentId)).clearContext(payload);
   }
 
+  async importContext({ agentId, ...payload }: AgentScopedPayload<ImportContextPayload>) {
+    return (await this.getAgent(agentId)).importContext(payload);
+  }
+
   async activateSkill({ agentId, ...payload }: AgentScopedPayload<ActivateSkillPayload>) {
     await (await this.getAgent(agentId)).activateSkill(payload);
     if (agentId === 'main') {
diff --git a/packages/agent-core/src/session/store/session-index.ts b/packages/agent-core/src/session/store/session-index.ts
index 06dc8799f..2b9677097 100644
--- a/packages/agent-core/src/session/store/session-index.ts
+++ b/packages/agent-core/src/session/store/session-index.ts
@@ -1,12 +1,22 @@
 import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import * as nodePath from 'node:path';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'pathe';
 
+import { normalizeWorkDir } from '#/session/store/workdir-key';
+
 export interface SessionIndexEntry {
   readonly sessionId: string;
   readonly sessionDir: string;
   readonly workDir: string;
 }
 
+export interface SessionIndexDeletion {
+  readonly sessionId: string;
+  readonly deleted: true;
+}
+
+type SessionIndexRecord = SessionIndexEntry | SessionIndexDeletion;
+
 // Per-homeDir append chain. Within one process, concurrent index appends are
 // serialized so two lines can never be interleaved at the filesystem layer.
 // Cross-process, a single short line written with O_APPEND is atomic on POSIX
@@ -22,9 +32,23 @@ export function sessionIndexPath(homeDir: string): string {
 export async function appendSessionIndexEntry(
   homeDir: string,
   entry: SessionIndexEntry,
+): Promise<void> {
+  return appendSessionIndexRecord(homeDir, entry);
+}
+
+export async function appendSessionIndexDeletion(
+  homeDir: string,
+  sessionId: string,
+): Promise<void> {
+  return appendSessionIndexRecord(homeDir, { sessionId, deleted: true });
+}
+
+async function appendSessionIndexRecord(
+  homeDir: string,
+  record: SessionIndexRecord,
 ): Promise<void> {
   const indexPath = sessionIndexPath(homeDir);
-  const line = `${JSON.stringify(entry)}\n`;
+  const line = `${JSON.stringify(record)}\n`;
   const previous = appendQueues.get(homeDir) ?? Promise.resolve();
   const next = previous.then(async () => {
     await mkdir(dirname(indexPath), { recursive: true, mode: 0o700 });
@@ -49,9 +73,14 @@ export async function readSessionIndex(
   for (const line of raw.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (trimmed === '') continue;
-    const entry = parseIndexLine(trimmed);
-    if (entry === undefined) continue;
-    const sessionDir = resolve(entry.sessionDir);
+    const record = parseIndexLine(trimmed);
+    if (record === undefined) continue;
+    if ('deleted' in record) {
+      result.delete(record.sessionId);
+      continue;
+    }
+    const entry = record;
+    const sessionDir = normalizeWorkDir(entry.sessionDir);
     if (!isAbsolute(entry.sessionDir)) continue;
     if (!isPathInside(sessionsDir, sessionDir)) continue;
     if (basename(sessionDir) !== entry.sessionId) continue;
@@ -67,13 +96,16 @@ export async function readSessionIndex(
   return result;
 }
 
-function parseIndexLine(line: string): SessionIndexEntry | undefined {
+function parseIndexLine(line: string): SessionIndexRecord | undefined {
   try {
     const parsed = JSON.parse(line) as unknown;
     if (typeof parsed !== 'object' || parsed === null) return undefined;
-    const entry = parsed as Partial<SessionIndexEntry>;
+    const entry = parsed as Partial<SessionIndexEntry & SessionIndexDeletion>;
+    if (typeof entry.sessionId !== 'string') return undefined;
+    if (entry.deleted === true) {
+      return { sessionId: entry.sessionId, deleted: true };
+    }
     if (
-      typeof entry.sessionId !== 'string' ||
       typeof entry.sessionDir !== 'string' ||
       typeof entry.workDir !== 'string'
     ) {
@@ -90,6 +122,17 @@ function parseIndexLine(line: string): SessionIndexEntry | undefined {
 }
 
 function isPathInside(parent: string, child: string): boolean {
+  if (isWindowsAbsolutePath(parent) || isWindowsAbsolutePath(child)) {
+    const rel = nodePath.win32.relative(
+      nodePath.win32.resolve(parent),
+      nodePath.win32.resolve(child),
+    );
+    return rel !== '' && rel !== '..' && !rel.startsWith(`..${nodePath.win32.sep}`) && !nodePath.win32.isAbsolute(rel);
+  }
   const rel = relative(resolve(parent), resolve(child));
   return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
 }
+
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || /^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(value);
+}
diff --git a/packages/agent-core/src/session/store/session-store.ts b/packages/agent-core/src/session/store/session-store.ts
index d32379933..6e5e2ec72 100644
--- a/packages/agent-core/src/session/store/session-store.ts
+++ b/packages/agent-core/src/session/store/session-store.ts
@@ -1,14 +1,29 @@
+import type { Dirent } from 'node:fs';
 import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import * as nodePath from 'node:path';
 import { dirname, isAbsolute, join, relative, resolve } from 'pathe';
 
 import { z } from 'zod';
 
 import { ErrorCodes, KimiError } from '#/errors';
 import type { SessionIndexEntry } from '#/session/store/session-index';
-import { appendSessionIndexEntry, readSessionIndex } from '#/session/store/session-index';
+import {
+  appendSessionIndexDeletion,
+  appendSessionIndexEntry,
+  readSessionIndex,
+} from '#/session/store/session-index';
 import { encodeWorkDirKey, normalizeWorkDir } from '#/session/store/workdir-key';
+import {
+  promptMetadataTextFromPayload,
+  promptMetadataTextFromPluginCommand,
+  promptMetadataTextFromSkill,
+} from '#/session/prompt-metadata';
 import type { JsonObject, ListSessionsPayload, SessionSummary } from '#/rpc/core-api';
-import { FileSystemAgentRecordPersistence, type AgentRecordOf } from '../../agent/records';
+import {
+  FileSystemAgentRecordPersistence,
+  type AgentRecord,
+  type AgentRecordOf,
+} from '../../agent/records';
 
 const SessionSummaryStateSchema = z.object({
   archived: z.boolean().optional(),
@@ -34,6 +49,7 @@ export interface ForkSessionRecordInput {
   readonly targetId: string;
   readonly title?: string;
   readonly metadata?: JsonObject;
+  readonly turnIndex?: number;
 }
 
 export type SessionStoreOptions = Record<string, never>;
@@ -57,7 +73,7 @@ export class SessionStore {
     assertSafeSessionId(input.id);
     const workDir = normalizeWorkDir(input.workDir);
     const indexed = await this.findSessionEntry(input.id);
-    if (indexed !== undefined) {
+    if (indexed !== undefined && (await isDirectory(indexed.sessionDir))) {
       throw new KimiError(ErrorCodes.SESSION_ALREADY_EXISTS, `Session "${input.id}" already exists`);
     }
 
@@ -76,6 +92,7 @@ export class SessionStore {
   }
 
   async fork(input: ForkSessionRecordInput): Promise<SessionSummary> {
+    assertForkTurnIndex(input.turnIndex);
     const source = await this.findExistingSessionEntry(input.sourceId);
     assertSafeSessionId(input.targetId);
     const indexed = await this.findSessionEntry(input.targetId);
@@ -96,7 +113,20 @@ export class SessionStore {
         errorOnExist: true,
       });
       await dropForkedSessionFiles(targetDir);
-      const forkedState = await this.writeForkedState(input, source.sessionDir, source.workDir, targetDir);
+      const fullForkedState = await this.writeForkedState(
+        input,
+        source.sessionDir,
+        source.workDir,
+        targetDir,
+      );
+      const forkedState = input.turnIndex === undefined
+        ? fullForkedState
+        : await truncateForkedSessionAtTurn(
+            targetDir,
+            input.sourceId,
+            input.turnIndex,
+            fullForkedState,
+          );
       await appendForkedMarkers(forkedState);
       const summary = await this.summaryFromDir(input.targetId, targetDir, source.workDir);
       await appendSessionIndexEntry(this.homeDir, {
@@ -166,6 +196,12 @@ export class SessionStore {
     return this.summaryFromDir(id, entry.sessionDir, entry.workDir);
   }
 
+  async delete(id: string): Promise<void> {
+    const entry = await this.findExistingSessionEntry(id);
+    await rm(entry.sessionDir, { recursive: true, force: true });
+    await appendSessionIndexDeletion(this.homeDir, id);
+  }
+
   async list(options: ListSessionsPayload = {}): Promise<readonly SessionSummary[]> {
     const workDir =
       options.workDir === undefined ? undefined : normalizeRequiredWorkDir(options.workDir);
@@ -239,12 +275,12 @@ export class SessionStore {
         }
         // Refuse to index a session whose recorded workDir does not match the
         // bucket it lives in (corrupt or foreign state).
-        if (resolve(sessionDir) !== resolve(expectedDir)) continue;
+        if (!areSameFsPath(sessionDir, expectedDir)) continue;
 
         const existing = index.get(id);
         if (
           existing !== undefined &&
-          resolve(existing.sessionDir) === resolve(sessionDir) &&
+          areSameFsPath(existing.sessionDir, sessionDir) &&
           existing.workDir === workDir
         ) {
           continue;
@@ -284,14 +320,16 @@ export class SessionStore {
     includeArchive: boolean,
   ): Promise<readonly SessionSummary[]> {
     const bucketDir = join(this.sessionsDir, encodeWorkDirKey(workDir));
-    let entries;
+    let entries: Dirent[] = [];
     try {
       entries = await readdir(bucketDir, { withFileTypes: true });
     } catch {
-      return [];
+      // The same Windows directory may have an older bucket whose drive/share
+      // casing differs. The index fallback below can still recover it.
     }
 
     const sessions: SessionSummary[] = [];
+    const seen = new Set<string>();
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const id = entry.name;
@@ -300,6 +338,21 @@ export class SessionStore {
       const summary = await this.summaryFromDir(id, dir, workDir);
       if (!includeArchive && summary.archived === true) continue;
       sessions.push(summary);
+      seen.add(id);
+    }
+
+    // Do not change the established bucket hash: that would hide every
+    // existing Windows session after an upgrade. Instead merge indexed
+    // sessions whose persisted workDir names the same case-insensitive drive
+    // or UNC location (for example TUI `C:/Work` vs VS Code `c:\\Work`).
+    const index = await readSessionIndex(this.homeDir, this.sessionsDir);
+    for (const entry of index.values()) {
+      if (seen.has(entry.sessionId) || !(await isDirectory(entry.sessionDir))) continue;
+      const summary = await this.summaryFromDir(entry.sessionId, entry.sessionDir, entry.workDir);
+      if (!areSameFsPath(summary.workDir, workDir)) continue;
+      if (!includeArchive && summary.archived === true) continue;
+      sessions.push(summary);
+      seen.add(entry.sessionId);
     }
     sessions.sort(compareSessionSummary);
     return sessions;
@@ -457,6 +510,316 @@ async function dropForkedSessionFiles(sessionDir: string): Promise<void> {
   );
 }
 
+interface MainTurnSlice {
+  readonly records: readonly AgentRecord[];
+  readonly cutoffTime?: number;
+  readonly lastPrompt?: string;
+}
+
+async function truncateForkedSessionAtTurn(
+  sessionDir: string,
+  sourceSessionId: string,
+  turnIndex: number,
+  state: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  const agents = state['agents'];
+  if (!isRecord(agents) || !isRecord(agents['main'])) {
+    throw new KimiError(
+      ErrorCodes.SESSION_STATE_INVALID,
+      `Session "${sourceSessionId}" has no main agent metadata`,
+    );
+  }
+
+  const mainAgentDir = join(sessionDir, 'agents', 'main');
+  const mainPersistence = new FileSystemAgentRecordPersistence(
+    join(mainAgentDir, 'wire.jsonl'),
+  );
+  const mainRecords = await readAgentRecords(mainPersistence);
+  const mainSlice = sliceMainRecordsAtTurn(mainRecords, sourceSessionId, turnIndex);
+  mainPersistence.rewrite(mainSlice.records);
+  await mainPersistence.flush();
+
+  const retainedAgents: Record<string, unknown> = {
+    main: withAgentHomedir(agents['main'], mainAgentDir),
+  };
+  for (const [agentId, agentMeta] of Object.entries(agents)) {
+    if (agentId === 'main') continue;
+    const agentDir = join(sessionDir, 'agents', agentId);
+    const retained = await truncateSubagentAtTime(agentDir, mainSlice.cutoffTime);
+    if (retained) {
+      retainedAgents[agentId] = withAgentHomedir(agentMeta, agentDir);
+      continue;
+    }
+    await rm(agentDir, { recursive: true, force: true });
+  }
+  dropAgentsWithMissingParents(retainedAgents);
+
+  for (const agentId of Object.keys(agents)) {
+    if (retainedAgents[agentId] !== undefined) continue;
+    await rm(join(sessionDir, 'agents', agentId), { recursive: true, force: true });
+  }
+
+  for (const agentId of Object.keys(retainedAgents)) {
+    const agentDir = join(sessionDir, 'agents', agentId);
+    await Promise.all([
+      rm(join(agentDir, 'tasks'), { recursive: true, force: true }),
+      rm(join(agentDir, 'cron'), { recursive: true, force: true }),
+    ]);
+  }
+
+  const next = {
+    ...state,
+    lastPrompt: mainSlice.lastPrompt,
+    agents: retainedAgents,
+  };
+  await writeFile(join(sessionDir, 'state.json'), `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
+  return next;
+}
+
+function withAgentHomedir(agentMeta: unknown, homedir: string): unknown {
+  return isRecord(agentMeta) ? { ...agentMeta, homedir } : agentMeta;
+}
+
+async function readAgentRecords(
+  persistence: FileSystemAgentRecordPersistence,
+): Promise<readonly AgentRecord[]> {
+  const records: AgentRecord[] = [];
+  for await (const record of persistence.read()) {
+    records.push(record);
+  }
+  return records;
+}
+
+function sliceMainRecordsAtTurn(
+  records: readonly AgentRecord[],
+  sourceSessionId: string,
+  turnIndex: number,
+): MainTurnSlice {
+  const turnStarts: number[] = [];
+  for (let index = 0; index < records.length; index += 1) {
+    if (isUserVisibleTurnRecord(records[index]!)) turnStarts.push(index);
+  }
+  const start = turnStarts[turnIndex];
+  if (start === undefined) {
+    throw new KimiError(
+      ErrorCodes.REQUEST_INVALID,
+      `Turn ${String(turnIndex)} was not found in session "${sourceSessionId}"`,
+      { details: { turnIndex, availableTurns: turnStarts.length } },
+    );
+  }
+
+  const end = turnStarts[turnIndex + 1] ?? records.length;
+  const retainedTurnInputs = turnInputIndicesThrough(records, turnIndex);
+  const retained = records
+    .slice(0, end)
+    .filter(
+      (record, index) =>
+        !isUserVisibleTurnInputRecord(record) || retainedTurnInputs.has(index),
+    );
+  const cutoffTimes = retained
+    .map(recordTime)
+    .filter((time): time is number => time !== undefined);
+  const lastPrompt = promptMetadataFromTurnRecord(records[start]!);
+  return {
+    records: retained,
+    cutoffTime: cutoffTimes.length === 0 ? undefined : Math.max(...cutoffTimes),
+    lastPrompt,
+  };
+}
+
+async function truncateSubagentAtTime(
+  agentDir: string,
+  cutoffTime: number | undefined,
+): Promise<boolean> {
+  if (cutoffTime === undefined) return false;
+  const persistence = new FileSystemAgentRecordPersistence(join(agentDir, 'wire.jsonl'));
+  const records = await readAgentRecords(persistence);
+  let end = records.length;
+  for (let index = 0; index < records.length; index += 1) {
+    const time = recordTime(records[index]!);
+    if (time !== undefined && time > cutoffTime) {
+      end = index;
+      break;
+    }
+  }
+  const retained = records.slice(0, end);
+  if (retained.length === 0) return false;
+  persistence.rewrite(retained);
+  await persistence.flush();
+  return true;
+}
+
+function dropAgentsWithMissingParents(agents: Record<string, unknown>): void {
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [agentId, agentMeta] of Object.entries(agents)) {
+      if (agentId === 'main' || !isRecord(agentMeta)) continue;
+      const parentAgentId = agentMeta['parentAgentId'];
+      if (
+        typeof parentAgentId === 'string' &&
+        parentAgentId !== 'main' &&
+        agents[parentAgentId] === undefined
+      ) {
+        delete agents[agentId];
+        changed = true;
+      }
+    }
+  }
+}
+
+function recordTime(record: AgentRecord): number | undefined {
+  if (typeof record.time === 'number' && Number.isFinite(record.time)) return record.time;
+  if (
+    record.type === 'metadata' &&
+    typeof record.created_at === 'number' &&
+    Number.isFinite(record.created_at)
+  ) {
+    return record.created_at;
+  }
+  return undefined;
+}
+
+function isUserVisibleTurnRecord(record: AgentRecord): boolean {
+  if (record.type !== 'context.append_message') return false;
+  const { message } = record;
+  if (message.role !== 'user') return false;
+  switch (message.origin?.kind) {
+    case undefined:
+    case 'user':
+      return true;
+    case 'skill_activation':
+    case 'plugin_command':
+      return message.origin.trigger === 'user-slash';
+    case 'shell_command':
+      return message.origin.phase === 'input';
+    case 'background_task':
+    case 'compaction_summary':
+    case 'cron_job':
+    case 'cron_missed':
+    case 'hook_result':
+    case 'injection':
+    case 'retry':
+    case 'system_trigger':
+      return false;
+  }
+}
+
+function isUserVisibleTurnInputRecord(record: AgentRecord): boolean {
+  if (record.type !== 'turn.prompt' && record.type !== 'turn.steer') return false;
+  switch (record.origin.kind) {
+    case 'user':
+      return true;
+    case 'skill_activation':
+    case 'plugin_command':
+      return record.origin.trigger === 'user-slash';
+    case 'shell_command':
+      return record.origin.phase === 'input';
+    case 'background_task':
+    case 'compaction_summary':
+    case 'cron_job':
+    case 'cron_missed':
+    case 'hook_result':
+    case 'injection':
+    case 'retry':
+    case 'system_trigger':
+      return false;
+  }
+}
+
+function turnInputIndicesThrough(
+  records: readonly AgentRecord[],
+  turnIndex: number,
+): ReadonlySet<number> {
+  const pending: number[] = [];
+  const retained = new Set<number>();
+  let visibleTurnIndex = 0;
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index]!;
+    if (isUserVisibleTurnInputRecord(record)) {
+      pending.push(index);
+      continue;
+    }
+    if (!isUserVisibleTurnRecord(record)) continue;
+
+    const matchAt = findMatchingTurnInput(records, pending, record);
+    if (matchAt !== -1) {
+      const [inputIndex] = pending.splice(matchAt, 1);
+      if (visibleTurnIndex <= turnIndex && inputIndex !== undefined) {
+        retained.add(inputIndex);
+      }
+    }
+    visibleTurnIndex += 1;
+  }
+  return retained;
+}
+
+function findMatchingTurnInput(
+  records: readonly AgentRecord[],
+  pending: readonly number[],
+  turnRecord: AgentRecord,
+): number {
+  const exact = pending.findIndex((index) =>
+    turnInputMatchesRecord(records[index]!, turnRecord, true),
+  );
+  if (exact !== -1) return exact;
+  return pending.findIndex((index) =>
+    turnInputMatchesRecord(records[index]!, turnRecord, false),
+  );
+}
+
+function turnInputMatchesRecord(
+  inputRecord: AgentRecord,
+  turnRecord: AgentRecord,
+  compareContent: boolean,
+): boolean {
+  if (
+    (inputRecord.type !== 'turn.prompt' && inputRecord.type !== 'turn.steer') ||
+    turnRecord.type !== 'context.append_message' ||
+    turnRecord.message.role !== 'user'
+  ) {
+    return false;
+  }
+  if (!sameTurnOrigin(inputRecord.origin.kind, turnRecord.message.origin?.kind)) return false;
+  return !compareContent || JSON.stringify(inputRecord.input) === JSON.stringify(turnRecord.message.content);
+}
+
+function sameTurnOrigin(inputKind: string, messageKind: string | undefined): boolean {
+  if (inputKind === 'user') return messageKind === undefined || messageKind === 'user';
+  return inputKind === messageKind;
+}
+
+function promptMetadataFromTurnRecord(record: AgentRecord): string | undefined {
+  if (record.type !== 'context.append_message' || record.message.role !== 'user') {
+    return undefined;
+  }
+  const { message } = record;
+  if (message.origin?.kind === 'skill_activation') {
+    return promptMetadataTextFromSkill({
+      name: message.origin.skillName,
+      args: message.origin.skillArgs,
+    });
+  }
+  if (message.origin?.kind === 'plugin_command') {
+    return promptMetadataTextFromPluginCommand({
+      pluginId: message.origin.pluginId,
+      commandName: message.origin.commandName,
+      args: message.origin.commandArgs,
+    });
+  }
+  return promptMetadataTextFromPayload({ input: message.content });
+}
+
+function assertForkTurnIndex(turnIndex: number | undefined): void {
+  if (turnIndex === undefined) return;
+  if (Number.isSafeInteger(turnIndex) && turnIndex >= 0) return;
+  throw new KimiError(
+    ErrorCodes.REQUEST_INVALID,
+    'forkSession turnIndex must be a non-negative safe integer',
+    { details: { turnIndex } },
+  );
+}
+
 async function appendForkedMarkers(state: Record<string, unknown>): Promise<void> {
   const record: AgentRecordOf<'forked'> = { type: 'forked', time: Date.now() };
 
@@ -577,6 +940,17 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function areSameFsPath(left: string, right: string): boolean {
+  if (isWindowsAbsolutePath(left) || isWindowsAbsolutePath(right)) {
+    return nodePath.win32.resolve(left).toLowerCase() === nodePath.win32.resolve(right).toLowerCase();
+  }
+  return resolve(left) === resolve(right);
+}
+
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || /^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(value);
+}
+
 async function statIfExists(path: string): Promise<{ readonly mtimeMs: number } | undefined> {
   try {
     return await stat(path);
diff --git a/packages/agent-core/src/session/store/workdir-key.ts b/packages/agent-core/src/session/store/workdir-key.ts
index 7b1c7f801..3e9d1ce19 100644
--- a/packages/agent-core/src/session/store/workdir-key.ts
+++ b/packages/agent-core/src/session/store/workdir-key.ts
@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { win32 } from 'node:path';
 import { basename, resolve } from 'pathe';
 
 import { slugifyWorkDirName } from '#/utils/workdir-slug';
@@ -7,6 +8,9 @@ const WORKDIR_KEY_PREFIX = 'wd_';
 const HASH_LENGTH = 12;
 
 export function normalizeWorkDir(workDir: string): string {
+  if (isWindowsAbsolutePath(workDir)) {
+    return win32.resolve(workDir).replaceAll('\\', '/');
+  }
   return resolve(workDir);
 }
 
@@ -16,3 +20,7 @@ export function encodeWorkDirKey(workDir: string): string {
   const hash = createHash('sha256').update(normalized).digest('hex').slice(0, HASH_LENGTH);
   return `${WORKDIR_KEY_PREFIX}${slug}_${hash}`;
 }
+
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || /^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(value);
+}
diff --git a/packages/agent-core/src/session/store/workspace-registry-file.ts b/packages/agent-core/src/session/store/workspace-registry-file.ts
new file mode 100644
index 000000000..8671b1c44
--- /dev/null
+++ b/packages/agent-core/src/session/store/workspace-registry-file.ts
@@ -0,0 +1,164 @@
+/**
+ * `workspaces.json` file format and atomic access — the on-disk contract of
+ * the known-workspaces catalog, shared by `WorkspaceRegistryService` (the
+ * services-layer facade, which adds locking and events on top) and by
+ * in-process runtime callers that only need a best-effort touch (e.g.
+ * `KimiCore` registering the cwd on session creation). It lives next to
+ * `session-index.ts` because the runtime must not import back into
+ * `services/` (see `src/services/AGENTS.md`).
+ *
+ * The layout is the v1-compatible `{ version, workspaces, deleted_workspace_ids }`
+ * document at `<homeDir>/workspaces.json`; agent-core-v2 reads and writes the
+ * same file, so both engines must agree on this shape.
+ */
+
+import { promises as fsp } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { basename as posixBasename } from 'pathe';
+
+import { encodeWorkDirKey, normalizeWorkDir } from '#/session/store/workdir-key';
+
+const WORKSPACE_REGISTRY_FILE = 'workspaces.json';
+const WORKSPACE_REGISTRY_VERSION = 1;
+
+export interface WorkspaceRegistryEntry {
+  root: string;
+  name: string;
+  created_at: string;
+  last_opened_at: string;
+}
+
+export interface WorkspaceRegistryFile {
+  version: number;
+  workspaces: Record<string, WorkspaceRegistryEntry>;
+  /** Workspace ids the user explicitly removed. Their session buckets stay on
+   *  disk, so derived workspaces (computed from the session index) must skip
+   *  them to keep deletion durable. */
+  deleted_workspace_ids: string[];
+}
+
+/** Diagnostic hook for malformed-content warnings; `(context, message)`. */
+export type WorkspaceRegistryWarn = (context: object, message: string) => void;
+
+function emptyRegistryFile(): WorkspaceRegistryFile {
+  return { version: WORKSPACE_REGISTRY_VERSION, workspaces: {}, deleted_workspace_ids: [] };
+}
+
+/** Read `<homeDir>/workspaces.json`, tolerating a missing or malformed file
+ *  (both yield an empty catalog). Unknown fields are ignored; entries failing
+ *  sanitization are dropped. */
+export async function readWorkspaceRegistryFile(
+  homeDir: string,
+  warn?: WorkspaceRegistryWarn,
+): Promise<WorkspaceRegistryFile> {
+  const registryPath = join(homeDir, WORKSPACE_REGISTRY_FILE);
+  let raw: string;
+  try {
+    raw = await fsp.readFile(registryPath, 'utf8');
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT' || code === 'ENOTDIR') {
+      return emptyRegistryFile();
+    }
+    throw err;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    warn?.({ path: registryPath, err: String(err) }, 'workspaces.json malformed; treating as empty');
+    return emptyRegistryFile();
+  }
+  if (
+    typeof parsed !== 'object' ||
+    parsed === null ||
+    typeof (parsed as { workspaces?: unknown }).workspaces !== 'object' ||
+    (parsed as { workspaces?: unknown }).workspaces === null
+  ) {
+    warn?.({ path: registryPath }, 'workspaces.json missing required keys; treating as empty');
+    return emptyRegistryFile();
+  }
+  const rawWorkspaces = (parsed as { workspaces: Record<string, unknown> }).workspaces;
+  const workspaces: Record<string, WorkspaceRegistryEntry> = {};
+  for (const [id, value] of Object.entries(rawWorkspaces)) {
+    const entry = sanitizeWorkspaceRegistryEntry(value);
+    if (entry !== null) {
+      workspaces[id] = entry;
+    }
+  }
+  const version =
+    typeof (parsed as { version?: unknown }).version === 'number'
+      ? (parsed as { version: number }).version
+      : WORKSPACE_REGISTRY_VERSION;
+  const rawDeleted = (parsed as { deleted_workspace_ids?: unknown }).deleted_workspace_ids;
+  const deleted_workspace_ids = Array.isArray(rawDeleted)
+    ? rawDeleted.filter((id): id is string => typeof id === 'string')
+    : [];
+  return { version, workspaces, deleted_workspace_ids };
+}
+
+/** Atomically write `<homeDir>/workspaces.json` (tmp file + rename). */
+export async function writeWorkspaceRegistryFile(
+  homeDir: string,
+  file: WorkspaceRegistryFile,
+): Promise<void> {
+  const registryPath = join(homeDir, WORKSPACE_REGISTRY_FILE);
+  await fsp.mkdir(dirname(registryPath), { recursive: true, mode: 0o700 });
+  const tmp = `${registryPath}.tmp`;
+  await fsp.writeFile(tmp, JSON.stringify(file, null, 2), 'utf8');
+  await fsp.rename(tmp, registryPath);
+}
+
+/**
+ * Best-effort read-modify-write: register `root` in `<homeDir>/workspaces.json`
+ * (or bump its `last_opened_at` when already present). An explicit touch clears
+ * any prior deletion tombstone for the workspace id.
+ *
+ * Unlike `WorkspaceRegistryService.createOrTouch` this performs no
+ * root-existence check and publishes no events; callers must treat failures as
+ * non-fatal (the catalog is a hint, not session state). Concurrent writers in
+ * other processes cannot corrupt the file (atomic rename), though a lost
+ * update is possible — the next session-index merge heals missing entries.
+ */
+export async function touchWorkspaceRegistry(
+  homeDir: string,
+  root: string,
+  name?: string,
+): Promise<{ workspaceId: string; created: boolean }> {
+  const normalizedRoot = normalizeWorkDir(root);
+  const workspaceId = encodeWorkDirKey(normalizedRoot);
+  const now = new Date().toISOString();
+  const file = await readWorkspaceRegistryFile(homeDir);
+  const existing = file.workspaces[workspaceId];
+  file.workspaces[workspaceId] =
+    existing !== undefined
+      ? { ...existing, last_opened_at: now }
+      : {
+          root: normalizedRoot,
+          name: name ?? posixBasename(normalizedRoot),
+          created_at: now,
+          last_opened_at: now,
+        };
+  file.deleted_workspace_ids = file.deleted_workspace_ids.filter((id) => id !== workspaceId);
+  await writeWorkspaceRegistryFile(homeDir, file);
+  return { workspaceId, created: existing === undefined };
+}
+
+function sanitizeWorkspaceRegistryEntry(value: unknown): WorkspaceRegistryEntry | null {
+  if (typeof value !== 'object' || value === null) return null;
+  const v = value as Partial<WorkspaceRegistryEntry>;
+  if (
+    typeof v.root !== 'string' ||
+    typeof v.name !== 'string' ||
+    typeof v.created_at !== 'string' ||
+    typeof v.last_opened_at !== 'string'
+  ) {
+    return null;
+  }
+  return {
+    root: v.root,
+    name: v.name,
+    created_at: v.created_at,
+    last_opened_at: v.last_opened_at,
+  };
+}
diff --git a/packages/agent-core/src/session/subagent-batch.ts b/packages/agent-core/src/session/subagent-batch.ts
index 317bcfab4..7646de387 100644
--- a/packages/agent-core/src/session/subagent-batch.ts
+++ b/packages/agent-core/src/session/subagent-batch.ts
@@ -622,7 +622,7 @@ export class SubagentBatch<T> {
       attempt.controller.abort(task.signal?.reason);
     };
     const timeout =
-      task.timeout === undefined
+      task.timeout === undefined || task.timeout <= 0
         ? undefined
         : setTimeout(() => {
             attempt.timedOut = true;
diff --git a/packages/agent-core/src/session/subagent-host.ts b/packages/agent-core/src/session/subagent-host.ts
index d6c4b6369..51a6a99f0 100644
--- a/packages/agent-core/src/session/subagent-host.ts
+++ b/packages/agent-core/src/session/subagent-host.ts
@@ -37,18 +37,18 @@ const SUBAGENT_TIMEOUT_ENV = 'KIMI_SUBAGENT_TIMEOUT_MS';
 
 /**
  * Resolve the effective subagent per-task timeout. Precedence:
- * `KIMI_SUBAGENT_TIMEOUT_MS` (positive integer ms) → `configMs` →
- * `DEFAULT_SUBAGENT_TIMEOUT_MS` (30 min). Set a large value to effectively
- * disable the cap. The value feeds the background-task manager's per-task
- * timeout, so it governs foreground and background subagents (and AgentSwarm).
+ * `KIMI_SUBAGENT_TIMEOUT_MS` (integer ms) → `configMs` →
+ * `DEFAULT_SUBAGENT_TIMEOUT_MS` (2 hours). `0` means no timeout: the value
+ * feeds the background-task manager's per-task timeout (where `0` arms no
+ * timer), so it governs foreground and background subagents (and AgentSwarm).
  */
 export function resolveSubagentTimeoutMs(configMs?: number): number {
   const raw = process.env[SUBAGENT_TIMEOUT_ENV];
   if (raw !== undefined && raw.trim().length > 0) {
     const parsed = Number(raw);
-    if (Number.isInteger(parsed) && parsed >= 1) return parsed;
+    if (Number.isInteger(parsed) && parsed >= 0) return parsed;
   }
-  if (configMs !== undefined && Number.isInteger(configMs) && configMs >= 1) {
+  if (configMs !== undefined && Number.isInteger(configMs) && configMs >= 0) {
     return configMs;
   }
   return DEFAULT_SUBAGENT_TIMEOUT_MS;
@@ -369,6 +369,7 @@ export class SessionSubagentHost {
     options: RunSubagentOptions,
   ): Promise<SubagentCompletion> {
     await runChildTurnToCompletion(child, options.signal);
+    await this.drainChildBackgroundTasks(child, options.signal);
 
     // A subagent that returns an overly terse summary leaves the parent
     // agent under-informed. Give it a bounded number of chances to expand
@@ -416,6 +417,49 @@ export class SessionSubagentHost {
     child.tools.inheritUserTools(parent.tools);
   }
 
+  /**
+   * Hold the run open until the child agent's background tasks (background
+   * Bash, nested background agents) settle — the print-mode (`kimi -p`)
+   * drain semantics applied to subagent completion. Drained tasks get their
+   * terminal notifications suppressed: without that, a task outliving the
+   * child's final turn steers a fresh turn on the finished subagent
+   * (`steer` degrades to `launch`), which runs unobserved and whose output
+   * never reaches the parent. Bounded by the run's signal — the Agent
+   * tool's per-run timeout / user-cancel envelope covers the drain too.
+   */
+  private async drainChildBackgroundTasks(child: Agent, signal: AbortSignal): Promise<void> {
+    for (;;) {
+      signal.throwIfAborted();
+      await this.suppressChildTaskNotifications(child);
+      await child.background.waitForActiveTasks(() => true, { signal });
+      // Suppress again after the wait: notification delivery re-checks
+      // suppression after its async output snapshot, so this pass still
+      // blocks notifications for tasks that settled during the wait.
+      await this.suppressChildTaskNotifications(child);
+      // A terminal effect that slipped past the suppression race may have
+      // steered a follow-up turn onto the child; let it finish (it can fan
+      // out new tasks) before declaring the child drained.
+      if (child.turn.hasActiveTurn) {
+        await runChildTurnToCompletion(child, signal);
+        continue;
+      }
+      if (child.background.list(true).length === 0) return;
+    }
+  }
+
+  /**
+   * Suppress terminal notifications for every child background task —
+   * including already-settled ones whose notification may still be in
+   * flight. `list(false)` is required: the active-only list drops a task
+   * the moment it terminates, which is exactly when an unsuppressed
+   * notification can still steer an orphan turn onto the finished child.
+   */
+  private async suppressChildTaskNotifications(child: Agent): Promise<void> {
+    for (const task of child.background.list(false)) {
+      await child.background.suppressTerminalNotification(task.taskId);
+    }
+  }
+
   private async triggerSubagentStart(
     parent: Agent,
     profileName: string,
diff --git a/packages/agent-core/src/skill/builtin/check-kimi-code-docs.md b/packages/agent-core/src/skill/builtin/check-kimi-code-docs.md
new file mode 100644
index 000000000..f64d179fe
--- /dev/null
+++ b/packages/agent-core/src/skill/builtin/check-kimi-code-docs.md
@@ -0,0 +1,44 @@
+---
+name: check-kimi-code-docs
+description: Answer questions about the Kimi Code product using the official documentation — CLI usage, configuration, slash commands, features, membership and quota, API onboarding, third-party tool setup, and error codes. Use when the user asks how Kimi Code works, how to set something up, or what a Kimi Code error message means.
+---
+
+# Check Kimi Code docs (check-kimi-code-docs)
+
+Answer Kimi Code **product** questions from the official documentation site, not from memory. This skill covers product usage ("how do I configure a provider", "what does this error mean", "how does membership quota work"); it is not for developing the Kimi Code repository itself.
+
+## The single source of truth
+
+Official documentation (English):
+
+```
+https://www.kimi.com/code/docs/en/
+```
+
+Fetch pages with **FetchURL** before answering. All page links below are relative to this base.
+
+## Which page to read for which question
+
+| Question topic | Page (relative to the base URL) |
+| --- | --- |
+| What Kimi Code is; Base URL / API Key; standard vs high-speed model; platform comparison | `./` (home overview) |
+| Membership plans, quota and rate limits, fuel packs | `kimi-code/membership.html` |
+| Install / login / usage FAQ | `kimi-code/faq.html` |
+| Error codes and their meaning (e.g. 401 for high-speed model access) | `kimi-code/error-reference.html` |
+| Product news and recent changes | `kimi-code/whats-new.html` |
+| Community guidelines; contact and feedback | `kimi-code/community-guidelines.html`, `kimi-code/contact-and-feedback.html` |
+| `config.toml` fields, providers/models, environment variables, data locations, config overrides | `kimi-code-cli/configuration/` — `config-files.html`, `providers.html`, `env-vars.html`, `data-locations.html`, `overrides.html` |
+| Skills, MCP, hooks, plugins, themes, agents/sub-agents, Kimi Datasource | `kimi-code-cli/customization/` — `skills.html`, `mcp.html`, `hooks.html`, `plugins.html`, `themes.html`, `agents.html`; Kimi Datasource lives at `plugins.html#kimi-datasource` |
+| Getting started, sessions and context, goals, interaction and input, IDEs, migration, use cases | `kimi-code-cli/guides/` — `getting-started.html`, `sessions.html`, `goals.html`, `interaction.html`, `ides.html`, `migration.html`, `use-cases.html` |
+| Slash commands, keyboard shortcuts, builtin tools, `kimi` command flags, ACP | `kimi-code-cli/reference/` — `slash-commands.html`, `keyboard.html`, `tools.html`, `kimi-command.html`, `kimi-acp.html` |
+| CLI changelog | `kimi-code-cli/release-notes/changelog.html` |
+| Using Kimi Code in Claude Code and other third-party agents | `third-party-tools/other-coding-agents.html` |
+
+If no row fits the question, fetch the docs home page and follow its navigation links.
+
+## How to answer
+
+1. Pick the page from the table above.
+2. **FetchURL the page before answering** — answer strictly from the fetched content, never from memory.
+3. Cite the page link(s) you used at the end of the answer.
+4. If the fetch fails or the docs do not cover the question, say so plainly: answer from what you already know, attach the docs entry link (`https://www.kimi.com/code/docs/en/`), and mark which parts you could not verify. **Never invent config keys, command names, model IDs, or product behaviors.**
diff --git a/packages/agent-core/src/skill/builtin/check-kimi-code-docs.ts b/packages/agent-core/src/skill/builtin/check-kimi-code-docs.ts
new file mode 100644
index 000000000..f99275c71
--- /dev/null
+++ b/packages/agent-core/src/skill/builtin/check-kimi-code-docs.ts
@@ -0,0 +1,22 @@
+import { parseSkillText } from '../parser';
+import type { SkillDefinition } from '../types';
+import CHECK_KIMI_CODE_DOCS_BODY from './check-kimi-code-docs.md?raw';
+
+const PSEUDO_PATH = 'builtin://check-kimi-code-docs';
+
+const parsed = parseSkillText({
+  skillMdPath: '/builtin/skills/check-kimi-code-docs.md',
+  skillDirName: 'check-kimi-code-docs',
+  source: 'builtin',
+  text: CHECK_KIMI_CODE_DOCS_BODY,
+});
+
+export const CHECK_KIMI_CODE_DOCS_SKILL: SkillDefinition = {
+  ...parsed,
+  path: PSEUDO_PATH,
+  dir: PSEUDO_PATH,
+  metadata: {
+    ...parsed.metadata,
+    type: parsed.metadata.type ?? 'inline',
+  },
+};
diff --git a/packages/agent-core/src/skill/builtin/index.ts b/packages/agent-core/src/skill/builtin/index.ts
index a5150815e..ff13ae84a 100644
--- a/packages/agent-core/src/skill/builtin/index.ts
+++ b/packages/agent-core/src/skill/builtin/index.ts
@@ -1,4 +1,5 @@
 import type { SessionSkillRegistry } from '../registry';
+import { CHECK_KIMI_CODE_DOCS_SKILL } from './check-kimi-code-docs';
 import { CUSTOM_THEME_SKILL } from './custom-theme';
 import { IMPORT_FROM_CC_CODEX_SKILL } from './import-from-cc-codex';
 import { MCP_CONFIG_SKILL } from './mcp-config';
@@ -16,12 +17,14 @@ export function registerBuiltinSkills(registry: SessionSkillRegistry): void {
   registry.registerBuiltinSkill(UPDATE_CONFIG_SKILL);
   registry.registerBuiltinSkill(CUSTOM_THEME_SKILL);
   registry.registerBuiltinSkill(WRITE_GOAL_SKILL);
+  registry.registerBuiltinSkill(CHECK_KIMI_CODE_DOCS_SKILL);
   registry.registerBuiltinSkill(SUB_SKILL_PARENT);
   registry.registerBuiltinSkill(SUB_SKILL_REVIEW);
   registry.registerBuiltinSkill(SUB_SKILL_CONSOLIDATE);
 }
 
 export {
+  CHECK_KIMI_CODE_DOCS_SKILL,
   CUSTOM_THEME_SKILL,
   IMPORT_FROM_CC_CODEX_SKILL,
   MCP_CONFIG_SKILL,
diff --git a/packages/agent-core/src/tools/builtin/collaboration/agent-swarm.ts b/packages/agent-core/src/tools/builtin/collaboration/agent-swarm.ts
index a4b685380..7bcaa599a 100644
--- a/packages/agent-core/src/tools/builtin/collaboration/agent-swarm.ts
+++ b/packages/agent-core/src/tools/builtin/collaboration/agent-swarm.ts
@@ -91,6 +91,8 @@ export class AgentSwarmTool implements BuiltinTool<AgentSwarmToolInput> {
   constructor(
     private readonly subagentHost: SessionSubagentHost,
     private readonly swarmMode: SwarmMode,
+    // `0` = no timeout, preserved on purpose (`0 ?? DEFAULT` stays `0`);
+    // SubagentBatch arms no timer for non-positive timeouts.
     private readonly subagentTimeoutMs?: number,
   ) {}
 
diff --git a/packages/agent-core/src/tools/builtin/collaboration/agent.ts b/packages/agent-core/src/tools/builtin/collaboration/agent.ts
index f0abf3e3f..e12a8c16d 100644
--- a/packages/agent-core/src/tools/builtin/collaboration/agent.ts
+++ b/packages/agent-core/src/tools/builtin/collaboration/agent.ts
@@ -120,6 +120,8 @@ export class AgentTool implements BuiltinTool<AgentToolInput> {
   ) {
     const log = options?.log;
     this.allowBackground = options?.allowBackground ?? true;
+    // `0` is preserved (not normalized): `0 ?? DEFAULT_SUBAGENT_TIMEOUT_MS`
+    // stays `0`, and the BackgroundManager arms no timer for it.
     this.subagentTimeoutMs = options?.subagentTimeoutMs;
     const typeLines = buildSubagentDescriptions(subagents);
     const baseDescription = `${AGENT_DESCRIPTION_BASE}\n\n${
diff --git a/packages/agent-core/src/tools/builtin/collaboration/ask-user.ts b/packages/agent-core/src/tools/builtin/collaboration/ask-user.ts
index 1b85bb17e..e42adb58e 100644
--- a/packages/agent-core/src/tools/builtin/collaboration/ask-user.ts
+++ b/packages/agent-core/src/tools/builtin/collaboration/ask-user.ts
@@ -156,6 +156,7 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
     {
       toolCallId,
       signal,
+      traceId,
       turnId,
     }: ExecutableToolContext,
   ): Promise<ExecutableToolResult> {
@@ -167,10 +168,10 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
     }
 
     if (args.background === true) {
-      return this.executeInBackground(args, { toolCallId, turnId, signal });
+      return this.executeInBackground(args, { toolCallId, turnId, signal, traceId });
     }
 
-    return this.executeQuestion(args, { toolCallId, turnId, signal });
+    return this.executeQuestion(args, { toolCallId, turnId, signal, traceId });
   }
 
   private inputSchema(): z.ZodType<AskUserQuestionInput> {
@@ -182,8 +183,9 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
     {
       toolCallId,
       signal,
+      traceId,
       turnId,
-    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'turnId'>,
+    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'traceId' | 'turnId'>,
   ): Promise<ExecutableToolResult> {
     try {
       const result = await this.agent.rpc!.requestQuestion!(
@@ -205,12 +207,15 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
 
       const normalized = normalizeQuestionResult(result);
       if (normalized === null || Object.keys(normalized.answers).length === 0) {
-        this.agent.telemetry.track('question_dismissed');
+        this.agent.telemetry.track('question_dismissed', {
+          trace_id: traceId,
+        });
         return dismissedQuestionResult();
       }
 
       const properties: Record<string, TelemetryPropertyValue> = {
         answered: Object.keys(normalized.answers).length,
+        trace_id: traceId,
       };
       if (normalized.method !== undefined) properties['method'] = normalized.method;
       this.agent.telemetry.track('question_answered', properties);
@@ -237,8 +242,9 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
     {
       toolCallId,
       signal,
+      traceId,
       turnId,
-    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'turnId'>,
+    }: Pick<ExecutableToolContext, 'toolCallId' | 'signal' | 'traceId' | 'turnId'>,
   ): ExecutableToolResult {
     if (signal.aborted) {
       signal.throwIfAborted();
@@ -250,7 +256,8 @@ export class AskUserQuestionTool implements BuiltinTool<AskUserQuestionInput> {
     try {
       taskId = backgroundManager.registerTask(
         new QuestionBackgroundTask(
-          (taskSignal) => this.executeQuestion(args, { toolCallId, turnId, signal: taskSignal }),
+          (taskSignal) =>
+            this.executeQuestion(args, { toolCallId, turnId, signal: taskSignal, traceId }),
           description,
           {
             questionCount: args.questions.length,
diff --git a/packages/agent-core/src/tools/builtin/shell/bash.ts b/packages/agent-core/src/tools/builtin/shell/bash.ts
index c9966ee09..020dd597d 100644
--- a/packages/agent-core/src/tools/builtin/shell/bash.ts
+++ b/packages/agent-core/src/tools/builtin/shell/bash.ts
@@ -116,10 +116,9 @@ function isValidTimeoutValue(timeout: number, isBackground: boolean): boolean {
   return timeout <= timeoutCapS(isBackground);
 }
 
-function normalizeTimeoutMs(timeout: number | undefined, isBackground: boolean): number {
-  const defaultSeconds = isBackground ? DEFAULT_BACKGROUND_TIMEOUT_S : DEFAULT_TIMEOUT_S;
-  const value = timeout ?? defaultSeconds;
-  return Math.min(value, timeoutCapS(isBackground)) * MS_PER_SECOND;
+function normalizeForegroundTimeoutMs(timeout: number | undefined): number {
+  const value = timeout ?? DEFAULT_TIMEOUT_S;
+  return Math.min(value, MAX_TIMEOUT_S) * MS_PER_SECOND;
 }
 
 async function disposeProcess(proc: KaosProcess): Promise<void> {
@@ -162,10 +161,44 @@ function withoutAutoBackgroundOnTimeout(description: string): string {
   );
 }
 
+/**
+ * Rewrite the background-timeout sentence when the effective default is "no
+ * timeout" (`background.bash_task_timeout_s = 0`): the model must not be told
+ * tasks die at 600s, nor nudged into defensive `disable_timeout` /
+ * `timeout` arguments — an explicit `timeout` is honored and still capped.
+ */
+function withoutBackgroundDefaultTimeout(description: string): string {
+  return description.replace(
+    `Background commands default to a ${String(DEFAULT_BACKGROUND_TIMEOUT_S)}s timeout and \`timeout\` is capped at ${String(MAX_BACKGROUND_TIMEOUT_S)}s; set \`disable_timeout=true\` only when the task should run without a timeout.`,
+    `Background commands have no timeout by default; set \`timeout\` (max ${String(MAX_BACKGROUND_TIMEOUT_S)}s) only when the task should be bounded.`,
+  );
+}
+
+/**
+ * Keep the JSON-schema `timeout` parameter description in sync with an
+ * unbounded background default (`withoutBackgroundDefaultTimeout` covers the
+ * prose description; the model reads parameter descriptions too).
+ */
+function withoutBackgroundDefaultTimeoutInParameters(
+  parameters: Record<string, unknown>,
+): Record<string, unknown> {
+  const properties = parameters['properties'];
+  if (typeof properties !== 'object' || properties === null) return parameters;
+  const timeout = (properties as Record<string, unknown>)['timeout'];
+  if (typeof timeout !== 'object' || timeout === null) return parameters;
+  const current = (timeout as Record<string, unknown>)['description'];
+  if (typeof current !== 'string') return parameters;
+  (timeout as Record<string, unknown>)['description'] = current.replace(
+    `Background default ${String(DEFAULT_BACKGROUND_TIMEOUT_S)}s,`,
+    'Background default no timeout;',
+  );
+  return parameters;
+}
+
 export class BashTool implements BuiltinTool<BashInput> {
   readonly name = 'Bash' as const;
   readonly description: string;
-  readonly parameters: Record<string, unknown> = toInputJsonSchema(BashInputSchema);
+  readonly parameters: Record<string, unknown>;
 
   private readonly isWindowsBash: boolean;
 
@@ -173,6 +206,13 @@ export class BashTool implements BuiltinTool<BashInput> {
 
   private readonly autoBackgroundOnTimeout: boolean;
 
+  /**
+   * Default deadline for background tasks when the call omits `timeout`, and
+   * the re-armed deadline for foreground commands moved to the background.
+   * `undefined` arms no timer at all (`background.bash_task_timeout_s = 0`).
+   */
+  private readonly backgroundTimeoutMs: number | undefined;
+
   constructor(
     private readonly kaos: Kaos,
     private readonly cwd: string,
@@ -180,17 +220,34 @@ export class BashTool implements BuiltinTool<BashInput> {
     options?: {
       allowBackground?: boolean | undefined;
       autoBackgroundOnTimeout?: boolean;
+      /**
+       * Effective background default timeout in seconds
+       * (`background.bash_task_timeout_s`; `0` = no timeout). Defaults to
+       * {@link DEFAULT_BACKGROUND_TIMEOUT_S} when unset.
+       */
+      backgroundTimeoutS?: number;
     },
   ) {
     this.isWindowsBash = this.kaos.osEnv.osKind === 'Windows';
     this.allowBackground = options?.allowBackground ?? true;
     this.autoBackgroundOnTimeout = options?.autoBackgroundOnTimeout ?? true;
+    const backgroundTimeoutS = options?.backgroundTimeoutS ?? DEFAULT_BACKGROUND_TIMEOUT_S;
+    this.backgroundTimeoutMs =
+      backgroundTimeoutS === 0 ? undefined : backgroundTimeoutS * MS_PER_SECOND;
     const rendered = renderBashDescription(this.kaos.osEnv.shellName);
+    const withEffectiveDefault =
+      this.backgroundTimeoutMs === undefined
+        ? withoutBackgroundDefaultTimeout(rendered)
+        : rendered;
     this.description = !this.allowBackground
-      ? withoutBackgroundDescription(rendered)
+      ? withoutBackgroundDescription(withEffectiveDefault)
       : this.autoBackgroundOnTimeout
-        ? rendered
-        : withoutAutoBackgroundOnTimeout(rendered);
+        ? withEffectiveDefault
+        : withoutAutoBackgroundOnTimeout(withEffectiveDefault);
+    this.parameters =
+      this.backgroundTimeoutMs === undefined
+        ? withoutBackgroundDefaultTimeoutInParameters(toInputJsonSchema(BashInputSchema))
+        : toInputJsonSchema(BashInputSchema);
   }
 
   resolveExecution(args: BashInput): ToolExecution {
@@ -240,6 +297,16 @@ export class BashTool implements BuiltinTool<BashInput> {
     return this.kaos.execWithEnv(shellArgs, mergedEnv);
   }
 
+  /**
+   * Background deadline: an explicit `timeout` wins (the schema caps it at
+   * `MAX_BACKGROUND_TIMEOUT_S`); otherwise the configured default — which is
+   * `undefined` (no timer armed) when `background.bash_task_timeout_s = 0`.
+   */
+  private backgroundDefaultTimeoutMs(timeout: number | undefined): number | undefined {
+    if (timeout !== undefined) return Math.min(timeout, MAX_BACKGROUND_TIMEOUT_S) * MS_PER_SECOND;
+    return this.backgroundTimeoutMs;
+  }
+
   private async execution(
     args: BashInput,
     signal: AbortSignal,
@@ -250,14 +317,14 @@ export class BashTool implements BuiltinTool<BashInput> {
     if (validationError !== undefined) return validationError;
 
     const startsInBackground = args.run_in_background === true;
-    const foregroundTimeoutMs = normalizeTimeoutMs(args.timeout, false);
+    const foregroundTimeoutMs = normalizeForegroundTimeoutMs(args.timeout);
     const command = this.isWindowsBash ? rewriteWindowsNullRedirect(args.command) : args.command;
     const effectiveCwd = args.cwd ?? this.cwd;
     const description = startsInBackground ? args.description!.trim() : foregroundDescription(args);
     const timeoutMs = startsInBackground
       ? args.disable_timeout
         ? undefined
-        : normalizeTimeoutMs(args.timeout, true)
+        : this.backgroundDefaultTimeoutMs(args.timeout)
       : foregroundTimeoutMs;
 
     const builder = new ToolResultBuilder();
@@ -295,9 +362,13 @@ export class BashTool implements BuiltinTool<BashInput> {
           detached: startsInBackground,
           timeoutMs,
           // Detaching (ctrl+b) moves a foreground command to the background;
-          // give it the background timeout so it is not still bounded by the
-          // shorter foreground deadline.
-          detachTimeoutMs: DEFAULT_BACKGROUND_TIMEOUT_S * MS_PER_SECOND,
+          // give it the background default so it is not still bounded by the
+          // shorter foreground deadline. When the config disables the
+          // background timeout this must be `0`, not `undefined`: `detach()`
+          // only re-arms when the value is defined, so `undefined` would keep
+          // the already-armed foreground deadline and kill the task anyway
+          // (`reset(0)` clears the timer and arms nothing).
+          detachTimeoutMs: this.backgroundTimeoutMs ?? 0,
           // A foreground command that hits its timeout is moved to the
           // background (re-armed to detachTimeoutMs) instead of being killed —
           // unless disabled via config, or background tooling is unavailable
diff --git a/packages/agent-core/src/tools/builtin/state/todo-list.ts b/packages/agent-core/src/tools/builtin/state/todo-list.ts
index 852042e19..03907509f 100644
--- a/packages/agent-core/src/tools/builtin/state/todo-list.ts
+++ b/packages/agent-core/src/tools/builtin/state/todo-list.ts
@@ -105,6 +105,10 @@ export class TodoListTool implements BuiltinTool<TodoListInput> {
           : 'Updating todo list';
     return {
       description,
+      display: {
+        kind: 'todo_list',
+        items: (args.todos ?? this.getTodos()).map((todo) => ({ ...todo })),
+      },
       approvalRule: this.name,
       execute: async () => {
         // Query mode — return the current list without mutation.
diff --git a/packages/agent-core/src/tools/providers/local-fetch-url.ts b/packages/agent-core/src/tools/providers/local-fetch-url.ts
index af10a8ca3..1b8e50844 100644
--- a/packages/agent-core/src/tools/providers/local-fetch-url.ts
+++ b/packages/agent-core/src/tools/providers/local-fetch-url.ts
@@ -2,7 +2,10 @@
  * LocalFetchURLProvider — host-side URL fetcher.
  *
  * Flow:
- *   1. GET the URL with a Chrome-like UA.
+ *   1. Validate the URL against the SSRF rules (scheme, IP literals, DNS
+ *      resolution) and GET it with a Chrome-like UA, following redirects
+ *      manually with every hop re-validated and pinned to the validated
+ *      addresses.
  *   2. Reject HTTP >= 400 with the status code in the message.
  *   3. Reject responses larger than `maxBytes` (content-length first,
  *      then measured body length as a defensive second check).
@@ -14,9 +17,15 @@
  *      before throwing a "meaningful content" error.
  */
 
+import { lookup as callbackLookup, type LookupAddress, type LookupOptions } from 'node:dns';
+import { lookup } from 'node:dns/promises';
+import { BlockList, isIP, type LookupFunction } from 'node:net';
+
 import { Readability } from '@mozilla/readability';
 import { parseHTML as rawParseHTML } from 'linkedom';
+import { Agent, type Dispatcher } from 'undici';
 
+import { isProxyConfigured, makeNoProxyMatcher, resolveNoProxy } from '../../utils/proxy';
 import { HttpFetchError, type UrlFetcher, type UrlFetchResult } from '../builtin';
 
 // Readability's .d.ts references the global `Document` type, but this
@@ -43,6 +52,10 @@ const DEFAULT_USER_AGENT =
 
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 
+const MAX_REDIRECT_HOPS = 10;
+
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+
 export interface LocalFetchURLProviderOptions {
   userAgent?: string;
   fetchImpl?: typeof fetch;
@@ -58,15 +71,54 @@ export interface LocalFetchURLProviderOptions {
 }
 
 /**
- * SSRF guard — reject non-http(s) schemes and (by default) any hostname
- * that is, or parses as, a private / loopback / link-local / ULA IP
- * literal. This is a *static* check against the URL string; it does NOT
- * do DNS resolution, so a domain that resolves to a private IP via
- * DNS-rebinding is **not** caught here. That attack is a known
- * limitation; mitigations (e.g. pinning the resolved IP through to
- * fetch) are left for a follow-up.
+ * SSRF blocklist: loopback / RFC 1918 / link-local / CGNAT / ULA and
+ * "this network", for both address families. BlockList.check() maps
+ * IPv4-mapped IPv6 addresses (e.g. ::ffff:127.0.0.1) onto the IPv4
+ * subnets, so mapped literals cannot slip past the v4 rules.
  */
-function assertSafeFetchTarget(url: string, allowPrivate: boolean): void {
+const PRIVATE_ADDRESS_BLOCKLIST = (() => {
+  const list = new BlockList();
+  list.addSubnet('0.0.0.0', 8, 'ipv4'); // "this network"
+  list.addSubnet('10.0.0.0', 8, 'ipv4');
+  list.addSubnet('100.64.0.0', 10, 'ipv4'); // CGNAT
+  list.addSubnet('127.0.0.0', 8, 'ipv4'); // loopback
+  list.addSubnet('169.254.0.0', 16, 'ipv4'); // link-local / cloud metadata
+  list.addSubnet('172.16.0.0', 12, 'ipv4');
+  list.addSubnet('192.168.0.0', 16, 'ipv4');
+  list.addSubnet('::', 128, 'ipv6'); // unspecified
+  list.addSubnet('::1', 128, 'ipv6'); // loopback
+  list.addSubnet('fc00::', 7, 'ipv6'); // ULA
+  list.addSubnet('fe80::', 10, 'ipv6'); // link-local
+  return list;
+})();
+
+function isBlockedAddress(address: string): boolean {
+  // Link-local addresses may carry a zone id ("fe80::1%en0") — strip it
+  // before matching.
+  const normalized = address.split('%', 1)[0] ?? address;
+  if (isIP(normalized) === 4) return PRIVATE_ADDRESS_BLOCKLIST.check(normalized, 'ipv4');
+  return isIP(normalized) === 6 && PRIVATE_ADDRESS_BLOCKLIST.check(normalized, 'ipv6');
+}
+
+interface SafeFetchTarget {
+  /** Lowercased hostname with any IPv6 brackets stripped. */
+  host: string;
+  /** Effective origin port — explicit, or the scheme default. */
+  port: string;
+  /** Validated DNS answers to pin the connection to — absent when no lookup was needed. */
+  addresses?: LookupAddress[];
+}
+
+/**
+ * SSRF guard — reject non-http(s) schemes and (by default) anything that
+ * resolves to a private / loopback / link-local / ULA address: IP literals
+ * are checked directly, hostnames are resolved via DNS and every resulting
+ * address is checked. Re-run for every redirect hop by the caller. Returns
+ * the validated DNS answers so the connection can be pinned to them —
+ * otherwise the connect-time re-resolution could be answered differently
+ * (TOCTOU / DNS rebinding).
+ */
+async function resolveSafeFetchTarget(url: string, allowPrivate: boolean): Promise<SafeFetchTarget> {
   let parsed: URL;
   try {
     parsed = new URL(url);
@@ -76,58 +128,71 @@ function assertSafeFetchTarget(url: string, allowPrivate: boolean): void {
   if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
     throw new Error(`Unsupported URL scheme "${parsed.protocol}" — only http(s) allowed.`);
   }
-  if (allowPrivate) return;
   // URL hostname preserves surrounding `[ ]` for IPv6 literals on some
   // Node versions (and not others). Strip them for uniform comparison.
   const hostRaw = parsed.hostname.toLowerCase();
   const host = hostRaw.startsWith('[') && hostRaw.endsWith(']') ? hostRaw.slice(1, -1) : hostRaw;
+  const port = parsed.port !== '' ? parsed.port : parsed.protocol === 'https:' ? '443' : '80';
+  if (allowPrivate) return { host, port };
+  // IP literals are checked directly and never resolved.
+  if (isIP(host) !== 0) {
+    if (isBlockedAddress(host)) {
+      throw new Error(`Refusing to fetch private address: "${host}"`);
+    }
+    return { host, port };
+  }
   // Literal "localhost" / loopback aliases.
   if (host === 'localhost' || host.endsWith('.localhost')) {
     throw new Error(`Refusing to fetch private host: "${host}"`);
   }
-  // IPv6 loopback / ULA / link-local. Check after bracket strip.
-  if (
-    host === '::1' ||
-    host === '::' ||
-    host.startsWith('fe80:') ||
-    host.startsWith('fc') ||
-    host.startsWith('fd')
-  ) {
-    throw new Error(`Refusing to fetch private host: "${host}"`);
+  // Hostnames must be resolved and every resulting address checked — a
+  // public-looking domain can point at loopback (e.g. localtest.me) or any
+  // internal address.
+  let addresses: LookupAddress[];
+  try {
+    addresses = await lookup(host, { all: true });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot resolve host "${host}" for the fetch safety check: ${detail}`, {
+      cause: error,
+    });
   }
-  // IPv4 literal — only check when the hostname is a dotted-quad; normal
-  // domains will never match.
-  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
-  if (v4 !== null) {
-    const octets = [v4[1], v4[2], v4[3], v4[4]].map(Number);
-    if (octets.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
-      throw new Error(`Invalid IPv4 literal: "${host}"`);
-    }
-    const [a, b] = octets as [number, number, number, number];
-    // 127.0.0.0/8 loopback, 10.0.0.0/8, 192.168.0.0/16,
-    // 172.16.0.0/12, 169.254.0.0/16 link-local / AWS metadata,
-    // 0.0.0.0/8 "this network", 100.64.0.0/10 CGNAT.
-    const isLoopback = a === 127;
-    const isPrivate10 = a === 10;
-    const isPrivate192 = a === 192 && b === 168;
-    const isPrivate172 = a === 172 && b >= 16 && b <= 31;
-    const isLinkLocal = a === 169 && b === 254;
-    const isZero = a === 0;
-    const isCgnat = a === 100 && b >= 64 && b <= 127;
-    if (
-      isLoopback ||
-      isPrivate10 ||
-      isPrivate192 ||
-      isPrivate172 ||
-      isLinkLocal ||
-      isZero ||
-      isCgnat
-    ) {
-      throw new Error(`Refusing to fetch private address: "${host}"`);
+  for (const { address } of addresses) {
+    if (isBlockedAddress(address)) {
+      throw new Error(`Refusing to fetch host "${host}": resolves to private address "${address}".`);
     }
   }
+  return { host, port, addresses };
 }
 
+/**
+ * Build a `net`/`tls` lookup hook that answers `host` from the validated
+ * address set, so the connect-time resolution cannot drift from what the
+ * safety check approved. Anything else is delegated to the real resolver
+ * (a per-hop Agent only ever connects to its own origin, but stay
+ * functional if reused elsewhere).
+ */
+function pinnedLookup(host: string, addresses: LookupAddress[]): LookupFunction {
+  return (hostname: string, options: LookupOptions | undefined, callback: PinnedLookupCallback) => {
+    if (hostname !== host) {
+      callbackLookup(hostname, options ?? {}, callback);
+      return;
+    }
+    if (options?.all === true) {
+      callback(null, [...addresses]);
+      return;
+    }
+    const single = addresses.find((entry) => entry.family === options?.family) ?? addresses[0]!;
+    callback(null, single.address, single.family);
+  };
+}
+
+type PinnedLookupCallback = (
+  err: NodeJS.ErrnoException | null,
+  addressOrList: string | LookupAddress[],
+  family?: number,
+) => void;
+
 export class LocalFetchURLProvider implements UrlFetcher {
   private readonly userAgent: string;
   private readonly fetchImpl: typeof fetch;
@@ -142,13 +207,24 @@ export class LocalFetchURLProvider implements UrlFetcher {
   }
 
   async fetch(url: string, _options?: { toolCallId?: string }): Promise<UrlFetchResult> {
-    assertSafeFetchTarget(url, this.allowPrivateAddresses);
-
-    const response = await this.fetchImpl(url, {
-      method: 'GET',
-      headers: { 'User-Agent': this.userAgent },
-    });
+    // Pinned Agents are created per redirect hop and closed once the final
+    // body is consumed, so keep-alive sockets never linger.
+    const dispatchers: Dispatcher[] = [];
+    try {
+      const response = await this.requestWithValidatedRedirects(url, dispatchers);
+      return await this.readResponse(response);
+    } finally {
+      await Promise.all(
+        dispatchers.map((dispatcher) =>
+          dispatcher.close().catch(() => {
+            /* already closed */
+          }),
+        ),
+      );
+    }
+  }
 
+  private async readResponse(response: Response): Promise<UrlFetchResult> {
     if (response.status >= 400) {
       // Drain the unused body so undici can release the socket back to
       // the keep-alive pool instead of leaking it on error paths.
@@ -166,6 +242,11 @@ export class LocalFetchURLProvider implements UrlFetcher {
     if (contentLengthRaw !== null) {
       const cl = Number(contentLengthRaw);
       if (Number.isFinite(cl) && cl > this.maxBytes) {
+        // Drain before throwing: the caller closes per-hop Agents in a
+        // finally, and an active oversized stream could stall that close.
+        await response.body?.cancel().catch(() => {
+          /* already closed */
+        });
         throw new Error(
           `Response body too large: ${String(cl)} bytes exceeds maxBytes (${String(this.maxBytes)}).`,
         );
@@ -190,6 +271,77 @@ export class LocalFetchURLProvider implements UrlFetcher {
     return { content: this.extractMainContent(body), kind: 'extracted' };
   }
 
+  /**
+   * GET `url`, following redirects manually. Every hop re-runs the full
+   * SSRF check (IP-literal + DNS) before the request goes out — a public
+   * URL must not be able to bounce the fetcher at an internal address.
+   * Redirects without a `Location` header are treated as final responses.
+   */
+  private async requestWithValidatedRedirects(
+    url: string,
+    dispatchers: Dispatcher[],
+  ): Promise<Response> {
+    let currentUrl = url;
+    let redirects = 0;
+    for (;;) {
+      const target = await resolveSafeFetchTarget(currentUrl, this.allowPrivateAddresses);
+      const response = await this.fetchImpl(currentUrl, {
+        method: 'GET',
+        headers: { 'User-Agent': this.userAgent },
+        redirect: 'manual',
+        // `dispatcher` is honored by undici at runtime but absent from
+        // DOM's RequestInit type (DOM-lib consumers typecheck this source)
+        // — hide it behind `unknown` to stay lib-agnostic.
+        dispatcher: this.pinnedDispatcherFor(target, dispatchers) as unknown,
+      } as RequestInit);
+      if (!REDIRECT_STATUSES.has(response.status)) return response;
+      const location = response.headers.get('location');
+      if (location === null) return response;
+      // Drain the unused body so undici can release the socket back to
+      // the keep-alive pool instead of leaking it on redirect hops.
+      await response.body?.cancel().catch(() => {
+        /* already closed */
+      });
+      if (redirects >= MAX_REDIRECT_HOPS) {
+        throw new Error(
+          `Too many redirects while fetching "${url}" (limit ${String(MAX_REDIRECT_HOPS)}).`,
+        );
+      }
+      redirects += 1;
+      currentUrl = new URL(location, currentUrl).toString();
+    }
+  }
+
+  /**
+   * Pin the connection to the addresses the safety check just validated.
+   * undici resolves the origin again when it connects, so without pinning
+   * an attacker-controlled DNS could answer the check with a public IP and
+   * the connect with an internal one (TOCTOU / DNS rebinding).
+   */
+  private pinnedDispatcherFor(
+    target: SafeFetchTarget,
+    dispatchers: Dispatcher[],
+  ): Dispatcher | undefined {
+    // IP literals (and allowPrivate mode) need no pin — there is no second
+    // resolution to race.
+    if (target.addresses === undefined) return undefined;
+    // Pin only when this request will actually connect directly. When a
+    // proxy applies, origin DNS happens on the proxy side (nothing local
+    // to pin) and a direct-connect pinned Agent would bypass the proxy
+    // entirely. A NO_PROXY bypass still connects directly — keep pinning.
+    if (
+      isProxyConfigured(process.env) &&
+      !makeNoProxyMatcher(resolveNoProxy(process.env))(target.host, target.port)
+    ) {
+      return undefined;
+    }
+    const dispatcher = new Agent({
+      connect: { lookup: pinnedLookup(target.host, target.addresses) },
+    });
+    dispatchers.push(dispatcher);
+    return dispatcher;
+  }
+
   private extractMainContent(html: string): string {
     // Readability mutates the DOM it parses, so parse twice — once for
     // the primary extractor and once for the fallback path.
diff --git a/packages/agent-core/src/utils/promise.ts b/packages/agent-core/src/utils/promise.ts
index e030e33c0..bbeb0b9d1 100644
--- a/packages/agent-core/src/utils/promise.ts
+++ b/packages/agent-core/src/utils/promise.ts
@@ -1,5 +1,12 @@
 const NEVER = new Promise<never>(() => {});
 
+/**
+ * Largest delay `setTimeout` accepts: beyond this Node clamps the delay to 1ms,
+ * which would fire immediately. Clamp instead so huge ("effectively unbounded")
+ * timeouts still mean a long wait (~24.8 days).
+ */
+const MAX_TIMER_DELAY_MS = 0x7fffffff;
+
 export type TimeoutOutcomePromise<Outcome> = Promise<Outcome> & {
   clear(): void;
 };
@@ -13,10 +20,13 @@ export function timeoutOutcome<Outcome>(
     timeoutMs === undefined || timeoutMs <= 0
       ? NEVER
       : new Promise((resolve) => {
-          timeout = setTimeout(() => {
-            timeout = undefined;
-            resolve(outcome);
-          }, timeoutMs);
+          timeout = setTimeout(
+            () => {
+              timeout = undefined;
+              resolve(outcome);
+            },
+            Math.min(timeoutMs, MAX_TIMER_DELAY_MS),
+          );
         });
 
   return Object.assign(promise, {
@@ -57,10 +67,13 @@ export function resettableTimeoutOutcome<Outcome>(
   const reset = (timeoutMs: number | undefined): void => {
     clear();
     if (timeoutMs === undefined || timeoutMs <= 0) return;
-    timer = setTimeout(() => {
-      timer = undefined;
-      resolvePromise(outcome);
-    }, timeoutMs);
+    timer = setTimeout(
+      () => {
+        timer = undefined;
+        resolvePromise(outcome);
+      },
+      Math.min(timeoutMs, MAX_TIMER_DELAY_MS),
+    );
   };
   reset(initialMs);
   return Object.assign(promise, { reset, clear });
diff --git a/packages/agent-core/test/agent/compaction/compaction-scenarios.test.ts b/packages/agent-core/test/agent/compaction/compaction-scenarios.test.ts
index f9ac8d6ea..dfa47a382 100644
--- a/packages/agent-core/test/agent/compaction/compaction-scenarios.test.ts
+++ b/packages/agent-core/test/agent/compaction/compaction-scenarios.test.ts
@@ -15,9 +15,8 @@
 import type { ContentPart, Message } from '@moonshot-ai/kosong';
 import { describe, expect, it } from 'vitest';
 
-import type { AgentOptions } from '../../../src/agent';
+import type { AgentOptions, AgentRecord } from '../../../src/agent';
 import { COMPACTION_ELISION_VARIANT, COMPACTION_SUMMARY_PREFIX } from '../../../src/agent/compaction';
-import type { AgentRecord } from '../../../src/agent';
 import {
   AGENT_WIRE_PROTOCOL_VERSION,
   InMemoryAgentRecordPersistence,
diff --git a/packages/agent-core/test/agent/compaction/full.test.ts b/packages/agent-core/test/agent/compaction/full.test.ts
index e238b6eef..9668f18c5 100644
--- a/packages/agent-core/test/agent/compaction/full.test.ts
+++ b/packages/agent-core/test/agent/compaction/full.test.ts
@@ -136,6 +136,53 @@ describe('FullCompaction', () => {
     await ctx.expectResumeMatches();
   });
 
+  it('attaches the summarizer request trace id to compaction_finished', async () => {
+    const records: TelemetryRecord[] = [];
+    const ctx = testAgent({ telemetry: recordingTelemetry(records) });
+    ctx.configure({
+      provider: CATALOGUED_PROVIDER,
+      modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
+    });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
+
+    ctx.mockNextProviderResponse({
+      parts: [{ type: 'text', text: 'Compacted summary.' }],
+      traceId: 'trace-compact-1',
+    });
+    await ctx.rpc.beginCompaction({});
+    await ctx.once('compaction.completed');
+
+    expect(records).toContainEqual({
+      event: 'compaction_finished',
+      properties: expect.objectContaining({ source: 'manual', trace_id: 'trace-compact-1' }),
+    });
+    expect(ctx.agent.fullCompaction.lastTraceId).toBe('trace-compact-1');
+  });
+
+  it('attaches the failed summarizer request trace id to compaction_failed', async () => {
+    const records: TelemetryRecord[] = [];
+    const generate: GenerateFn = async () => {
+      // 401 is not retryable: the round fails on the first attempt without
+      // backoff timers.
+      throw new APIStatusError(401, 'Unauthorized', 'req-1', null, 'trace-compact-err');
+    };
+    const ctx = testAgent({ generate, telemetry: recordingTelemetry(records) });
+    ctx.configure({
+      provider: CATALOGUED_PROVIDER,
+      modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
+    });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
+    const failed = ctx.once('error');
+
+    await ctx.rpc.beginCompaction({});
+    await failed;
+
+    expect(records).toContainEqual({
+      event: 'compaction_failed',
+      properties: expect.objectContaining({ source: 'manual', trace_id: 'trace-compact-err' }),
+    });
+  });
+
   it('emits the raw summary while keeping the prefixed summary in model context', async () => {
     const ctx = testAgent();
     ctx.configure({
@@ -364,6 +411,7 @@ describe('FullCompaction', () => {
   });
 
   it('force-refreshes OAuth credentials on compaction 401 and treats replay 401 as provider auth error', async () => {
+    const records: TelemetryRecord[] = [];
     const tokenCalls: Array<boolean | undefined> = [];
     const authKeys: string[] = [];
     const oauthOptions = oauthTestAgentOptions(async (options) => {
@@ -380,11 +428,17 @@ describe('FullCompaction', () => {
     ) => {
       authKeys.push(options?.auth?.apiKey ?? '<missing>');
       if (authKeys.length <= 2) {
-        throw new APIStatusError(401, 'Unauthorized', 'req-compact-401');
+        throw new APIStatusError(
+          401,
+          'Unauthorized',
+          'req-compact-401',
+          null,
+          authKeys.length === 1 ? 'trace-compact-initial-401' : 'trace-compact-replay-401',
+        );
       }
       return textResult('Recovered compacted summary.');
     };
-    const ctx = testAgent({ ...oauthOptions, generate });
+    const ctx = testAgent({ ...oauthOptions, generate, telemetry: recordingTelemetry(records) });
     ctx.configure();
     await ctx.rpc.setModel({ model: 'kimi-code' });
     ctx.newEvents();
@@ -409,6 +463,9 @@ describe('FullCompaction', () => {
     );
     expect(authKeys).toEqual(['fresh-token', 'forced-refresh-token']);
     expect(tokenCalls).toEqual([undefined, true]);
+    expect(
+      records.find((record) => record.event === 'compaction_failed')?.properties?.['trace_id'],
+    ).toBe('trace-compact-replay-401');
     expect(ctx.compactHistory()).toEqual([
       { role: 'user', text: 'old user one' },
       { role: 'assistant', text: 'old assistant one' },
diff --git a/packages/agent-core/test/agent/config-state.test.ts b/packages/agent-core/test/agent/config-state.test.ts
index 0947978d7..c7b4c896b 100644
--- a/packages/agent-core/test/agent/config-state.test.ts
+++ b/packages/agent-core/test/agent/config-state.test.ts
@@ -152,6 +152,66 @@ describe('ConfigState model capabilities', () => {
     expect(requestMaxTokens).toBe(131072);
   });
 
+  it('warns and sends when an Anthropic effort is not listed by the model', async () => {
+    let requests = 0;
+    const config: KimiConfig = {
+      providers: {
+        compatible: {
+          type: 'kimi',
+          apiKey: 'test-key',
+          baseUrl: 'https://api.example.test',
+        },
+      },
+      models: {
+        compatible: {
+          provider: 'compatible',
+          model: 'compatible-model',
+          protocol: 'anthropic',
+          maxContextSize: 128_000,
+          capabilities: ['thinking'],
+          supportEfforts: ['max'],
+        },
+      },
+    };
+    const ctx = testAgent({
+      initialConfig: config,
+      providerManager: new ProviderManager({ config }),
+      generate: async (provider) => {
+        requests += 1;
+        expect(provider.thinkingEffort).toBe('high');
+        return {
+          id: 'response-1',
+          message: { role: 'assistant', content: [], toolCalls: [] },
+          usage: emptyUsage(),
+          finishReason: 'completed',
+          rawFinishReason: 'stop',
+        };
+      },
+    });
+    ctx.agent.config.update({
+      modelAlias: 'compatible',
+      systemPrompt: 'system',
+    });
+    ctx.agent.config.setThinkingEffort('high');
+
+    await ctx.agent.llm.chat({
+      messages: [],
+      tools: [],
+      signal: new AbortController().signal,
+    });
+
+    expect(requests).toBe(1);
+    expect(ctx.allEvents).toContainEqual({
+      type: '[rpc]',
+      event: 'warning',
+      args: {
+        code: 'anthropic-thinking-effort-not-listed',
+        message:
+          'Thinking effort "high" is not listed for model "compatible-model" (known: max). The configured value will be sent unchanged to the Anthropic-compatible backend.',
+      },
+    });
+  });
+
   it('uses session id as a provider prompt cache hint without storing it on Agent', () => {
     const ctx = testAgent({
       providerManager: new ProviderManager({
diff --git a/packages/agent-core/test/agent/config/thinking.test.ts b/packages/agent-core/test/agent/config/thinking.test.ts
index 503cb20a5..aa642d8e4 100644
--- a/packages/agent-core/test/agent/config/thinking.test.ts
+++ b/packages/agent-core/test/agent/config/thinking.test.ts
@@ -104,8 +104,10 @@ describe('resolveThinkingEffort', () => {
   });
 
   it('forces always-thinking models back on when the resolved effort is off', () => {
-    expect(resolveThinkingEffort('off', undefined, alwaysThinkingModel)).toBe('on');
-    expect(resolveThinkingEffort(undefined, { enabled: false }, alwaysThinkingModel)).toBe('on');
+    expect(resolveThinkingEffort('off', undefined, alwaysThinkingModel, true)).toBe('on');
+    expect(resolveThinkingEffort(undefined, { enabled: false }, alwaysThinkingModel, true)).toBe(
+      'on',
+    );
   });
 
   it('honors a configured effort when clamping always-thinking models back on', () => {
@@ -113,12 +115,21 @@ describe('resolveThinkingEffort', () => {
     // an explicitly configured effort is preserved instead of falling back to
     // the model default.
     expect(
-      resolveThinkingEffort(undefined, { enabled: false, effort: 'max' }, alwaysThinkingEffortModel),
+      resolveThinkingEffort(
+        undefined,
+        { enabled: false, effort: 'max' },
+        alwaysThinkingEffortModel,
+        true,
+      ),
     ).toBe('max');
     // without an explicit effort, fall back to the model's default effort.
-    expect(resolveThinkingEffort(undefined, { enabled: false }, alwaysThinkingEffortModel)).toBe(
-      'high',
-    );
+    expect(
+      resolveThinkingEffort(undefined, { enabled: false }, alwaysThinkingEffortModel, true),
+    ).toBe('high');
+  });
+
+  it('preserves off for always-thinking models on compatible protocols', () => {
+    expect(resolveThinkingEffort('off', undefined, alwaysThinkingEffortModel, false)).toBe('off');
   });
 
   it('does not force on for models that are not always-thinking', () => {
@@ -165,6 +176,7 @@ describe('resolveThinkingEffort overrides', () => {
           capabilities: ['thinking'],
           overrides: { capabilities: ['thinking', 'always_thinking'] },
         }),
+        true,
       ),
     ).toBe('on');
   });
diff --git a/packages/agent-core/test/agent/context/projector.test.ts b/packages/agent-core/test/agent/context/projector.test.ts
index 7390173e6..35889f9b2 100644
--- a/packages/agent-core/test/agent/context/projector.test.ts
+++ b/packages/agent-core/test/agent/context/projector.test.ts
@@ -160,6 +160,24 @@ function compactionSummary(text = 'summary'): ContextMessage {
 // Targeted regression tests
 // ---------------------------------------------------------------------------
 
+describe('project UI-only context metadata', () => {
+  it('does not send persisted tool displays to the model provider', () => {
+    const assistantMessage = assistant(['edit-call']);
+    assistantMessage.toolCallDisplays = {
+      'edit-call': {
+        kind: 'diff',
+        path: '/workspace/file.txt',
+        before: 'old',
+        after: 'new',
+      },
+    };
+
+    const projected = project([user('update it'), assistantMessage, tool('edit-call')]);
+
+    expect(projected[1]).not.toHaveProperty('toolCallDisplays');
+  });
+});
+
 describe('project tool_use/tool_result adjacency', () => {
   it('leaves an already well-formed history unchanged (idempotent)', () => {
     const history: ContextMessage[] = [
diff --git a/packages/agent-core/test/agent/harness/scripted-generate.ts b/packages/agent-core/test/agent/harness/scripted-generate.ts
index 08432dd11..4fe5e8f21 100644
--- a/packages/agent-core/test/agent/harness/scripted-generate.ts
+++ b/packages/agent-core/test/agent/harness/scripted-generate.ts
@@ -21,6 +21,7 @@ interface ScriptedResponse {
   readonly parts: readonly StreamedMessagePart[];
   readonly finishReason?: FinishReason | null | undefined;
   readonly rawFinishReason?: string | null | undefined;
+  readonly traceId?: string | null | undefined;
 }
 
 export function createScriptedGenerate() {
@@ -36,11 +37,13 @@ export function createScriptedGenerate() {
     readonly parts?: readonly StreamedMessagePart[] | undefined;
     readonly finishReason?: FinishReason | null | undefined;
     readonly rawFinishReason?: string | null | undefined;
+    readonly traceId?: string | null | undefined;
   }) {
     responses.push({
       parts: structuredClone(input.parts ?? []),
       ...(input.finishReason !== undefined ? { finishReason: input.finishReason } : {}),
       ...(input.rawFinishReason !== undefined ? { rawFinishReason: input.rawFinishReason } : {}),
+      ...(input.traceId !== undefined ? { traceId: input.traceId } : {}),
     });
   }
 
@@ -85,6 +88,10 @@ export function createScriptedGenerate() {
 
     const inferredFinishReason: FinishReason = toolCalls.length > 0 ? 'tool_calls' : 'completed';
     const finishReason = response.finishReason ?? inferredFinishReason;
+    const traceId = response.traceId ?? null;
+    // Mirror kosong generate(): the trace id callback fires before the stream
+    // is drained, as soon as the response headers arrive.
+    options?.onTraceId?.(traceId);
     return {
       id: `mock-${String(calls.length)}`,
       message,
@@ -96,6 +103,7 @@ export function createScriptedGenerate() {
       },
       finishReason,
       rawFinishReason: response.rawFinishReason ?? defaultRawFinishReason(finishReason),
+      traceId,
     };
   };
 
diff --git a/packages/agent-core/test/agent/permission.test.ts b/packages/agent-core/test/agent/permission.test.ts
index a11158652..6ebf96768 100644
--- a/packages/agent-core/test/agent/permission.test.ts
+++ b/packages/agent-core/test/agent/permission.test.ts
@@ -2197,6 +2197,21 @@ describe('ExitPlanMode permission policy', () => {
       }),
     );
   });
+
+  it('attaches the request trace id to permission_approval_result', async () => {
+    const { manager, telemetryTrack } = makePermissionManager(
+      async () => ({ decision: 'approved' }),
+    );
+
+    await expect(
+      manager.beforeToolCall(hookContext({ id: 'call_traced', traceId: 'trace-perm-1' })),
+    ).resolves.toBeUndefined();
+
+    expect(telemetryTrack).toHaveBeenCalledWith(
+      'permission_approval_result',
+      expect.objectContaining({ result: 'approved', trace_id: 'trace-perm-1' }),
+    );
+  });
 });
 
 describe('Agent-local approve for session', () => {
@@ -3953,6 +3968,7 @@ function makePlanPermissionManager(input: {
     rpc: { requestApproval },
     log: { warn: vi.fn(), error: vi.fn(), info: vi.fn(), debug: vi.fn() },
     telemetry: { track: telemetryTrack },
+    turn: { traceIdForTurn: () => undefined },
     planMode: {
       get isActive() {
         return true;
@@ -3987,6 +4003,7 @@ function hookContext(input: {
   readonly args?: Record<string, unknown> | undefined;
   readonly execution?: PermissionPolicyContext['execution'] | undefined;
   readonly toolCalls?: readonly ToolCall[] | undefined;
+  readonly traceId?: string | undefined;
 }): PermissionPolicyContext {
   const toolName = input.toolName ?? 'Bash';
   const args = input.args ?? { command: 'printf first', timeout: 60 };
@@ -3999,6 +4016,7 @@ function hookContext(input: {
   return {
     turnId: '0',
     stepNumber: 1,
+    traceId: input.traceId,
     signal: new AbortController().signal,
     llm: {} as PermissionPolicyContext['llm'],
     toolCall,
diff --git a/packages/agent-core/test/agent/turn.test.ts b/packages/agent-core/test/agent/turn.test.ts
index 3d0a0697a..3af3fb306 100644
--- a/packages/agent-core/test/agent/turn.test.ts
+++ b/packages/agent-core/test/agent/turn.test.ts
@@ -519,11 +519,11 @@ describe('Agent turn flow', () => {
 
     expect(records).toContainEqual({
       event: 'turn_started',
-      properties: { mode: 'agent' },
+      properties: { turn_id: 0, mode: 'agent' },
     });
     expect(records).toContainEqual({
       event: 'turn_interrupted',
-      properties: { mode: 'agent', at_step: 0, interrupt_reason: 'error' },
+      properties: { turn_id: 0, mode: 'agent', at_step: 0, interrupt_reason: 'error' },
     });
   });
 
@@ -656,6 +656,7 @@ describe('Agent turn flow', () => {
     expect(ended).toEqual({
       event: 'turn_ended',
       properties: expect.objectContaining({
+        turn_id: 0,
         mode: 'agent',
         reason: 'completed',
         provider_type: 'kimi',
@@ -665,6 +666,49 @@ describe('Agent turn flow', () => {
     });
   });
 
+  it('attaches the provider trace id to turn and tool telemetry', async () => {
+    const records: TelemetryRecord[] = [];
+    const ctx = testAgent({
+      kaos: createCommandKaos('traced'),
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure({ tools: ['Bash'] });
+    await ctx.rpc.setPermission({ mode: 'yolo' });
+    records.length = 0;
+
+    ctx.mockNextProviderResponse({
+      parts: [{ type: 'text', text: 'running' }, bashCallWithId('call_traced', 'printf traced')],
+      traceId: 'trace-turn-1',
+    });
+    ctx.mockNextProviderResponse({
+      parts: [{ type: 'text', text: 'done' }],
+      traceId: 'trace-turn-2',
+    });
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'run' }] });
+    await ctx.untilTurnEnd();
+
+    // tool_call attributes to the request that produced the call.
+    const toolCall = records.find((candidate) => candidate.event === 'tool_call');
+    expect(toolCall?.properties?.['trace_id']).toBe('trace-turn-1');
+    // turn_ended attributes to the turn's most recent request.
+    const ended = records.find((candidate) => candidate.event === 'turn_ended');
+    expect(ended?.properties?.['trace_id']).toBe('trace-turn-2');
+  });
+
+  it('omits trace_id from turn telemetry when the provider reports none', async () => {
+    const records: TelemetryRecord[] = [];
+    const ctx = testAgent({ telemetry: recordingTelemetry(records) });
+    ctx.configure();
+    ctx.mockNextResponse({ type: 'text', text: 'done' });
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'hi' }] });
+    await ctx.untilTurnEnd();
+
+    const ended = records.find((candidate) => candidate.event === 'turn_ended');
+    expect(ended?.properties?.['trace_id']).toBeUndefined();
+  });
+
   it('tracks duplicate tool-call detection telemetry', async () => {
     const records: TelemetryRecord[] = [];
     const ctx = testAgent({
@@ -735,6 +779,7 @@ describe('Agent turn flow', () => {
     expect(records).toContainEqual({
       event: 'tool_call',
       properties: expect.objectContaining({
+        turn_id: 0,
         tool_name: 'Bash',
         outcome: 'success',
         dup_type: 'cross_step',
@@ -812,6 +857,7 @@ describe('Agent turn flow', () => {
     expect(records).toContainEqual({
       event: 'tool_call',
       properties: expect.objectContaining({
+        turn_id: 0,
         tool_name: 'MissingTool',
         outcome: 'error',
         dup_type: 'normal',
@@ -1873,6 +1919,7 @@ describe('Agent turn flow', () => {
   });
 
   it('treats 401 after force-refresh as provider auth error', async () => {
+    const records: TelemetryRecord[] = [];
     const tokenCalls: Array<boolean | undefined> = [];
     const authKeys: string[] = [];
     const oauthOptions = oauthAgentOptions(
@@ -1891,9 +1938,15 @@ describe('Agent turn flow', () => {
       options,
     ) => {
       authKeys.push(options?.auth?.apiKey ?? '<missing>');
-      throw new APIStatusError(401, 'Unauthorized', 'req-401');
+      throw new APIStatusError(
+        401,
+        'Unauthorized',
+        'req-401',
+        null,
+        authKeys.length === 1 ? 'trace-initial-401' : 'trace-replay-401',
+      );
     };
-    const ctx = testAgent({ ...oauthOptions, generate });
+    const ctx = testAgent({ ...oauthOptions, generate, telemetry: recordingTelemetry(records) });
     ctx.configure();
     await ctx.rpc.setModel({ model: 'kimi-code' });
     ctx.newEvents();
@@ -1919,6 +1972,12 @@ describe('Agent turn flow', () => {
         }),
       }),
     );
+    expect(records.find((record) => record.event === 'api_error')?.properties?.['trace_id']).toBe(
+      'trace-replay-401',
+    );
+    expect(records.find((record) => record.event === 'turn_ended')?.properties?.['trace_id']).toBe(
+      'trace-replay-401',
+    );
   });
 
   it('keeps non-OAuth provider 401 as provider auth error', async () => {
@@ -2054,6 +2113,270 @@ describe('Agent turn flow', () => {
     }
   });
 
+  it('tracks api_error with the failed request trace id from the error response', async () => {
+    const records: TelemetryRecord[] = [];
+    const generate: GenerateFn = async () => {
+      throw new APIStatusError(500, 'server exploded', 'req-1', null, 'trace-err-1');
+    };
+    const ctx = testAgent({
+      generate,
+      ...singleAttemptAgentOptions(),
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure();
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'trigger provider error' }] });
+    await ctx.untilTurnEnd();
+
+    const record = records.find((candidate) => candidate.event === 'api_error');
+    expect(record?.properties?.['trace_id']).toBe('trace-err-1');
+  });
+
+  it('omits trace_id from api_error when the failure carried no response', async () => {
+    const records: TelemetryRecord[] = [];
+    const generate: GenerateFn = async () => {
+      throw new APIConnectionError('socket hang up');
+    };
+    const ctx = testAgent({
+      generate,
+      ...singleAttemptAgentOptions(),
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure();
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'trigger provider error' }] });
+    await ctx.untilTurnEnd();
+
+    const record = records.find((candidate) => candidate.event === 'api_error');
+    expect(record).toBeDefined();
+    expect(record?.properties?.['trace_id']).toBeUndefined();
+  });
+
+  it('attributes api_error to the in-flight request trace on post-headers failures', async () => {
+    const records: TelemetryRecord[] = [];
+    const generate: GenerateFn = async (_provider, _system, _tools, _history, _callbacks, options) => {
+      // Mirror kosong generate(): the trace id callback fires as soon as the
+      // response headers arrive, before the stream body is drained — so a
+      // mid-stream failure has a captured trace but none on the error itself.
+      options?.onTraceId?.('trace-mid-stream');
+      throw new APIEmptyResponseError('empty response');
+    };
+    const ctx = testAgent({
+      generate,
+      ...singleAttemptAgentOptions(),
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure();
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'trigger provider error' }] });
+    await ctx.untilTurnEnd();
+
+    const record = records.find((candidate) => candidate.event === 'api_error');
+    expect(record?.properties?.['trace_id']).toBe('trace-mid-stream');
+  });
+
+  it('omits trace_id from api_error when a later step fails before response headers', async () => {
+    const records: TelemetryRecord[] = [];
+    let calls = 0;
+    const generate: GenerateFn = async (_provider, _system, _tools, _history, _callbacks, options) => {
+      calls += 1;
+      if (calls === 1) {
+        options?.onTraceId?.('trace-step-1');
+        return {
+          id: 'mock-step-1',
+          message: {
+            role: 'assistant' as const,
+            content: [{ type: 'text' as const, text: 'running' }],
+            toolCalls: [
+              {
+                type: 'function' as const,
+                id: 'call_traced',
+                name: 'Bash',
+                arguments: '{"command":"printf traced"}',
+              },
+            ],
+          },
+          usage: { inputOther: 1, output: 1, inputCacheRead: 0, inputCacheCreation: 0 },
+          finishReason: 'tool_calls' as const,
+          rawFinishReason: 'tool_calls',
+          traceId: 'trace-step-1',
+        };
+      }
+      // Step 2's request fails before any response headers arrive: neither
+      // the error nor the in-flight capture has a trace, and step 1's trace
+      // must not leak into api_error.
+      throw new APIConnectionError('socket hang up');
+    };
+    const ctx = testAgent({
+      generate,
+      kaos: createCommandKaos('traced'),
+      ...singleAttemptAgentOptions(),
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure({ tools: ['Bash'] });
+    await ctx.rpc.setPermission({ mode: 'yolo' });
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'run' }] });
+    await ctx.untilTurnEnd();
+
+    const record = records.find((candidate) => candidate.event === 'api_error');
+    expect(record).toBeDefined();
+    expect(record?.properties?.['trace_id']).toBeUndefined();
+  });
+
+  it('attributes turn-level telemetry to the failed request trace on error turns', async () => {
+    const records: TelemetryRecord[] = [];
+    let calls = 0;
+    const generate: GenerateFn = async (_provider, _system, _tools, _history, _callbacks, options) => {
+      calls += 1;
+      if (calls === 1) {
+        // Mirror kosong generate(): the trace id callback fires before the
+        // stream is drained, as soon as the response headers arrive.
+        options?.onTraceId?.('trace-step-1');
+        return {
+          id: 'mock-step-1',
+          message: {
+            role: 'assistant' as const,
+            content: [{ type: 'text' as const, text: 'running' }],
+            toolCalls: [
+              {
+                type: 'function' as const,
+                id: 'call_traced',
+                name: 'Bash',
+                arguments: '{"command":"printf traced"}',
+              },
+            ],
+          },
+          usage: { inputOther: 1, output: 1, inputCacheRead: 0, inputCacheCreation: 0 },
+          finishReason: 'tool_calls' as const,
+          rawFinishReason: 'tool_calls',
+          traceId: 'trace-step-1',
+        };
+      }
+      throw new APIStatusError(429, 'rate limited', 'req-2', null, 'trace-fail-2');
+    };
+    const ctx = testAgent({
+      generate,
+      kaos: createCommandKaos('traced'),
+      ...singleAttemptAgentOptions(),
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure({ tools: ['Bash'] });
+    await ctx.rpc.setPermission({ mode: 'yolo' });
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'run' }] });
+    await ctx.untilTurnEnd();
+
+    // The turn failed on step 2's request: turn-level events attribute to the
+    // failed request's trace, not the previous successful step's.
+    const ended = records.find((candidate) => candidate.event === 'turn_ended');
+    expect(ended?.properties?.['reason']).toBe('failed');
+    expect(ended?.properties?.['trace_id']).toBe('trace-fail-2');
+    const interrupted = records.find((candidate) => candidate.event === 'turn_interrupted');
+    expect(interrupted?.properties?.['trace_id']).toBe('trace-fail-2');
+  });
+
+  it('does not reuse the previous step trace when beforeStep fails before a request', async () => {
+    const records: TelemetryRecord[] = [];
+    const generate: GenerateFn = async (_provider, _system, _tools, _history, _callbacks, options) => {
+      options?.onTraceId?.('trace-step-1');
+      return {
+        id: 'mock-step-1',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'running' }],
+          toolCalls: [
+            {
+              type: 'function',
+              id: 'call_traced',
+              name: 'Bash',
+              arguments: '{"command":"printf traced"}',
+            },
+          ],
+        },
+        usage: { inputOther: 1, output: 1, inputCacheRead: 0, inputCacheCreation: 0 },
+        finishReason: 'tool_calls',
+        rawFinishReason: 'tool_calls',
+        traceId: 'trace-step-1',
+      };
+    };
+    const ctx = testAgent({
+      generate,
+      kaos: createCommandKaos('traced'),
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure({ tools: ['Bash'] });
+    await ctx.rpc.setPermission({ mode: 'yolo' });
+    let beforeStepCalls = 0;
+    vi.spyOn(ctx.agent.fullCompaction, 'beforeStep').mockImplementation(async () => {
+      beforeStepCalls += 1;
+      if (beforeStepCalls === 2) throw new Error('before step failed');
+    });
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'run' }] });
+    await ctx.untilTurnEnd();
+
+    expect(records.find((record) => record.event === 'tool_call')?.properties?.['trace_id']).toBe('trace-step-1');
+    expect(records.find((record) => record.event === 'turn_interrupted')?.properties?.['trace_id']).toBeUndefined();
+    expect(records.find((record) => record.event === 'turn_ended')?.properties?.['trace_id']).toBeUndefined();
+  });
+
+  it('attributes turn-level telemetry to the last failed attempt after retries', async () => {
+    const records: TelemetryRecord[] = [];
+    let calls = 0;
+    const generate: GenerateFn = async () => {
+      calls += 1;
+      throw new APIStatusError(429, 'rate limited', `req-${String(calls)}`, null, `trace-fail-${String(calls)}`);
+    };
+    const ctx = testAgent({
+      generate,
+      initialConfig: {
+        providers: {},
+        loopControl: { maxRetriesPerStep: 2 },
+      },
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure();
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'trigger provider error' }] });
+    await ctx.untilTurnEnd();
+
+    expect(calls).toBe(2);
+    const ended = records.find((candidate) => candidate.event === 'turn_ended');
+    expect(ended?.properties?.['trace_id']).toBe('trace-fail-2');
+    const apiError = records.find((candidate) => candidate.event === 'api_error');
+    expect(apiError?.properties?.['trace_id']).toBe('trace-fail-2');
+  });
+
+  it('omits the previous attempt trace when the final retry fails before headers', async () => {
+    const records: TelemetryRecord[] = [];
+    let calls = 0;
+    const generate: GenerateFn = async () => {
+      calls += 1;
+      if (calls === 1) {
+        throw new APIStatusError(429, 'rate limited', 'req-1', null, 'trace-fail-1');
+      }
+      throw new APIConnectionError('socket hang up');
+    };
+    const ctx = testAgent({
+      generate,
+      initialConfig: {
+        providers: {},
+        loopControl: { maxRetriesPerStep: 2 },
+      },
+      telemetry: recordingTelemetry(records),
+    });
+    ctx.configure();
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'trigger mixed retry failures' }] });
+    await ctx.untilTurnEnd();
+
+    expect(calls).toBe(2);
+    expect(records.find((record) => record.event === 'api_error')?.properties?.['trace_id']).toBeUndefined();
+    expect(records.find((record) => record.event === 'turn_interrupted')?.properties?.['trace_id']).toBeUndefined();
+    expect(records.find((record) => record.event === 'turn_ended')?.properties?.['trace_id']).toBeUndefined();
+  });
+
   it('keeps transient retry handling with request-scoped OAuth auth', async () => {
     const { logger, entries } = captureLogs();
     const authKeys: string[] = [];
@@ -2104,7 +2427,7 @@ describe('Agent turn flow', () => {
     const payloads = requestLogs.map((entry) => entry.payload as Record<string, unknown>);
     expect(payloads[0]).toMatchObject({ turnStep: '0.1' });
     expect(payloads[0]).not.toHaveProperty('attempt');
-    expect(payloads[1]).toMatchObject({ turnStep: '0.1', attempt: '2/3' });
+    expect(payloads[1]).toMatchObject({ turnStep: '0.1', attempt: '2/10' });
   });
 
   it('force-refreshes OAuth credentials on video upload 401 and surfaces the provider auth error when replay 401', async () => {
@@ -2206,6 +2529,7 @@ describe('Agent turn flow', () => {
     expect(records).toContainEqual({
       event: 'tool_call',
       properties: expect.objectContaining({
+        turn_id: 0,
         tool_name: 'Bash',
         outcome: 'cancelled',
         dup_type: 'normal',
diff --git a/packages/agent-core/test/agent/turn/tool-dedup.test.ts b/packages/agent-core/test/agent/turn/tool-dedup.test.ts
index 087831645..f2aa09f9a 100644
--- a/packages/agent-core/test/agent/turn/tool-dedup.test.ts
+++ b/packages/agent-core/test/agent/turn/tool-dedup.test.ts
@@ -486,6 +486,18 @@ describe('ToolCallDeduplicator', () => {
       expect(events.filter((e) => e.event === 'tool_call_repeat')).toHaveLength(0);
     });
 
+    it('attaches the injected trace id to tool_call_repeat', async () => {
+      const { client, events } = makeRecordingTelemetry();
+      const dedup = new ToolCallDeduplicator({ telemetry: client });
+      for (let i = 0; i < 2; i += 1) {
+        dedup.beginStep({ traceId: 'trace-repeat-1' });
+        await runOriginal(dedup, `c${String(i)}`, 'Read', { p: 1 }, okResult('R'));
+        dedup.endStep();
+      }
+      const repeat = events.find((e) => e.event === 'tool_call_repeat');
+      expect(repeat?.properties?.['trace_id']).toBe('trace-repeat-1');
+    });
+
     it('labels the action as r1/r2/r3 according to the reminder tier from streak 3 through 11', async () => {
       const { client, events } = makeRecordingTelemetry();
       const dedup = new ToolCallDeduplicator({ telemetry: client });
diff --git a/packages/agent-core/test/config/configs.test.ts b/packages/agent-core/test/config/configs.test.ts
index 26aa96bb7..71f7f8d00 100644
--- a/packages/agent-core/test/config/configs.test.ts
+++ b/packages/agent-core/test/config/configs.test.ts
@@ -8,6 +8,7 @@ import { afterEach, describe, expect, it } from 'vitest';
 import { ErrorCodes, KimiError } from '../../src/errors';
 import {
   KimiConfigSchema,
+  applyPrintModeConfigDefaults,
   configToTomlData,
   ensureConfigFile,
   loadRuntimeConfig,
@@ -937,3 +938,25 @@ support_efforts = ["low", "high"]
     expect(overrides['support_efforts']).toEqual(['low', 'high']);
   });
 });
+
+describe('applyPrintModeConfigDefaults', () => {
+  it('fills unbounded print defaults when nothing is configured', () => {
+    const config = applyPrintModeConfigDefaults({ providers: {} });
+    expect(config.loopControl?.maxStepsPerTurn).toBe(0);
+    expect(config.background?.bashTaskTimeoutS).toBe(0);
+    expect(config.subagent?.timeoutMs).toBe(0);
+  });
+
+  it('lets explicit user config win over every print default', () => {
+    const config = applyPrintModeConfigDefaults({
+      providers: {},
+      loopControl: { maxStepsPerTurn: 7 },
+      background: { bashTaskTimeoutS: 30, keepAliveOnExit: true },
+      subagent: { timeoutMs: 5000 },
+    });
+    expect(config.loopControl?.maxStepsPerTurn).toBe(7);
+    expect(config.background?.bashTaskTimeoutS).toBe(30);
+    expect(config.background?.keepAliveOnExit).toBe(true);
+    expect(config.subagent?.timeoutMs).toBe(5000);
+  });
+});
diff --git a/packages/agent-core/test/config/model-overrides.test.ts b/packages/agent-core/test/config/model-overrides.test.ts
index d1caf9a52..9c06e37bb 100644
--- a/packages/agent-core/test/config/model-overrides.test.ts
+++ b/packages/agent-core/test/config/model-overrides.test.ts
@@ -45,4 +45,129 @@ describe('effectiveModelAlias', () => {
 
     expect(effectiveModelAlias(model).defaultEffort).toBe('high');
   });
+
+  it('derives the official effort list and thinking capability from a Claude model name', () => {
+    const model: ModelAlias = {
+      provider: 'anthropic',
+      model: 'claude-opus-4-6',
+      maxContextSize: 200000,
+    };
+
+    expect(effectiveModelAlias(model)).toMatchObject({
+      capabilities: ['thinking'],
+      supportEfforts: ['low', 'medium', 'high', 'max'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('infers Anthropic effort metadata for an unknown model on a non-Kimi Anthropic provider', () => {
+    const model: ModelAlias = {
+      provider: 'custom',
+      model: 'custom-anthropic-model',
+      maxContextSize: 200000,
+      protocol: 'anthropic',
+    };
+
+    expect(effectiveModelAlias(model, 'anthropic')).toMatchObject({
+      capabilities: ['thinking'],
+      supportEfforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('does not infer Anthropic effort metadata for a Kimi provider routed through the Anthropic protocol', () => {
+    const model: ModelAlias = {
+      provider: 'managed:kimi-code',
+      model: 'kimi-for-coding',
+      maxContextSize: 262144,
+      capabilities: ['thinking', 'always_thinking'],
+      protocol: 'anthropic',
+      adaptiveThinking: true,
+    };
+
+    expect(effectiveModelAlias(model, 'kimi')).toEqual(model);
+  });
+
+  it('does not infer the fallback profile without provider context', () => {
+    const model: ModelAlias = {
+      provider: 'custom',
+      model: 'custom-anthropic-model',
+      maxContextSize: 200000,
+      protocol: 'anthropic',
+    };
+
+    expect(effectiveModelAlias(model)).toEqual(model);
+  });
+
+  it('limits an adaptive_thinking=false model to budget efforts', () => {
+    const model: ModelAlias = {
+      provider: 'custom',
+      model: 'custom-anthropic-model',
+      maxContextSize: 200000,
+      protocol: 'anthropic',
+      adaptiveThinking: false,
+    };
+
+    expect(effectiveModelAlias(model, 'anthropic')).toMatchObject({
+      capabilities: ['thinking'],
+      supportEfforts: ['low', 'medium', 'high'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('keeps a declared supportEfforts list authoritative when adaptive_thinking=false', () => {
+    const model: ModelAlias = {
+      provider: 'custom',
+      model: 'custom-anthropic-model',
+      maxContextSize: 200000,
+      protocol: 'anthropic',
+      adaptiveThinking: false,
+      supportEfforts: ['low', 'high'],
+    };
+
+    expect(effectiveModelAlias(model, 'anthropic')).toMatchObject({
+      capabilities: ['thinking'],
+      supportEfforts: ['low', 'high'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('does not infer Anthropic effort metadata for an unknown model without an Anthropic protocol', () => {
+    const model: ModelAlias = {
+      provider: 'custom',
+      model: 'custom-anthropic-model',
+      maxContextSize: 200000,
+    };
+
+    expect(effectiveModelAlias(model)).toEqual(model);
+  });
+
+  it('marks official always-on models and does not surface off', () => {
+    const model: ModelAlias = {
+      provider: 'anthropic',
+      model: 'claude-fable-5',
+      maxContextSize: 200000,
+    };
+
+    expect(effectiveModelAlias(model)).toMatchObject({
+      capabilities: ['always_thinking'],
+      supportEfforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+      defaultEffort: 'high',
+    });
+  });
+
+  it('keeps an explicit supportEfforts list authoritative over the official profile', () => {
+    const model: ModelAlias = {
+      provider: 'anthropic',
+      model: 'claude-opus-4-7',
+      maxContextSize: 200000,
+      supportEfforts: ['low', 'max'],
+      defaultEffort: 'max',
+    };
+
+    expect(effectiveModelAlias(model)).toMatchObject({
+      supportEfforts: ['low', 'max'],
+      defaultEffort: 'max',
+    });
+  });
 });
diff --git a/packages/agent-core/test/harness/coder-subagent-tools.test.ts b/packages/agent-core/test/harness/coder-subagent-tools.test.ts
new file mode 100644
index 000000000..8478a03d3
--- /dev/null
+++ b/packages/agent-core/test/harness/coder-subagent-tools.test.ts
@@ -0,0 +1,484 @@
+/**
+ * Real-Session e2e for the bundled `coder` subagent profile (aligned with
+ * agent-core-v2's CODER_TOOLS). Proves the tools newly added to the profile
+ * don't just pass the profile allowlist but actually execute inside a real
+ * subagent: Skill / TodoList / background Bash + the Task* trio / plan mode
+ * enter+write+exit / a nested Agent (explore) call / a nested AgentSwarm batch.
+ * Also pins the declared-but-not-delivered contract for cron tools on sub
+ * agents (same as v2).
+ */
+
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { setTimeout as delay } from 'node:timers/promises';
+import { join } from 'pathe';
+
+import {
+  isContentPart,
+  isToolCall,
+  type FinishReason,
+  type Message,
+  type ProviderConfig,
+  type StreamedMessagePart,
+} from '@moonshot-ai/kosong';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { Agent, AgentOptions } from '../../src/agent';
+import { isBackgroundTaskTerminal } from '../../src/agent/background';
+import type { ResolvedAgentProfile } from '../../src/profile';
+import type { SDKSessionRPC } from '../../src/rpc';
+import { Session } from '../../src/session';
+import { ProviderManager } from '../../src/session/provider-manager';
+import { createScriptedGenerate } from '../agent/harness/scripted-generate';
+import { testKaos } from '../fixtures/test-kaos';
+
+const MOCK_PROVIDER = { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } as const satisfies ProviderConfig;
+
+const tempDirs: string[] = [];
+const openSessions: Session[] = [];
+
+afterEach(async () => {
+  await Promise.allSettled(openSessions.splice(0).map((s) => s.close()));
+  for (const dir of tempDirs.splice(0)) {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+type GenerateFn = NonNullable<AgentOptions['generate']>;
+
+interface StepRecord {
+  readonly label: string;
+  readonly wireTools: readonly string[];
+  readonly prevToolOutput: string | null;
+  readonly prevToolIsError: boolean;
+}
+
+function toolText(message: Message | undefined): string | null {
+  if (message === undefined) return null;
+  const parts = message.content;
+  return parts
+    .map((part) => ('text' in part && typeof part.text === 'string' ? part.text : JSON.stringify(part)))
+    .join('');
+}
+
+function lastToolMessage(history: readonly Message[]): Message | undefined {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const message = history[i]!;
+    if (message.role === 'tool') return message;
+  }
+  return undefined;
+}
+
+function callTool(name: string, args: unknown): StreamedMessagePart[] {
+  return [{ type: 'function', id: `call_${name}`, name, arguments: JSON.stringify(args) }];
+}
+
+const FINAL_TEXT =
+  'E2E-CODER-DONE: exercised Skill, TodoList, background Bash with the TaskList/TaskOutput/TaskStop ' +
+  'trio, plan mode enter/write-plan/exit, and a nested explore Agent call. Every newly aligned tool ' +
+  'executed successfully on a real Session with a real home directory, skill registry, background ' +
+  'manager, and subagent host wiring. No tool call returned an error.';
+
+function createVerifyGenerate(steps: StepRecord[]): GenerateFn {
+  let taskId = '';
+  let planPath = '';
+
+  const generate: GenerateFn = async (_chat, systemPrompt, tools, history, callbacks, options) => {
+    options?.signal?.throwIfAborted();
+    options?.onRequestStart?.();
+
+    const wireTools = tools.filter((tool) => tool.deferred !== true).map((tool) => tool.name);
+    const firstUserText = toolText(history.find((message) => message.role === 'user')) ?? '';
+    const isExploreChild = firstUserText.includes('Probe nested subagent support');
+    const isSwarmChild = firstUserText.includes('SWARM-PROBE');
+
+    let parts: StreamedMessagePart[];
+    if (isExploreChild) {
+      parts = [
+        {
+          type: 'text',
+          text: 'NESTED-EXPLORE-OK: the nested explore subagent ran and reported back to the coder.',
+        },
+      ];
+    } else if (isSwarmChild) {
+      // Long enough (>200 chars) to skip the subagent summary-continuation retry,
+      // keeping the scripted call count deterministic across the swarm batch.
+      parts = [
+        {
+          type: 'text',
+          text:
+            'SWARM-CHILD-OK: this swarm child subagent ran to completion inside the coder subagent, ' +
+            'executed its assigned slice of the batch, and is reporting the outcome back to its ' +
+            'parent so the swarm results can be aggregated.',
+        },
+      ];
+    } else {
+      const last = lastToolMessage(history);
+      const prevToolOutput = toolText(last);
+      const prevToolIsError = (last as { isError?: boolean } | undefined)?.isError === true;
+      const step = history.filter((message) => message.role === 'assistant').length + 1;
+      steps.push({ label: `step-${String(step)}`, wireTools, prevToolOutput, prevToolIsError });
+
+      switch (step) {
+        case 1:
+          parts = callTool('Skill', { skill: 'demo-skill', args: 'e2e' });
+          break;
+        case 2:
+          parts = callTool('TodoList', { todos: [{ title: 'verify-tools-e2e', status: 'in_progress' }] });
+          break;
+        case 3:
+          parts = callTool('Bash', { command: 'sleep 15', description: 'e2e bg sleep', run_in_background: true });
+          break;
+        case 4: {
+          const match = /task_id: (\S+)/.exec(prevToolOutput ?? '');
+          taskId = match?.[1] ?? '';
+          parts = callTool('TaskList', {});
+          break;
+        }
+        case 5:
+          parts = callTool('TaskOutput', { task_id: taskId, block: false });
+          break;
+        case 6:
+          parts = callTool('TaskStop', { task_id: taskId });
+          break;
+        case 7:
+          parts = callTool('EnterPlanMode', {});
+          break;
+        case 8: {
+          const match = /Plan file: (\S+)/.exec(prevToolOutput ?? '');
+          planPath = match?.[1] ?? '';
+          parts = callTool('Write', { path: planPath, content: '# e2e plan\n\nDo the thing.\n' });
+          break;
+        }
+        case 9:
+          parts = callTool('ExitPlanMode', {});
+          break;
+        case 10:
+          parts = callTool('Agent', {
+            description: 'nested explore check',
+            prompt: 'Probe nested subagent support: confirm you can run and report back.',
+            subagent_type: 'explore',
+          });
+          break;
+        case 11:
+          parts = callTool('AgentSwarm', {
+            description: 'swarm probe',
+            prompt_template: 'SWARM-PROBE {{item}}',
+            items: ['alpha', 'beta'],
+            subagent_type: 'explore',
+          });
+          break;
+        default:
+          parts = [{ type: 'text', text: FINAL_TEXT }];
+          break;
+      }
+    }
+
+    for (const part of parts) {
+      await callbacks?.onMessagePart?.(structuredClone(part));
+      options?.signal?.throwIfAborted();
+    }
+    options?.onStreamEnd?.();
+
+    const content = parts.filter((part) => isContentPart(part));
+    const toolCalls = parts.filter((part) => isToolCall(part));
+    const message: Message = {
+      role: 'assistant',
+      content: structuredClone(content),
+      toolCalls: structuredClone(toolCalls),
+    };
+    const finishReason: FinishReason = toolCalls.length > 0 ? 'tool_calls' : 'completed';
+    options?.onTraceId?.(null);
+    return {
+      id: 'mock-generate',
+      message,
+      usage: { inputOther: 1, output: 1, inputCacheRead: 0, inputCacheCreation: 0 },
+      finishReason,
+      rawFinishReason: finishReason === 'completed' ? 'stop' : finishReason,
+      traceId: null,
+    };
+  };
+  return generate;
+}
+
+const DRAIN_FINAL_TEXT =
+  'DRAIN-CHECK-DONE: started a background sleep with Bash and finished my main work. ' +
+  'The subagent run must not complete until that background task settles — this final ' +
+  'message should reach the parent only after the background task has terminated, and ' +
+  'no orphan notification turn may run on me afterwards.';
+
+async function createCoderSession(
+  generate: AgentOptions['generate'],
+): Promise<{ session: Session; mainAgent: Agent }> {
+  const sessionDir = await mkdtemp(join(tmpdir(), 'kimi-coder-tools-e2e-'));
+  tempDirs.push(sessionDir);
+  const rpc: SDKSessionRPC = {
+    emitEvent: vi.fn(async () => {}),
+    requestApproval: vi.fn(async () => ({ decision: 'approved', selectedLabel: 'approve' })),
+    requestQuestion: vi.fn(async () => null),
+    toolCall: vi.fn(async () => ({ output: '', isError: true })),
+  } as unknown as SDKSessionRPC;
+
+  const session = new Session({
+    id: 'coder-tools-drain-e2e',
+    kaos: testKaos.withCwd(sessionDir),
+    homedir: sessionDir,
+    rpc,
+    skills: { explicitDirs: [join(sessionDir, 'no-such-skills-dir')] },
+    providerManager: new ProviderManager({
+      config: {
+        providers: { test: { type: MOCK_PROVIDER.type, apiKey: MOCK_PROVIDER.apiKey } },
+        models: {
+          [MOCK_PROVIDER.model]: { provider: 'test', model: MOCK_PROVIDER.model, maxContextSize: 1_000_000 },
+        },
+      },
+    }),
+  });
+  openSessions.push(session);
+
+  const mainProfile: ResolvedAgentProfile = {
+    name: 'agent',
+    systemPrompt: () => '<system-prompt>',
+    tools: [],
+  };
+  const { agent: mainAgent } = await session.createAgent(
+    { type: 'main', generate },
+    { profile: mainProfile },
+  );
+  mainAgent.config.update({ modelAlias: MOCK_PROVIDER.model, thinkingEffort: 'off' });
+  mainAgent.permission.setMode('auto');
+  return { session, mainAgent };
+}
+
+describe('coder subagent aligned tools (real Session e2e)', () => {
+  it('runs every newly aligned tool to success inside a real coder subagent', async () => {
+    const sessionDir = await mkdtemp(join(tmpdir(), 'kimi-coder-tools-e2e-'));
+    tempDirs.push(sessionDir);
+
+    const rpc: SDKSessionRPC = {
+      emitEvent: vi.fn(async () => {}),
+      requestApproval: vi.fn(async () => ({ decision: 'approved', selectedLabel: 'approve' })),
+      requestQuestion: vi.fn(async () => null),
+      toolCall: vi.fn(async () => ({ output: '', isError: true })),
+    } as unknown as SDKSessionRPC;
+
+    const session = new Session({
+      id: 'coder-tools-e2e',
+      kaos: testKaos.withCwd(sessionDir),
+      homedir: sessionDir,
+      rpc,
+      skills: { explicitDirs: [join(sessionDir, 'no-such-skills-dir')] },
+      providerManager: new ProviderManager({
+        config: {
+          providers: { test: { type: MOCK_PROVIDER.type, apiKey: MOCK_PROVIDER.apiKey } },
+          models: {
+            [MOCK_PROVIDER.model]: { provider: 'test', model: MOCK_PROVIDER.model, maxContextSize: 1_000_000 },
+          },
+        },
+      }),
+    });
+    openSessions.push(session);
+
+    // Register an invocable skill BEFORE the child agent initializes its
+    // builtin tools (the Skill tool only registers when the shared session
+    // skill registry has model-invocable skills).
+    session.skills.registerBuiltinSkill({
+      name: 'demo-skill',
+      description: 'Demo skill for e2e',
+      path: '/skills/demo-skill/SKILL.md',
+      dir: '/skills/demo-skill',
+      content: 'Demo skill body for the e2e check.',
+      metadata: {},
+      source: 'builtin',
+    });
+
+    const steps: StepRecord[] = [];
+    const mainProfile: ResolvedAgentProfile = {
+      name: 'agent',
+      systemPrompt: () => '<system-prompt>',
+      tools: [],
+    };
+    const { agent: mainAgent } = await session.createAgent(
+      { type: 'main', generate: createVerifyGenerate(steps) },
+      { profile: mainProfile },
+    );
+    mainAgent.config.update({ modelAlias: MOCK_PROVIDER.model, thinkingEffort: 'off' });
+    mainAgent.permission.setMode('auto');
+
+    const handle = await mainAgent.subagentHost!.spawn({
+      profileName: 'coder',
+      parentToolCallId: 'e2e-agent-call',
+      prompt: 'Verify the newly aligned coder tools work end to end.',
+      description: 'verify coder tools',
+      runInBackground: false,
+      signal: new AbortController().signal,
+    });
+
+    const completion = await handle.completion;
+    expect(completion.result).toContain('E2E-CODER-DONE');
+
+    // The child's first request must carry the new tools on the wire.
+    const firstCallTools = steps[0]?.wireTools ?? [];
+    for (const expected of [
+      'Agent',
+      'AgentSwarm',
+      'Bash',
+      'Edit',
+      'EnterPlanMode',
+      'ExitPlanMode',
+      'Glob',
+      'Grep',
+      'Read',
+      'Skill',
+      'TaskList',
+      'TaskOutput',
+      'TaskStop',
+      'TodoList',
+      'Write',
+    ]) {
+      expect(firstCallTools, `wire tools should include ${expected}`).toContain(expected);
+    }
+    // Cron tools stay declared-but-not-delivered for sub agents (v2 parity).
+    expect(firstCallTools).not.toContain('CronCreate');
+    expect(firstCallTools).not.toContain('CreateGoal');
+
+    const byStep = (n: number) => steps.find((record) => record.label === `step-${String(n)}`);
+    const taskId = /task_id: (\S+)/.exec(byStep(4)?.prevToolOutput ?? '')?.[1] ?? '';
+
+    expect(byStep(2)?.prevToolOutput).toContain('Skill "demo-skill" loaded inline');
+    expect(byStep(3)?.prevToolOutput).toContain('verify-tools-e2e');
+    expect(byStep(4)?.prevToolOutput).toContain('task_id:');
+    expect(taskId).not.toBe('');
+    expect(byStep(5)?.prevToolOutput).toContain(taskId);
+    expect(byStep(6)?.prevToolIsError).toBe(false);
+    expect(byStep(7)?.prevToolIsError).toBe(false);
+    expect(byStep(8)?.prevToolOutput).toContain('Plan file:');
+    expect(byStep(9)?.prevToolIsError).toBe(false);
+    expect(byStep(10)?.prevToolOutput).toContain('Exited plan mode');
+    expect(byStep(11)?.prevToolOutput).toContain('NESTED-EXPLORE-OK');
+    expect(byStep(12)?.prevToolOutput).toContain('SWARM-CHILD-OK');
+
+    for (const record of steps) {
+      expect(record.prevToolIsError, `${record.label} saw an error tool result`).toBe(false);
+    }
+  }, 30_000);
+
+  it('blocks completion until the child background bash task settles', async () => {
+    const scripted = createScriptedGenerate();
+    scripted.mockNextResponse({
+      type: 'function',
+      id: 'c1',
+      name: 'Bash',
+      arguments: JSON.stringify({ command: 'sleep 2', description: 'drain probe', run_in_background: true }),
+    });
+    scripted.mockNextResponse({ type: 'text', text: DRAIN_FINAL_TEXT });
+    const { session, mainAgent } = await createCoderSession(scripted.generate);
+
+    const handle = await mainAgent.subagentHost!.spawn({
+      profileName: 'coder',
+      parentToolCallId: 'e2e-drain-call',
+      prompt: 'Start a short background sleep, then finish without waiting for it.',
+      description: 'drain check',
+      runInBackground: false,
+      signal: new AbortController().signal,
+    });
+
+    // The model turn ends almost immediately; completion must still be held
+    // by the background-task drain until the sleep exits (~2s).
+    const early = await Promise.race([
+      handle.completion.then(() => 'resolved' as const),
+      delay(1_200).then(() => 'pending' as const),
+    ]);
+    expect(early).toBe('pending');
+
+    const completion = await handle.completion;
+    expect(completion.result).toContain('DRAIN-CHECK-DONE');
+
+    const child = await session.ensureAgentResumed(handle.agentId);
+    // The task settled before completion, and the drain suppressed its
+    // terminal notification — no orphan turn, no <notification> in context.
+    expect(child.background.list(true)).toHaveLength(0);
+    const settled = child.background.list(false);
+    expect(settled.length).toBeGreaterThan(0);
+    for (const task of settled) {
+      expect(isBackgroundTaskTerminal(task.status)).toBe(true);
+    }
+    expect(child.turn.hasActiveTurn).toBe(false);
+    expect(JSON.stringify(child.context.history)).not.toContain('<notification ');
+  }, 30_000);
+
+  it('aborting the run during the background drain rejects the completion', async () => {
+    const scripted = createScriptedGenerate();
+    scripted.mockNextResponse({
+      type: 'function',
+      id: 'c1',
+      name: 'Bash',
+      arguments: JSON.stringify({ command: 'sleep 30', description: 'drain cancel probe', run_in_background: true }),
+    });
+    scripted.mockNextResponse({ type: 'text', text: DRAIN_FINAL_TEXT });
+    const { mainAgent } = await createCoderSession(scripted.generate);
+
+    const controller = new AbortController();
+    const handle = await mainAgent.subagentHost!.spawn({
+      profileName: 'coder',
+      parentToolCallId: 'e2e-drain-cancel-call',
+      prompt: 'Start a long background sleep, then finish without waiting for it.',
+      description: 'drain cancel check',
+      runInBackground: false,
+      signal: controller.signal,
+    });
+
+    // Both scripted LLM calls consumed ⇒ the turn has finished and the run
+    // is now held open only by the background-task drain.
+    const deadline = Date.now() + 5_000;
+    while (scripted.calls.length < 2 && Date.now() < deadline) {
+      await delay(25);
+    }
+    expect(scripted.calls.length).toBe(2);
+    await delay(300);
+    controller.abort();
+
+    await expect(handle.completion).rejects.toThrow(/abort/i);
+  }, 30_000);
+
+  it('completes cleanly when the background task settles before the final turn ends', async () => {
+    const scripted = createScriptedGenerate();
+    // The background task settles while the turn is still running: its
+    // terminal notification is delivered into the active turn (the
+    // legitimate path), so the drain afterwards has nothing to wait for
+    // and must not launch or leak a follow-up turn either.
+    scripted.mockNextResponse({
+      type: 'function',
+      id: 'c1',
+      name: 'Bash',
+      arguments: JSON.stringify({ command: 'sleep 0.2', description: 'early settle probe', run_in_background: true }),
+    });
+    scripted.mockNextResponse({
+      type: 'function',
+      id: 'c2',
+      name: 'Bash',
+      arguments: JSON.stringify({ command: 'sleep 1' }),
+    });
+    scripted.mockNextResponse({ type: 'text', text: DRAIN_FINAL_TEXT });
+    const { session, mainAgent } = await createCoderSession(scripted.generate);
+
+    const handle = await mainAgent.subagentHost!.spawn({
+      profileName: 'coder',
+      parentToolCallId: 'e2e-early-settle-call',
+      prompt: 'Start a quick background sleep, keep working briefly, then finish.',
+      description: 'early settle check',
+      runInBackground: false,
+      signal: new AbortController().signal,
+    });
+
+    const completion = await handle.completion;
+    expect(completion.result).toContain('DRAIN-CHECK-DONE');
+
+    const child = await session.ensureAgentResumed(handle.agentId);
+    expect(child.background.list(true)).toHaveLength(0);
+    expect(child.turn.hasActiveTurn).toBe(false);
+    // The task settled mid-turn, so its notification was delivered into the
+    // turn (visible in context) rather than orphaned after completion.
+    expect(JSON.stringify(child.context.history)).toContain('<notification ');
+  }, 30_000);
+});
diff --git a/packages/agent-core/test/harness/goal-session.test.ts b/packages/agent-core/test/harness/goal-session.test.ts
index 2b39b5e57..5b27ea829 100644
--- a/packages/agent-core/test/harness/goal-session.test.ts
+++ b/packages/agent-core/test/harness/goal-session.test.ts
@@ -478,9 +478,19 @@ describe('goal session end-to-end', () => {
   it('pauses the goal on provider rate limits', async () => {
     const sessionDir = await makeTempDir();
     const events: Array<Record<string, unknown>> = [];
-    const { session, agent } = await setupSession(sessionDir, events, ['GetGoal'], async () => {
-      throw new APIStatusError(429, 'Rate limited', 'req-429');
-    });
+    // Pin the retry budget to 1 attempt: the pause behavior under test does
+    // not depend on retries, and the default 10-attempt backoff would blow
+    // the test timeout.
+    const { session, agent } = await setupSession(
+      sessionDir,
+      events,
+      ['GetGoal'],
+      async () => {
+        throw new APIStatusError(429, 'Rate limited', 'req-429');
+      },
+      undefined,
+      { providers: {}, loopControl: { maxRetriesPerStep: 1 } },
+    );
     const api = new SessionAPIImpl(session);
     await api.createGoal({ agentId: 'main', objective: 'work' });
 
@@ -495,9 +505,19 @@ describe('goal session end-to-end', () => {
   it('pauses the goal on provider connection errors', async () => {
     const sessionDir = await makeTempDir();
     const events: Array<Record<string, unknown>> = [];
-    const { session, agent } = await setupSession(sessionDir, events, ['GetGoal'], async () => {
-      throw new APIConnectionError('socket hang up');
-    });
+    // Pin the retry budget to 1 attempt: the pause behavior under test does
+    // not depend on retries, and the default 10-attempt backoff would blow
+    // the test timeout.
+    const { session, agent } = await setupSession(
+      sessionDir,
+      events,
+      ['GetGoal'],
+      async () => {
+        throw new APIConnectionError('socket hang up');
+      },
+      undefined,
+      { providers: {}, loopControl: { maxRetriesPerStep: 1 } },
+    );
     const api = new SessionAPIImpl(session);
     await api.createGoal({ agentId: 'main', objective: 'work' });
 
diff --git a/packages/agent-core/test/harness/model-alias-session.test.ts b/packages/agent-core/test/harness/model-alias-session.test.ts
index 6d9b66388..18f0d327f 100644
--- a/packages/agent-core/test/harness/model-alias-session.test.ts
+++ b/packages/agent-core/test/harness/model-alias-session.test.ts
@@ -58,6 +58,34 @@ describe('HarnessAPI session model aliases', () => {
     await rm(tmp, { recursive: true, force: true });
   });
 
+  const compatibleConfig = (supportEfforts: string, defaultEffort: string) => `
+default_model = "compatible/model"
+
+[providers.compatible]
+type = "kimi"
+api_key = "test-key"
+base_url = "https://api.example.test"
+
+[models."compatible/model"]
+provider = "compatible"
+model = "compatible-model"
+protocol = "anthropic"
+max_context_size = 128000
+capabilities = ["thinking"]
+support_efforts = [${supportEfforts}]
+default_effort = "${defaultEffort}"
+`;
+
+  async function createEffortReplaySession(): Promise<string> {
+    await writeFile(configPath, compatibleConfig('"high", "max"', 'high'));
+    const rpc = await createTestRpc();
+    const created = await rpc.createSession({ workDir, model: 'compatible/model' });
+    await rpc.setThinking({ sessionId: created.id, agentId: 'main', effort: 'max' });
+    await rpc.closeSession({ sessionId: created.id });
+    await writeFile(configPath, compatibleConfig('"max"', 'max'));
+    return created.id;
+  }
+
   it('keeps the configured alias separate from the provider model across create, setModel, and resume', async () => {
     const rpc = await createTestRpc();
     const created = await rpc.createSession({
@@ -88,6 +116,99 @@ describe('HarnessAPI session model aliases', () => {
     );
   });
 
+  it('resolves the initial effort with provider context for an Anthropic-typed provider', async () => {
+    // The model name is unknown to the Anthropic profile matrix and the alias
+    // declares no protocol/capabilities itself; the provider's
+    // `type = "anthropic"` must still route the default resolution through
+    // the inferred profile (default effort "high"), not fall back to "off".
+    await writeFile(
+      configPath,
+      `
+default_model = "compat/custom"
+
+[providers.compat]
+type = "anthropic"
+api_key = "test-key"
+base_url = "https://api.example.test"
+
+[models."compat/custom"]
+provider = "compat"
+model = "joint-model-0714-vibe"
+max_context_size = 200000
+`,
+    );
+    const rpc = await createTestRpc();
+    const created = await rpc.createSession({ workDir });
+
+    const config = await rpc.getConfig({ sessionId: created.id, agentId: 'main' });
+    expect(config.thinkingEffort).toBe('high');
+
+    // The recorded bootstrap effort must survive resume unchanged.
+    await rpc.closeSession({ sessionId: created.id });
+    const freshRpc = await createTestRpc();
+    await freshRpc.resumeSession({ sessionId: created.id });
+    const restored = await freshRpc.getConfig({ sessionId: created.id, agentId: 'main' });
+    expect(restored.thinkingEffort).toBe('high');
+  });
+
+  it('honors an explicit session effort for an Anthropic-typed provider', async () => {
+    await writeFile(
+      configPath,
+      `
+default_model = "compat/custom"
+
+[providers.compat]
+type = "anthropic"
+api_key = "test-key"
+base_url = "https://api.example.test"
+
+[models."compat/custom"]
+provider = "compat"
+model = "joint-model-0714-vibe"
+max_context_size = 200000
+`,
+    );
+    const rpc = await createTestRpc();
+    const created = await rpc.createSession({ workDir, thinking: 'low' });
+
+    const config = await rpc.getConfig({ sessionId: created.id, agentId: 'main' });
+    expect(config.thinkingEffort).toBe('low');
+  });
+
+  it('restores the final effort after replaying an earlier unlisted Anthropic effort', async () => {
+    const sessionId = await createEffortReplaySession();
+
+    // The current catalog no longer lists the earlier `high` state. Replay
+    // must continue to the following `max` record instead of validating and
+    // aborting at the transient state.
+    const events: Array<Parameters<SDKAPI['emitEvent']>[0]> = [];
+    const freshRpc = await createTestRpc({ emitEvent: (event) => events.push(event) });
+
+    await expect(freshRpc.resumeSession({ sessionId })).resolves.toBeDefined();
+    expect(events).toContainEqual({
+      sessionId,
+      agentId: 'main',
+      type: 'warning',
+      code: 'anthropic-thinking-effort-not-listed',
+      message:
+        'Thinking effort "high" is not listed for model "compatible-model" (known: max). The configured value will be sent unchanged to the Anthropic-compatible backend.',
+    });
+    const restored = await freshRpc.getConfig({ sessionId, agentId: 'main' });
+    expect(restored.modelAlias).toBe('compatible/model');
+    expect(restored.thinkingEffort).toBe('max');
+  });
+
+  it('does not block resume when the warning sink fails', async () => {
+    const sessionId = await createEffortReplaySession();
+
+    const throwingRpc = await createTestRpc({
+      emitEvent: () => {
+        throw new Error('warning sink failed');
+      },
+    });
+    await expect(throwingRpc.resumeSession({ sessionId })).resolves.toBeDefined();
+  });
+
   it('re-bootstraps profile and model when resuming a session whose wire has no config.update', async () => {
     // A migrated session ships a wire.jsonl with only `metadata` and message
     // records — none of the `config.update` / `tools.set_active_tools`
@@ -464,6 +585,7 @@ max_context_size = 1000000
   async function createTestRpc(
     options: {
       readonly appVersion?: string;
+      readonly emitEvent?: (event: Parameters<SDKAPI['emitEvent']>[0]) => void;
       readonly telemetry?: TelemetryClient;
     } = {},
   ) {
@@ -475,7 +597,7 @@ max_context_size = 1000000
       telemetry: options.telemetry,
     });
     return sdkRpc({
-      emitEvent: vi.fn(),
+      emitEvent: options.emitEvent ?? vi.fn(),
       requestApproval: vi.fn(async () => ({ decision: 'rejected' as const })),
       requestQuestion: vi.fn(async () => null),
       toolCall: vi.fn(async () => ({ output: '' })),
diff --git a/packages/agent-core/test/harness/runtime-provider.test.ts b/packages/agent-core/test/harness/runtime-provider.test.ts
index f79a0d7b8..b16547a80 100644
--- a/packages/agent-core/test/harness/runtime-provider.test.ts
+++ b/packages/agent-core/test/harness/runtime-provider.test.ts
@@ -338,6 +338,34 @@ describe('resolveRuntimeProvider maxOutputSize forwarding', () => {
     });
   });
 
+  it('forwards alias.supportEfforts to the anthropic provider config', () => {
+    const resolved = resolveRuntimeProvider({
+      config: {
+        ...BASE_CONFIG,
+        providers: {
+          ...BASE_CONFIG.providers,
+          anthropic: { type: 'anthropic', apiKey: 'sk-anthropic' },
+        },
+        models: {
+          ...BASE_CONFIG.models!,
+          'compatible-alias': {
+            provider: 'anthropic',
+            model: 'compatible-model',
+            maxContextSize: 200000,
+            supportEfforts: ['low', 'high', 'max'],
+          },
+        },
+      },
+      model: 'compatible-alias',
+    });
+
+    expect(resolved.provider).toMatchObject({
+      type: 'anthropic',
+      model: 'compatible-model',
+      supportEfforts: ['low', 'high', 'max'],
+    });
+  });
+
   it('forwards alias.betaApi to the anthropic provider config', () => {
     const resolved = resolveRuntimeProvider({
       config: {
@@ -840,8 +868,10 @@ describe('resolveThinkingEffort', () => {
   });
 
   it('forces always-thinking models back on even when off is requested', () => {
-    expect(resolveThinkingEffort('off', { enabled: false }, alwaysThinkingModel)).toBe('on');
-    expect(resolveThinkingEffort(undefined, { enabled: false }, alwaysThinkingModel)).toBe('on');
+    expect(resolveThinkingEffort('off', { enabled: false }, alwaysThinkingModel, true)).toBe('on');
+    expect(resolveThinkingEffort(undefined, { enabled: false }, alwaysThinkingModel, true)).toBe(
+      'on',
+    );
   });
 });
 
diff --git a/packages/agent-core/test/harness/runtime.test.ts b/packages/agent-core/test/harness/runtime.test.ts
index 569c7d5fa..227f49825 100644
--- a/packages/agent-core/test/harness/runtime.test.ts
+++ b/packages/agent-core/test/harness/runtime.test.ts
@@ -1147,6 +1147,118 @@ base_url = "https://search.example.test/v1"
   });
 });
 
+describe('KimiCore print-mode defaults', () => {
+  let tmp: string;
+
+  afterEach(async () => {
+    if (tmp !== undefined) {
+      await rm(tmp, { recursive: true, force: true });
+    }
+    await __resetRootLoggerForTest();
+    vi.unstubAllEnvs();
+    vi.unstubAllGlobals();
+  });
+
+  async function createCorePair(homeDir: string, uiMode?: string) {
+    const [coreRpc, sdkRpc] = createRPC<CoreAPI, SDKAPI>();
+    const core = new KimiCore(coreRpc, { homeDir, uiMode });
+    const rpc = await sdkRpc({
+      emitEvent: vi.fn(),
+      requestApproval: vi.fn(async (): Promise<ApprovalResponse> => ({ decision: 'rejected' })),
+      requestQuestion: vi.fn(async () => null),
+      toolCall: vi.fn(async () => ({ output: '' })),
+    });
+    return { core, rpc };
+  }
+
+  async function setupDirs(configToml: string): Promise<{ homeDir: string; workDir: string }> {
+    tmp = await mkdtemp(join(tmpdir(), 'kimi-core-print-defaults-'));
+    const homeDir = join(tmp, 'home');
+    const workDir = join(tmp, 'work');
+    await mkdir(homeDir, { recursive: true });
+    await mkdir(workDir, { recursive: true });
+    await writeFile(join(homeDir, 'config.toml'), configToml);
+    return { homeDir, workDir };
+  }
+
+  it('applies print-mode subagent/loop defaults to sessions when uiMode is print', async () => {
+    const { homeDir, workDir } = await setupDirs(baseModelConfig());
+    const { core, rpc } = await createCorePair(homeDir, 'print');
+
+    const created = await rpc.createSession({
+      id: 'ses_print_defaults',
+      workDir,
+      model: 'default-mock',
+    });
+
+    const main = core.sessions.get(created.id)?.getReadyAgent('main');
+    expect(main?.kimiConfig?.subagent?.timeoutMs).toBe(0);
+    expect(main?.kimiConfig?.background?.bashTaskTimeoutS).toBe(0);
+    expect(main?.kimiConfig?.loopControl?.maxStepsPerTurn).toBe(0);
+
+    // The raw user config is left untouched so config reads/writes still
+    // round-trip the user's file values.
+    const raw = await core.getKimiConfig();
+    expect(raw.subagent).toBeUndefined();
+    expect(raw.loopControl).toBeUndefined();
+  });
+
+  it('keeps explicit user config over the print-mode defaults', async () => {
+    const { homeDir, workDir } = await setupDirs(`${baseModelConfig()}
+[loop_control]
+max_steps_per_turn = 7
+
+[subagent]
+timeout_ms = 5000
+`);
+    const { core, rpc } = await createCorePair(homeDir, 'print');
+
+    const created = await rpc.createSession({
+      id: 'ses_print_defaults_user_config',
+      workDir,
+      model: 'default-mock',
+    });
+
+    const main = core.sessions.get(created.id)?.getReadyAgent('main');
+    expect(main?.kimiConfig?.subagent?.timeoutMs).toBe(5000);
+    expect(main?.kimiConfig?.loopControl?.maxStepsPerTurn).toBe(7);
+  });
+
+  it('does not apply print-mode defaults outside print mode', async () => {
+    const { homeDir, workDir } = await setupDirs(baseModelConfig());
+    const { core, rpc } = await createCorePair(homeDir);
+
+    const created = await rpc.createSession({
+      id: 'ses_print_defaults_off',
+      workDir,
+      model: 'default-mock',
+    });
+
+    const main = core.sessions.get(created.id)?.getReadyAgent('main');
+    expect(main?.kimiConfig?.subagent).toBeUndefined();
+    expect(main?.kimiConfig?.loopControl).toBeUndefined();
+  });
+
+  it('applies print-mode defaults when a session is reloaded', async () => {
+    const { homeDir, workDir } = await setupDirs(baseModelConfig());
+    const { core, rpc } = await createCorePair(homeDir, 'print');
+
+    const created = await rpc.createSession({
+      id: 'ses_print_defaults_reload',
+      workDir,
+      model: 'default-mock',
+    });
+    await rpc.reloadSession({ sessionId: created.id });
+
+    // The reload path rebuilds the session through resumeSessionWithOverrides;
+    // the agent it constructs must carry the same print-mode defaults.
+    const main = core.sessions.get(created.id)?.getReadyAgent('main');
+    expect(main?.kimiConfig?.subagent?.timeoutMs).toBe(0);
+    expect(main?.kimiConfig?.background?.bashTaskTimeoutS).toBe(0);
+    expect(main?.kimiConfig?.loopControl?.maxStepsPerTurn).toBe(0);
+  });
+});
+
 async function writeSessionStartPlugin(root: string, skillBody: string): Promise<void> {
   await mkdir(join(root, 'skills', 'greeter'), { recursive: true });
   await writeFile(
diff --git a/packages/agent-core/test/logging/logger.test.ts b/packages/agent-core/test/logging/logger.test.ts
index 2b70d2011..e46a79493 100644
--- a/packages/agent-core/test/logging/logger.test.ts
+++ b/packages/agent-core/test/logging/logger.test.ts
@@ -1,4 +1,5 @@
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'pathe';
 
@@ -6,6 +7,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import {
   __resetRootLoggerForTest,
+  flushDiagnosticLogsSync,
   getRootLogger,
   log,
   redact,
@@ -429,6 +431,29 @@ describe('session routing', () => {
   });
 });
 
+describe('flushDiagnosticLogsSync', () => {
+  it('persists enqueued entries synchronously, before the async drain could run', async () => {
+    await getRootLogger().configure(defaultConfig());
+    log.error('crash marker', { error: new Error('boom') });
+
+    // No `await` between enqueue and flush: the async drain (microtask + async
+    // fs) cannot have written yet, so only the synchronous append can produce
+    // the file content below. This mirrors crash paths that call
+    // process.exit() on the same tick.
+    flushDiagnosticLogsSync();
+
+    const content = readFileSync(resolveGlobalLogPath(homeDir), 'utf-8');
+    expect(content).toContain('crash marker');
+    expect(content).toContain('boom');
+  });
+
+  it('is a silent no-op before configure', () => {
+    expect(() => {
+      flushDiagnosticLogsSync();
+    }).not.toThrow();
+  });
+});
+
 describe('redact helper', () => {
   it('returns same shape with sensitive fields replaced', () => {
     const out = redact({ user: 'x', token: 'abc', nested: { apiKey: '1' } });
diff --git a/packages/agent-core/test/loop/error-paths.e2e.test.ts b/packages/agent-core/test/loop/error-paths.e2e.test.ts
index 66bd88cb4..4188d89b8 100644
--- a/packages/agent-core/test/loop/error-paths.e2e.test.ts
+++ b/packages/agent-core/test/loop/error-paths.e2e.test.ts
@@ -58,7 +58,7 @@ describe('runTurn — error paths', () => {
         message: 'llm request failed',
         payload: {
           turnStep: 'turn-1.1',
-          attempt: '1/3',
+          attempt: '1/10',
           model: 'fake-model',
           errorName: 'Error',
           errorMessage: 'upstream blew up',
diff --git a/packages/agent-core/test/loop/retry.test.ts b/packages/agent-core/test/loop/retry.test.ts
index aedf0dda6..9c38ed781 100644
--- a/packages/agent-core/test/loop/retry.test.ts
+++ b/packages/agent-core/test/loop/retry.test.ts
@@ -9,7 +9,7 @@ import { describe, expect, it } from 'vitest';
 import type { KimiConfig } from '#/config';
 import { ErrorCodes, KimiError } from '#/errors';
 import type { LLM, LLMChatParams, LLMChatResponse } from '#/loop/llm';
-import { chatWithRetry, retryBackoffDelays } from '#/loop/retry';
+import { chatWithRetry, DEFAULT_MAX_RETRY_ATTEMPTS, retryBackoffDelays } from '#/loop/retry';
 import { ProviderManager } from '#/session/provider-manager';
 
 function okResponse(): LLMChatResponse {
@@ -57,7 +57,7 @@ describe('chatWithRetry: terminated stream drops', () => {
 
     expect(seenFields).toEqual([
       { projection: 'strict', turnStep: 't.1' },
-      { projection: 'strict', turnStep: 't.1', attempt: '2/3' },
+      { projection: 'strict', turnStep: 't.1', attempt: '2/10' },
     ]);
   });
 
@@ -168,7 +168,7 @@ describe('retryBackoffDelays', () => {
     expect(maxSeen).toBeGreaterThan(30_000);
   });
 
-  it('keeps default-attempt retries quick so interactive runs are not slowed', () => {
+  it('keeps low-attempt configs quick so latency-sensitive runs are not slowed', () => {
     // 3 attempts -> 2 delays at the bottom of the ramp (~0.5s / ~1s before
     // jitter); their sum stays small.
     const delays = retryBackoffDelays(3);
@@ -177,6 +177,39 @@ describe('retryBackoffDelays', () => {
   });
 });
 
+describe('chatWithRetry: default retry budget', () => {
+  it('retries up to DEFAULT_MAX_RETRY_ATTEMPTS before giving up', async () => {
+    // A sustained 429 carries a 1ms server retry-after so the test exercises
+    // the full default budget without sleeping through the real backoff.
+    let calls = 0;
+    const captured: Array<{ type: string }> = [];
+    const llm: LLM = {
+      systemPrompt: '',
+      modelName: 'mock',
+      isRetryableError: (e) => isRetryableGenerateError(e),
+      async chat(): Promise<LLMChatResponse> {
+        calls += 1;
+        throw new APIProviderRateLimitError('rate limited', null, 1);
+      },
+    };
+    const input = makeInput(llm, new AbortController().signal);
+
+    await expect(
+      chatWithRetry({
+        ...input,
+        dispatchEvent: async (event) => {
+          captured.push(event as { type: string });
+        },
+      }),
+    ).rejects.toMatchObject({ name: 'APIProviderRateLimitError' });
+
+    expect(calls).toBe(DEFAULT_MAX_RETRY_ATTEMPTS);
+    expect(captured.filter((e) => e.type === 'step.retrying')).toHaveLength(
+      DEFAULT_MAX_RETRY_ATTEMPTS - 1,
+    );
+  });
+});
+
 describe('chatWithRetry: honors server retry-after', () => {
   it('uses the error retryAfterMs as the retry delay instead of the backoff', async () => {
     let calls = 0;
diff --git a/packages/agent-core/test/loop/tool-call.e2e.test.ts b/packages/agent-core/test/loop/tool-call.e2e.test.ts
index 368d5b08d..2fe004d95 100644
--- a/packages/agent-core/test/loop/tool-call.e2e.test.ts
+++ b/packages/agent-core/test/loop/tool-call.e2e.test.ts
@@ -13,12 +13,13 @@ import { describe, expect, it } from 'vitest';
 
 import { ToolAccesses } from '../../src/loop';
 import type { Logger } from '../../src/logging';
-import type { ExecutableTool, ExecutableToolResult, LoopHooks, ToolExecution } from '../../src/loop';
+import type { ExecutableTool, ExecutableToolResult, LoopHooks, ToolCall, ToolExecution } from '../../src/loop';
 import { PathSecurityError } from '../../src/tools/policies/path-access';
 import {
   makeEndTurnResponse,
   makeResponse,
   makeTextParts,
+  makeThinkingParts,
   makeToolCall,
   makeToolUseResponse,
 } from './fixtures/fake-llm';
@@ -878,3 +879,117 @@ class StopSuccessTool implements ExecutableTool<Record<string, unknown>> {
     };
   }
 }
+
+
+describe('runTurn — unexecuted tool calls (abnormal step end)', () => {
+  it('records and closes a complete tool call when the step ends paused', async () => {
+    const echo = new EchoTool();
+    const { result, context, sink } = await runTurn({
+      tools: [echo],
+      responses: [
+        makeResponse(makeThinkingParts('let me run a tool'), [makeToolCall('echo', { text: 'hi' }, 'tc-1')], 'paused'),
+      ],
+    });
+
+    // The call must not execute, but it is recorded and immediately closed
+    // with a synthetic interrupted result so the exchange stays wire-valid.
+    expect(echo.calls.length).toBe(0);
+    expect(result.stopReason).toBe('paused');
+    expect(context.toolCalls().map((e) => [e.toolCallId, e.name, e.args])).toEqual([
+      ['tc-1', 'echo', { text: 'hi' }],
+    ]);
+    const results = context.toolResults();
+    expect(results.map((e) => e.toolCallId)).toEqual(['tc-1']);
+    expect(results[0]?.result.isError).toBe(true);
+    expect(expectTextOutput(results[0]?.result.output)).toContain('not executed');
+    // Events pair up in the live stream too, and the step seals as paused.
+    expect(sink.byType('tool.call').map((e) => e.toolCallId)).toEqual(['tc-1']);
+    expect(sink.byType('tool.result').map((e) => e.toolCallId)).toEqual(['tc-1']);
+    expect(context.stepEnds()[0]?.finishReason).toBe('paused');
+  });
+
+  it('sanitizes truncated (unparseable) arguments to {} when recording the call', async () => {
+    // The provider stream was cut mid-arguments: id and name arrived, the JSON
+    // did not. The recorded call must carry sanitized args — the raw fragment
+    // would crash the next request's wire conversion.
+    const partialCall: ToolCall = {
+      type: 'function',
+      id: 'tc-partial',
+      name: 'echo',
+      arguments: '{"text":"unterminated',
+    };
+    const echo = new EchoTool();
+    const { context } = await runTurn({
+      tools: [echo],
+      responses: [
+        // The realistic poison shape: an empty signed thinking block plus the
+        // partial call (what a pause_turn response carries).
+        makeResponse([{ type: 'think', think: '', encrypted: 'sig' }], [partialCall], 'paused'),
+      ],
+    });
+
+    expect(echo.calls.length).toBe(0);
+    expect(context.toolCalls().map((e) => [e.toolCallId, e.args])).toEqual([['tc-partial', {}]]);
+    const results = context.toolResults();
+    expect(results.map((e) => e.toolCallId)).toEqual(['tc-partial']);
+    expect(results[0]?.result.isError).toBe(true);
+  });
+
+  it('records and closes tool calls when the stream fails overloaded (other finish)', async () => {
+    const echo = new EchoTool();
+    const { result, context } = await runTurn({
+      tools: [echo],
+      responses: [
+        makeResponse(makeTextParts(''), [makeToolCall('echo', { text: 'hi' }, 'tc-ovl')], 'unknown'),
+      ],
+    });
+
+    expect(echo.calls.length).toBe(0);
+    expect(result.stopReason).toBe('unknown');
+    expect(context.toolCalls().map((e) => e.toolCallId)).toEqual(['tc-ovl']);
+    expect(context.toolResults().map((e) => e.toolCallId)).toEqual(['tc-ovl']);
+    expect(context.toolResults()[0]?.result.isError).toBe(true);
+  });
+
+  it('records and closes a tool call cut off by max_tokens', async () => {
+    const echo = new EchoTool();
+    const { result, context } = await runTurn({
+      tools: [echo],
+      responses: [
+        makeResponse(makeTextParts('partial answer'), [makeToolCall('echo', { text: 'hi' }, 'tc-max')], 'max_tokens'),
+      ],
+    });
+
+    expect(echo.calls.length).toBe(0);
+    expect(result.stopReason).toBe('max_tokens');
+    expect(context.toolCalls().map((e) => e.toolCallId)).toEqual(['tc-max']);
+    expect(context.toolResults().map((e) => e.toolCallId)).toEqual(['tc-max']);
+    expect(context.toolResults()[0]?.result.isError).toBe(true);
+  });
+
+  it('closes every unexecuted call in provider order', async () => {
+    const echo = new EchoTool();
+    const { context } = await runTurn({
+      tools: [echo],
+      responses: [
+        makeResponse(
+          makeThinkingParts('two calls'),
+          [makeToolCall('echo', { text: 'a' }, 'tc-a'), makeToolCall('echo', { text: 'b' }, 'tc-b')],
+          'paused',
+        ),
+      ],
+    });
+
+    expect(echo.calls.length).toBe(0);
+    expect(context.toolCalls().map((e) => e.toolCallId)).toEqual(['tc-a', 'tc-b']);
+    expect(context.toolResults().map((e) => e.toolCallId)).toEqual(['tc-a', 'tc-b']);
+  });
+
+  it('does not record synthetic results for a normal end_turn without tool calls', async () => {
+    const { context } = await runTurn({
+      responses: [makeEndTurnResponse('done')],
+    });
+    expect(context.toolCalls()).toEqual([]);
+    expect(context.toolResults()).toEqual([]);
+  });
+});
diff --git a/packages/agent-core/test/mcp/client-stdio.test.ts b/packages/agent-core/test/mcp/client-stdio.test.ts
index 356a0d949..ff2c4296d 100644
--- a/packages/agent-core/test/mcp/client-stdio.test.ts
+++ b/packages/agent-core/test/mcp/client-stdio.test.ts
@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
 import { KimiError } from '../../src/errors';
-import { mergeStdioEnv, StdioMcpClient } from '../../src/mcp/client-stdio';
+import { mergeStdioEnv, resolveStdioCwd, StdioMcpClient } from '../../src/mcp/client-stdio';
 
 const here = import.meta.dirname;
 const fixture = join(here, 'fixtures', 'mock-stdio-server.mjs');
@@ -15,6 +15,20 @@ const cwdFixture = join(here, 'fixtures', 'cwd-stdio-server.mjs');
 const stderrThenExitFixture = join(here, 'fixtures', 'stderr-then-exit-stdio-server.mjs');
 const crashAfterConnectFixture = join(here, 'fixtures', 'crash-after-connect-stdio-server.mjs');
 
+describe('stdio MCP working directory resolution', () => {
+  it('preserves the UNC share when resolving a relative server cwd', () => {
+    expect(
+      resolveStdioCwd('tools/mcp server', '\\\\Server\\Share\\Workspace'),
+    ).toBe('//Server/Share/Workspace/tools/mcp server');
+  });
+
+  it('normalizes a drive path containing spaces and non-ASCII segments', () => {
+    expect(
+      resolveStdioCwd('工具\\server', 'C:\\Users\\Example User\\项目'),
+    ).toBe('C:/Users/Example User/项目/工具/server');
+  });
+});
+
 describe('StdioMcpClient', () => {
   it('rejects unsupported executor at construction time', () => {
     expect(
diff --git a/packages/agent-core/test/mcp/config-loader.test.ts b/packages/agent-core/test/mcp/config-loader.test.ts
index f281c0551..754630b59 100644
--- a/packages/agent-core/test/mcp/config-loader.test.ts
+++ b/packages/agent-core/test/mcp/config-loader.test.ts
@@ -180,6 +180,28 @@ describe('loadMcpServers', () => {
     });
   });
 
+  it('preserves an UNC-style project root when resolving a relative stdio cwd', async () => {
+    const home = makeTempDir();
+    const repoRoot = makeTempDir();
+    const cwd = join(repoRoot, 'packages', 'agent-core');
+    await mkdir(join(repoRoot, '.git'), { recursive: true });
+    await mkdir(cwd, { recursive: true });
+    await writeJson(join(repoRoot, '.mcp.json'), {
+      mcpServers: {
+        local: { command: 'node.exe', cwd: 'tools/mcp server' },
+      },
+    });
+    const uncStyleCwd = `/${cwd}`;
+
+    const servers = await loadMcpServers({ cwd: uncStyleCwd, homeDir: home });
+
+    expect(servers['local']).toEqual({
+      transport: 'stdio',
+      command: 'node.exe',
+      cwd: `/${join(repoRoot, 'tools', 'mcp server')}`,
+    });
+  });
+
   it('throws KimiError(config.invalid) on invalid JSON', async () => {
     const home = makeTempDir();
     const cwd = makeTempDir();
@@ -243,6 +265,24 @@ describe('loadMcpServers', () => {
     });
   });
 
+  it('preserves the OAuth marker on a remote server entry', async () => {
+    const home = makeTempDir();
+    const cwd = makeTempDir();
+    await writeJson(join(home, 'mcp.json'), {
+      mcpServers: {
+        remote: { url: 'https://mcp.example.com/mcp', auth: 'oauth' },
+      },
+    });
+
+    const servers = await loadMcpServers({ cwd, homeDir: home });
+
+    expect(servers['remote']).toEqual({
+      transport: 'http',
+      url: 'https://mcp.example.com/mcp',
+      auth: 'oauth',
+    });
+  });
+
   it('loads explicit SSE server config', async () => {
     const home = makeTempDir();
     const cwd = makeTempDir();
diff --git a/packages/agent-core/test/mcp/connection-manager.test.ts b/packages/agent-core/test/mcp/connection-manager.test.ts
index 3b7a9112c..504a35b1d 100644
--- a/packages/agent-core/test/mcp/connection-manager.test.ts
+++ b/packages/agent-core/test/mcp/connection-manager.test.ts
@@ -367,7 +367,7 @@ describe('McpConnectionManager', () => {
     }
   }, 7000);
 
-  it('flips HTTP servers into needs-auth when the server returns 401 and no static token is set', async () => {
+  it('marks an explicitly OAuth HTTP server as needs-auth when non-auth headers accompany a 401', async () => {
     const server: HttpServer = createHttpServer((_req, res) => {
       res.writeHead(401, {
         'content-type': 'application/json',
@@ -385,6 +385,8 @@ describe('McpConnectionManager', () => {
         gated: {
           transport: 'http',
           url: `http://127.0.0.1:${port}/mcp`,
+          headers: { 'X-Tenant': 'example' },
+          auth: 'oauth',
           startupTimeoutMs: 5_000,
         },
       });
diff --git a/packages/agent-core/test/mcp/oauth-store.test.ts b/packages/agent-core/test/mcp/oauth-store.test.ts
index 2d3b50724..bba389755 100644
--- a/packages/agent-core/test/mcp/oauth-store.test.ts
+++ b/packages/agent-core/test/mcp/oauth-store.test.ts
@@ -128,6 +128,17 @@ describe('MCP OAuth credential identity', () => {
     expect(service.hasTokens('linear', 'https://second.example.com/mcp')).toBe(false);
   });
 
+  it('removes stored credentials when a server authorization is reset', () => {
+    const service = new McpOAuthService({ store: new JsonFileStore(dir) });
+    service
+      .getProvider('linear', 'https://mcp.example.com/mcp')
+      .saveTokens(token('access-token'));
+
+    service.invalidate('linear', 'https://mcp.example.com/mcp');
+
+    expect(service.hasTokens('linear', 'https://mcp.example.com/mcp')).toBe(false);
+  });
+
   it('uses stored client redirect URI when no active OAuth callback is running', () => {
     const provider = new McpOAuthClientProvider({
       serverName: 'notion',
diff --git a/packages/agent-core/test/profile/agent-profile-loader.test.ts b/packages/agent-core/test/profile/agent-profile-loader.test.ts
index bf744bacd..c7ef6bdb0 100644
--- a/packages/agent-core/test/profile/agent-profile-loader.test.ts
+++ b/packages/agent-core/test/profile/agent-profile-loader.test.ts
@@ -179,9 +179,30 @@ describe('default agent profiles', () => {
         'TaskStop',
       ]),
     );
-    expect(DEFAULT_AGENT_PROFILES['coder']?.tools).toEqual(
-      expect.arrayContaining(['Read', 'Write', 'Edit', 'Bash']),
-    );
+    expect(DEFAULT_AGENT_PROFILES['coder']?.tools).toEqual([
+      'Agent',
+      'AgentSwarm',
+      'Bash',
+      'CronCreate',
+      'CronDelete',
+      'CronList',
+      'Edit',
+      'EnterPlanMode',
+      'ExitPlanMode',
+      'Glob',
+      'Grep',
+      'Read',
+      'ReadMediaFile',
+      'Skill',
+      'TaskList',
+      'TaskOutput',
+      'TaskStop',
+      'TodoList',
+      'WebSearch',
+      'FetchURL',
+      'Write',
+      'mcp__*',
+    ]);
     expect(DEFAULT_AGENT_PROFILES['explore']?.tools).not.toContain('Write');
     expect(DEFAULT_AGENT_PROFILES['plan']?.tools).not.toContain('Bash');
   });
diff --git a/packages/agent-core/test/profile/default-agent-profiles.test.ts b/packages/agent-core/test/profile/default-agent-profiles.test.ts
index 17dc6f681..09b4d1cea 100644
--- a/packages/agent-core/test/profile/default-agent-profiles.test.ts
+++ b/packages/agent-core/test/profile/default-agent-profiles.test.ts
@@ -62,15 +62,19 @@ describe('default agent profiles', () => {
     ).toThrow(/Embedded agent profile source missing: profile\/default\/missing\.md/);
   });
 
-  it('omits the Skills section for subagent profiles that lack the Skill tool', () => {
-    // The root agent has the Skill tool, so the Skills section and listing render.
-    const agentPrompt = DEFAULT_AGENT_PROFILES['agent']?.systemPrompt(promptContext) ?? '';
-    expect(agentPrompt).toContain('# Skills');
-    expect(agentPrompt).toContain('- test-skill: does things');
+  it('omits the Skills section only for profiles that lack the Skill tool', () => {
+    // The root agent and coder have the Skill tool, so the Skills section and
+    // listing render in their prompts.
+    for (const name of ['agent', 'coder']) {
+      expect(DEFAULT_AGENT_PROFILES[name]?.tools).toContain('Skill');
+      const prompt = DEFAULT_AGENT_PROFILES[name]?.systemPrompt(promptContext) ?? '';
+      expect(prompt).toContain('# Skills');
+      expect(prompt).toContain('- test-skill: does things');
+    }
 
-    // Subagents (coder/explore/plan) lack the Skill tool, so neither the section
-    // heading nor the skill listing should appear in their prompt.
-    for (const name of ['coder', 'explore', 'plan']) {
+    // explore/plan lack the Skill tool, so neither the section heading nor the
+    // skill listing should appear in their prompts.
+    for (const name of ['explore', 'plan']) {
       const tools = DEFAULT_AGENT_PROFILES[name]?.tools ?? [];
       expect(tools).not.toContain('Skill');
       const prompt = DEFAULT_AGENT_PROFILES[name]?.systemPrompt(promptContext) ?? '';
diff --git a/packages/agent-core/test/services/model-catalog-service.test.ts b/packages/agent-core/test/services/model-catalog-service.test.ts
index a6d6440c2..96a0d013a 100644
--- a/packages/agent-core/test/services/model-catalog-service.test.ts
+++ b/packages/agent-core/test/services/model-catalog-service.test.ts
@@ -165,6 +165,20 @@ describe('model catalog adapters', () => {
     expect(toProtocolModel('turbo', alias).display_name).toBe('kimi-turbo');
   });
 
+  it('projects official Anthropic effort metadata inferred from the model name', () => {
+    expect(
+      toProtocolModel('opus', {
+        provider: 'anthropic',
+        model: 'claude-opus-4-6',
+        maxContextSize: 200000,
+      }),
+    ).toMatchObject({
+      capabilities: ['thinking'],
+      support_efforts: ['low', 'medium', 'high', 'max'],
+      default_effort: 'high',
+    });
+  });
+
   it('maps provider model ids and global default', () => {
     const config = catalogConfig();
     expect(
@@ -195,6 +209,46 @@ describe('ModelCatalogService', () => {
     expect(getCalls).toEqual([{ reload: true }, { reload: true }]);
   });
 
+  it('projects latest Opus efforts for unknown Anthropic-compatible models', async () => {
+    const configRef = { current: catalogConfig() };
+    configRef.current.providers['custom'] = { type: 'anthropic' };
+    configRef.current.models!['compatible'] = {
+      provider: 'custom',
+      model: 'compatible-model',
+      maxContextSize: 128000,
+    };
+    const { core } = makeCore(configRef);
+    const svc = new ModelCatalogService(makeEnv(), core, makeEventService().svc);
+
+    const compatible = (await svc.listModels()).find((model) => model.model === 'compatible');
+    expect(compatible).toMatchObject({
+      capabilities: ['thinking'],
+      support_efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+      default_effort: 'high',
+    });
+  });
+
+  it('does not project fallback efforts for a Kimi provider routed through the Anthropic protocol', async () => {
+    const configRef = { current: catalogConfig() };
+    configRef.current.models!['compatible'] = {
+      provider: 'kimi',
+      protocol: 'anthropic',
+      model: 'compatible-model',
+      maxContextSize: 128000,
+    };
+    const { core } = makeCore(configRef);
+    const svc = new ModelCatalogService(makeEnv(), core, makeEventService().svc);
+
+    const compatible = (await svc.listModels()).find((model) => model.model === 'compatible');
+    expect(compatible).toMatchObject({
+      provider: 'kimi',
+      model: 'compatible',
+    });
+    expect(compatible?.capabilities).toBeUndefined();
+    expect(compatible?.support_efforts).toBeUndefined();
+    expect(compatible?.default_effort).toBeUndefined();
+  });
+
   it('gets one provider or throws ProviderNotFoundError', async () => {
     const configRef = { current: catalogConfig() };
     const { core } = makeCore(configRef);
diff --git a/packages/agent-core/test/services/session-service.test.ts b/packages/agent-core/test/services/session-service.test.ts
index e05ecc13c..51704823e 100644
--- a/packages/agent-core/test/services/session-service.test.ts
+++ b/packages/agent-core/test/services/session-service.test.ts
@@ -414,7 +414,7 @@ describe('toProtocolSession adapter', () => {
       updatedAt: 0,
     };
     const proto = toProtocolSession(summary);
-    expect(proto.status).toBe('idle');
+    expect(proto.busy).toBe(false);
     expect(proto.usage).toEqual(emptySessionUsage());
     expect(proto.permission_rules).toEqual([]);
     expect(proto.message_count).toBe(0);
@@ -589,9 +589,9 @@ describe('SessionService.list', () => {
   });
 
   it('status filter applies post-hydration', async () => {
-    const empty = await svc.list({ status: 'running' });
+    const empty = await svc.list({ busy: true });
     expect(empty.items).toEqual([]);
-    const idle = await svc.list({ status: 'idle' });
+    const idle = await svc.list({ busy: false });
     expect(idle.items.length).toBe(3);
   });
 
@@ -947,7 +947,7 @@ describe('SessionService.undo', () => {
       { type: 'text', text: 'first prompt' },
     ]);
     expect(result.status).toMatchObject({
-      status: 'idle',
+      busy: false,
       model: 'kimi-k2',
       thinking_level: 'auto',
       permission: 'manual',
@@ -1033,89 +1033,136 @@ describe('SessionService per-domain event listeners (Phase C)', () => {
   });
 });
 
-describe('SessionService status lifecycle', () => {
-  it('getStatus returns live status', async () => {
+describe('SessionService busy lifecycle', () => {
+  it('getStatus reports no live work for a fresh session', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/status' } });
     const status = await svc.getStatus(session.id);
-    expect(status.status).toBe('idle');
+    expect(status.busy).toBe(false);
   });
 
-  it('patches created session status to idle', async () => {
+  it('patches created session to not busy', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/status2' } });
-    expect(session.status).toBe('idle');
+    expect(session).toMatchObject({
+      busy: false,
+      main_turn_active: false,
+      pending_interaction: 'none',
+    });
   });
 
-  it('turn.started moves status to running and emits status_changed', async () => {
+  it('turn.started marks the session busy and emits work_changed', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/running' } });
     eventBus.eventService.publish({
       type: 'turn.started',
       sessionId: session.id,
     } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('running');
+    expect(await svc.get(session.id)).toMatchObject({
+      busy: true,
+      main_turn_active: true,
+    });
     expect(eventBus.events).toContainEqual(expect.objectContaining({
-      type: 'event.session.status_changed',
+      type: 'event.session.work_changed',
       sessionId: session.id,
-      previous_status: 'idle',
-      status: 'running',
+      busy: true,
+      main_turn_active: true,
     }));
   });
 
-  it('turn.ended with success moves status back to idle', async () => {
-    const session = await svc.create({ metadata: { cwd: '/tmp/ended' } });
-    eventBus.eventService.publish({ type: 'turn.started', sessionId: session.id } as unknown as Event);
-    eventBus.eventService.publish({ type: 'turn.ended', sessionId: session.id, reason: 'success' } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('idle');
+  it('turn.ended marks the session not busy, whatever the reason', async () => {
+    for (const reason of ['completed', 'failed', 'blocked']) {
+      const session = await svc.create({ metadata: { cwd: `/tmp/ended-${reason}` } });
+      eventBus.eventService.publish({ type: 'turn.started', sessionId: session.id } as unknown as Event);
+      eventBus.eventService.publish({ type: 'turn.ended', sessionId: session.id, reason } as unknown as Event);
+      expect((await svc.get(session.id)).busy).toBe(false);
+    }
   });
 
-  it('turn.ended with failed moves status to aborted', async () => {
-    const session = await svc.create({ metadata: { cwd: '/tmp/aborted' } });
-    eventBus.eventService.publish({ type: 'turn.started', sessionId: session.id } as unknown as Event);
-    eventBus.eventService.publish({ type: 'turn.ended', sessionId: session.id, reason: 'failed' } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('aborted');
-  });
-
-  it('turn.ended with blocked moves status to aborted', async () => {
+  it('projects a blocked turn as failed across session wire surfaces', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/blocked' } });
     eventBus.eventService.publish({ type: 'turn.started', sessionId: session.id } as unknown as Event);
-    eventBus.eventService.publish({ type: 'turn.ended', sessionId: session.id, reason: 'blocked' } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('aborted');
+    eventBus.eventService.publish({
+      type: 'turn.ended',
+      sessionId: session.id,
+      reason: 'blocked',
+    } as unknown as Event);
+
+    expect((await svc.get(session.id)).last_turn_reason).toBe('failed');
+    expect(eventBus.events).toContainEqual(expect.objectContaining({
+      type: 'event.session.work_changed',
+      sessionId: session.id,
+      busy: false,
+      last_turn_reason: 'failed',
+    }));
   });
 
-  it('prompt.submitted moves status to running when a current prompt exists', async () => {
+  it('clears the last turn reason when a new turn starts', async () => {
+    const session = await svc.create({ metadata: { cwd: '/tmp/fresh-turn' } });
+    eventBus.eventService.publish({ type: 'turn.started', sessionId: session.id } as unknown as Event);
+    eventBus.eventService.publish({ type: 'turn.ended', sessionId: session.id, reason: 'cancelled' } as unknown as Event);
+    expect((await svc.get(session.id)).last_turn_reason).toBe('cancelled');
+
+    eventBus.eventService.publish({ type: 'turn.started', sessionId: session.id } as unknown as Event);
+    expect((await svc.get(session.id)).last_turn_reason).toBeUndefined();
+    expect(eventBus.events).toContainEqual(expect.objectContaining({
+      type: 'event.session.work_changed',
+      sessionId: session.id,
+      busy: true,
+      last_turn_reason: undefined,
+    }));
+  });
+
+  it('prompt.submitted marks the session busy when a current prompt exists', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/prompt' } });
     promptStub.activePromptIds.set(session.id, 'p1');
     eventBus.eventService.publish({ type: 'prompt.submitted', sessionId: session.id } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('running');
+    expect((await svc.get(session.id)).busy).toBe(true);
   });
 
-  it('pending approval yields awaiting_approval', async () => {
+  it('a pending approval keeps the session busy', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/approval' } });
     approvalStub.pending.set(session.id, [{ id: 'a1' }]);
     eventBus.eventService.publish({ type: 'event.approval.requested', sessionId: session.id } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('awaiting_approval');
+    expect((await svc.get(session.id)).busy).toBe(true);
   });
 
-  it('pending question yields awaiting_question', async () => {
+  it('a pending question keeps the session busy', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/question' } });
     questionStub.pending.set(session.id, [{ id: 'q1' }]);
     eventBus.eventService.publish({ type: 'event.question.requested', sessionId: session.id } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('awaiting_question');
+    expect((await svc.get(session.id)).busy).toBe(true);
   });
 
-  it('approval takes precedence over active prompt', async () => {
-    const session = await svc.create({ metadata: { cwd: '/tmp/priority' } });
-    promptStub.activePromptIds.set(session.id, 'p1');
+  it('publishes the pending interaction when busy remains true', async () => {
+    const session = await svc.create({ metadata: { cwd: '/tmp/approval-count' } });
+    eventBus.eventService.publish({
+      type: 'turn.started',
+      sessionId: session.id,
+    } as unknown as Event);
     approvalStub.pending.set(session.id, [{ id: 'a1' }]);
-    eventBus.eventService.publish({ type: 'prompt.submitted', sessionId: session.id } as unknown as Event);
-    expect((await svc.get(session.id)).status).toBe('awaiting_approval');
+
+    eventBus.eventService.publish({
+      type: 'event.approval.requested',
+      sessionId: session.id,
+    } as unknown as Event);
+
+    expect(await svc.get(session.id)).toMatchObject({
+      busy: true,
+      main_turn_active: true,
+      pending_interaction: 'approval',
+    });
+    expect(eventBus.events.at(-1)).toMatchObject({
+      type: 'event.session.work_changed',
+      busy: true,
+      main_turn_active: true,
+      pending_interaction: 'approval',
+    });
   });
 
-  it('does not emit status_changed when status is unchanged', async () => {
+  it('does not emit work_changed when all work facts are unchanged', async () => {
     const session = await svc.create({ metadata: { cwd: '/tmp/nochange' } });
-    const statusChangedCount = (e: unknown) =>
-      (e as { type?: string }).type === 'event.session.status_changed';
-    const before = eventBus.events.filter(statusChangedCount).length;
+    const workChangedCount = (e: unknown) =>
+      (e as { type?: string }).type === 'event.session.work_changed';
+    const before = eventBus.events.filter(workChangedCount).length;
     eventBus.eventService.publish({ type: 'prompt.completed', sessionId: session.id } as unknown as Event);
-    expect(eventBus.events.filter(statusChangedCount).length).toBe(before);
+    expect(eventBus.events.filter(workChangedCount).length).toBe(before);
   });
 });
diff --git a/packages/agent-core/test/services/terminal-service.test.ts b/packages/agent-core/test/services/terminal-service.test.ts
index 131573fd7..025a229c3 100644
--- a/packages/agent-core/test/services/terminal-service.test.ts
+++ b/packages/agent-core/test/services/terminal-service.test.ts
@@ -91,7 +91,7 @@ function session(id: string, cwd: string): Session {
     title: id,
     created_at: '2026-06-04T10:30:00.000Z',
     updated_at: '2026-06-04T10:30:00.000Z',
-    status: 'idle',
+    busy: false,
     archived: false,
     metadata: { cwd },
     agent_config: { model: '' },
diff --git a/packages/agent-core/test/services/workspace-registry.test.ts b/packages/agent-core/test/services/workspace-registry.test.ts
index ca618489b..f670d980f 100644
--- a/packages/agent-core/test/services/workspace-registry.test.ts
+++ b/packages/agent-core/test/services/workspace-registry.test.ts
@@ -1,4 +1,4 @@
-import { mkdtemp, mkdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { mkdtemp, mkdir, readFile, realpath, rm, symlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -10,6 +10,7 @@ import type { IEnvironmentService } from '../../src/services/environment/environ
 import type { IEventService } from '../../src/services/event/event';
 import type { ILogService } from '../../src/services/logger/logger';
 import { WorkspaceRegistryService } from '../../src/services/workspace/workspaceRegistryService';
+import { touchWorkspaceRegistry } from '../../src/session/store/workspace-registry-file';
 import { appendSessionIndexEntry } from '../../src/session/store/session-index';
 import { encodeWorkDirKey, normalizeWorkDir } from '../../src/session/store/workdir-key';
 
@@ -255,3 +256,97 @@ describe('WorkspaceRegistryService', () => {
     expect(matches[0]?.session_count).toBe(1);
   });
 });
+
+describe('touchWorkspaceRegistry', () => {
+  let homeDir: string;
+  let tempRoots: string[] = [];
+
+  beforeEach(async () => {
+    homeDir = await mkdtemp(join(tmpdir(), 'kimi-ws-touch-home-'));
+    tempRoots = [];
+  });
+
+  afterEach(async () => {
+    await rm(homeDir, { recursive: true, force: true });
+    for (const root of tempRoots) {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  async function makeProjectRoot(label: string): Promise<string> {
+    const root = await mkdtemp(join(tmpdir(), `kimi-ws-touch-${label}-`));
+    tempRoots.push(root);
+    return normalizeWorkDir(await realpath(root));
+  }
+
+  async function readRegistryFile(): Promise<{
+    version: number;
+    workspaces: Record<
+      string,
+      { root: string; name: string; created_at: string; last_opened_at: string }
+    >;
+    deleted_workspace_ids: string[];
+  }> {
+    return JSON.parse(await readFile(join(homeDir, 'workspaces.json'), 'utf-8')) as never;
+  }
+
+  it('creates a new entry in workspaces.json', async () => {
+    const root = await makeProjectRoot('new');
+
+    const result = await touchWorkspaceRegistry(homeDir, root);
+
+    expect(result.created).toBe(true);
+    expect(result.workspaceId).toBe(encodeWorkDirKey(root));
+    const file = await readRegistryFile();
+    const entry = file.workspaces[result.workspaceId];
+    expect(entry).toBeDefined();
+    expect(entry?.root).toBe(root);
+    expect(entry?.name).toBe(root.split('/').pop());
+    expect(entry?.created_at).not.toBe('');
+    expect(file.deleted_workspace_ids).toEqual([]);
+  });
+
+  it('touches an existing entry without resetting its name or created_at', async () => {
+    const root = await makeProjectRoot('touch');
+    const first = await touchWorkspaceRegistry(homeDir, root, 'custom-name');
+    const before = (await readRegistryFile()).workspaces[first.workspaceId];
+    expect(before?.name).toBe('custom-name');
+
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    const second = await touchWorkspaceRegistry(homeDir, root);
+
+    expect(second.created).toBe(false);
+    const after = (await readRegistryFile()).workspaces[first.workspaceId];
+    expect(after?.name).toBe('custom-name');
+    expect(after?.created_at).toBe(before?.created_at);
+    expect(Date.parse(after?.last_opened_at ?? '')).toBeGreaterThan(
+      Date.parse(before?.last_opened_at ?? ''),
+    );
+  });
+
+  it('clears the deletion tombstone for the touched workspace', async () => {
+    const root = await makeProjectRoot('tombstone');
+    const workspaceId = encodeWorkDirKey(root);
+    await writeFile(
+      join(homeDir, 'workspaces.json'),
+      JSON.stringify({ version: 1, workspaces: {}, deleted_workspace_ids: [workspaceId] }),
+      'utf-8',
+    );
+
+    await touchWorkspaceRegistry(homeDir, root);
+
+    const file = await readRegistryFile();
+    expect(file.deleted_workspace_ids).toEqual([]);
+    expect(file.workspaces[workspaceId]).toBeDefined();
+  });
+
+  it('recovers from a malformed workspaces.json', async () => {
+    await writeFile(join(homeDir, 'workspaces.json'), '{ not json', 'utf-8');
+    const root = await makeProjectRoot('malformed');
+
+    const result = await touchWorkspaceRegistry(homeDir, root);
+
+    const file = await readRegistryFile();
+    expect(file.workspaces[result.workspaceId]?.root).toBe(root);
+  });
+});
diff --git a/packages/agent-core/test/session/init.test.ts b/packages/agent-core/test/session/init.test.ts
index 1a8096c16..1a5ab4b4d 100644
--- a/packages/agent-core/test/session/init.test.ts
+++ b/packages/agent-core/test/session/init.test.ts
@@ -213,6 +213,50 @@ describe('Session.init', () => {
     }
   });
 
+  it('resumes a v2 session from the standard path instead of persisted homedir', async () => {
+    const workDir = await makeTempDir();
+    const sessionDir = await makeTempDir();
+    const options = {
+      id: 'test-resume-without-agent-homedir',
+      kaos: testKaos.withCwd(workDir),
+      persistenceKaos: testKaos.withCwd(workDir),
+      homedir: sessionDir,
+      rpc: createSessionRpc([]),
+      skills: { explicitDirs: [join(workDir, 'missing-skills')] },
+      providerManager: testProviderManager(),
+    };
+    const firstSession = new Session(options);
+    try {
+      await firstSession.createMain();
+    } finally {
+      await firstSession.closeForReload();
+    }
+
+    const statePath = join(sessionDir, 'state.json');
+    const now = Date.now();
+    await writeFile(statePath, JSON.stringify({
+      id: options.id,
+      version: 2,
+      createdAt: now,
+      updatedAt: now,
+      archived: false,
+      cwd: workDir,
+      agents: { main: { homedir: '/stale/session/agents/main', type: 'main' } },
+      custom: {},
+    }), 'utf-8');
+
+    const resumedSession = new Session(options);
+    try {
+      await resumedSession.resume();
+      const main = await resumedSession.ensureAgentResumed('main');
+
+      expect(main.homedir).toBe(join(sessionDir, 'agents', 'main'));
+      expect(main.config.systemPrompt).not.toBe('');
+    } finally {
+      await resumedSession.close();
+    }
+  });
+
   it('rebuilds builtin tools when rebinding the session tool kaos', async () => {
     const workDir = await makeTempDir();
     const sessionDir = await makeTempDir();
diff --git a/packages/agent-core/test/session/lifecycle-hooks.test.ts b/packages/agent-core/test/session/lifecycle-hooks.test.ts
index 71e3847fb..2993fc90e 100644
--- a/packages/agent-core/test/session/lifecycle-hooks.test.ts
+++ b/packages/agent-core/test/session/lifecycle-hooks.test.ts
@@ -297,17 +297,43 @@ describe('Session lifecycle hooks', () => {
     await session.close();
   });
 
-  it('handlePrintMainTurnCompleted returns finish by default (exit mode)', async () => {
+  it('handlePrintMainTurnCompleted finishes immediately by default once quiescent (steer mode)', async () => {
     const { sessionDir, workDir } = await hookFixture();
     const session = new Session({
       kaos: testKaos.withCwd(workDir),
-      id: 'session-print-mode-exit',
+      id: 'session-print-mode-default',
       homedir: sessionDir,
       rpc: createSessionRpc(),
       skills: { explicitDirs: [join(workDir, 'missing-skills')] },
     });
     await session.createMain();
 
+    // Default mode is 'steer'; with no pending background tasks the run finishes.
+    await expect(session.handlePrintMainTurnCompleted()).resolves.toBe('finish');
+    await session.close();
+  });
+
+  it('handlePrintMainTurnCompleted defaults to steer: continue while a task is pending, then finish', async () => {
+    const { sessionDir, workDir } = await hookFixture();
+    const session = new Session({
+      kaos: testKaos.withCwd(workDir),
+      id: 'session-print-mode-default-steer',
+      homedir: sessionDir,
+      rpc: createSessionRpc(),
+      skills: { explicitDirs: [join(workDir, 'missing-skills')] },
+    });
+    const agent = await session.createMain();
+    const { proc } = pendingProcess();
+    agent.background.registerTask(new ProcessBackgroundTask(proc, 'sleep 60', 'steer by default'));
+
+    // No background config at all: the print default is 'steer', so a pending
+    // task keeps the run alive.
+    await expect(session.handlePrintMainTurnCompleted()).resolves.toBe('continue');
+
+    await proc.kill('SIGTERM');
+    // Let the background manager observe the terminal status.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
     await expect(session.handlePrintMainTurnCompleted()).resolves.toBe('finish');
     await session.close();
   });
diff --git a/packages/agent-core/test/session/store.test.ts b/packages/agent-core/test/session/store.test.ts
index 5df0f763c..f2b776c11 100644
--- a/packages/agent-core/test/session/store.test.ts
+++ b/packages/agent-core/test/session/store.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: persisted sessions remain addressable across native path forms.
+ * Responsibilities: create/list/index behavior plus Windows drive and UNC workDir normalization.
+ * Wiring: real temporary session storage; no stubbed collaborators.
+ * Run: pnpm exec vitest run test/session/store.test.ts
+ */
 import { mkdtemp, mkdir, realpath, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -5,7 +11,11 @@ import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { SessionStore } from '../../src/session/store/session-store';
-import { appendSessionIndexEntry, readSessionIndex } from '../../src/session/store/session-index';
+import {
+  appendSessionIndexDeletion,
+  appendSessionIndexEntry,
+  readSessionIndex,
+} from '../../src/session/store/session-index';
 import { encodeWorkDirKey, normalizeWorkDir } from '../../src/session/store/workdir-key';
 
 async function makeWorkDir(label: string): Promise<string> {
@@ -51,6 +61,41 @@ describe('SessionStore', () => {
     return wd;
   }
 
+  describe('create', () => {
+    it('creates a session when an earlier index entry points to a missing directory', async () => {
+      const workDir = await trackWorkDir('stale-create');
+      const sessionId = 'session_stale_create';
+      await appendSessionIndexEntry(homeDir, {
+        sessionId,
+        sessionDir: join(homeDir, 'sessions', 'wd_stale_000000000000', sessionId),
+        workDir,
+      });
+
+      await expect(store.create({ id: sessionId, workDir })).resolves.toMatchObject({
+        id: sessionId,
+        workDir,
+      });
+    });
+
+    it('returns a canonical drive workDir when Windows separators are used', async () => {
+      const summary = await store.create({
+        id: 'session_windows_drive',
+        workDir: 'C:\\Users\\Example User\\项目',
+      });
+
+      expect(summary.workDir).toBe('C:/Users/Example User/项目');
+    });
+
+    it('preserves the share root when an UNC workDir is used', async () => {
+      const summary = await store.create({
+        id: 'session_windows_unc',
+        workDir: '\\\\Server\\Share\\Workspace\\项目',
+      });
+
+      expect(summary.workDir).toBe('//Server/Share/Workspace/项目');
+    });
+  });
+
   describe('summaryFromDir (via get/list)', () => {
     it('prefers workDir from state.json over the index entry', async () => {
       const indexWorkDir = await trackWorkDir('index');
@@ -67,6 +112,38 @@ describe('SessionStore', () => {
     });
   });
 
+  describe('list by Windows workDir', () => {
+    it('merges drive buckets when only workDir casing differs', async () => {
+      await store.create({ id: 'session_drive_upper', workDir: 'C:\\Workspace\\项目' });
+      await store.create({ id: 'session_drive_lower', workDir: 'c:\\workspace\\项目' });
+
+      const sessions = await store.list({ workDir: 'C:/WORKSPACE/项目' });
+
+      expect(sessions.map((session) => session.id).toSorted()).toEqual([
+        'session_drive_lower',
+        'session_drive_upper',
+      ]);
+    });
+
+    it('merges UNC buckets when server and share casing differs', async () => {
+      await store.create({
+        id: 'session_unc_upper',
+        workDir: '\\\\Server\\Share\\Workspace',
+      });
+      await store.create({
+        id: 'session_unc_lower',
+        workDir: '\\\\server\\share\\workspace',
+      });
+
+      const sessions = await store.list({ workDir: '//SERVER/SHARE/WORKSPACE' });
+
+      expect(sessions.map((session) => session.id).toSorted()).toEqual([
+        'session_unc_lower',
+        'session_unc_upper',
+      ]);
+    });
+  });
+
   describe('reindex', () => {
     it('adds an index entry for an on-disk session missing from the index', async () => {
       const workDir = await trackWorkDir('missing');
@@ -171,5 +248,29 @@ describe('SessionStore', () => {
       // state.json wins, so the bogus index workDir never surfaces.
       expect(listed[0]?.workDir).toBe(workDir);
     });
+
+    it('removes an entry when a deletion record follows it', async () => {
+      const workDir = await trackWorkDir('deleted-index');
+      const sessionId = 'session_deleted_index';
+      const sessionDir = await seedSessionDir(homeDir, workDir, sessionId);
+      await appendSessionIndexEntry(homeDir, { sessionId, sessionDir, workDir });
+
+      await appendSessionIndexDeletion(homeDir, sessionId);
+
+      expect((await readSessionIndex(homeDir, store.sessionsDir)).has(sessionId)).toBe(false);
+    });
+
+    it('restores an id when a live entry follows its deletion record', async () => {
+      const workDir = await trackWorkDir('restored-index');
+      const sessionId = 'session_restored_index';
+      const sessionDir = await seedSessionDir(homeDir, workDir, sessionId);
+      const entry = { sessionId, sessionDir, workDir };
+      await appendSessionIndexEntry(homeDir, entry);
+      await appendSessionIndexDeletion(homeDir, sessionId);
+
+      await appendSessionIndexEntry(homeDir, entry);
+
+      expect((await readSessionIndex(homeDir, store.sessionsDir)).get(sessionId)).toEqual(entry);
+    });
   });
 });
diff --git a/packages/agent-core/test/session/subagent-host.test.ts b/packages/agent-core/test/session/subagent-host.test.ts
index e611e1b82..778bea661 100644
--- a/packages/agent-core/test/session/subagent-host.test.ts
+++ b/packages/agent-core/test/session/subagent-host.test.ts
@@ -74,6 +74,13 @@ describe('resolveSubagentTimeoutMs', () => {
     process.env[SUBAGENT_TIMEOUT_ENV] = '-5';
     expect(resolveSubagentTimeoutMs()).toBe(DEFAULT_SUBAGENT_TIMEOUT_MS);
   });
+
+  it('treats 0 as no timeout from both config and env', () => {
+    delete process.env[SUBAGENT_TIMEOUT_ENV];
+    expect(resolveSubagentTimeoutMs(0)).toBe(0);
+    process.env[SUBAGENT_TIMEOUT_ENV] = '0';
+    expect(resolveSubagentTimeoutMs(600000)).toBe(0);
+  });
 });
 
 describe('formatSubagentTimeoutDescription', () => {
@@ -449,10 +456,19 @@ describe('SessionSubagentHost', () => {
     expect(child.llmCalls[0]?.systemPrompt).toContain('You are now running as a subagent.');
     expect(child.llmCalls[0]?.tools.map((tool) => tool.name).toSorted()).toEqual([
       'Bash',
+      'CronCreate',
+      'CronDelete',
+      'CronList',
       'Edit',
+      'EnterPlanMode',
+      'ExitPlanMode',
       'Glob',
       'Grep',
       'Read',
+      'TaskList',
+      'TaskOutput',
+      'TaskStop',
+      'TodoList',
       'Write',
     ]);
     expect(child.llmCalls[0]?.history).toMatchObject([
diff --git a/packages/agent-core/test/skill/builtin-update-config.test.ts b/packages/agent-core/test/skill/builtin-update-config.test.ts
index 2b8198313..3231da6b6 100644
--- a/packages/agent-core/test/skill/builtin-update-config.test.ts
+++ b/packages/agent-core/test/skill/builtin-update-config.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { SessionSkillRegistry, UPDATE_CONFIG_SKILL, registerBuiltinSkills } from '../../src/skill';
+import { CHECK_KIMI_CODE_DOCS_SKILL, SessionSkillRegistry, UPDATE_CONFIG_SKILL, registerBuiltinSkills } from '../../src/skill';
 
 describe('builtin skill: update-config', () => {
   it('has the expected identity and inline metadata', () => {
@@ -32,3 +32,36 @@ describe('builtin skill: update-config', () => {
     ).toBe(true);
   });
 });
+
+describe('builtin skill: check-kimi-code-docs', () => {
+  it('has the expected identity and inline metadata', () => {
+    expect(CHECK_KIMI_CODE_DOCS_SKILL.name).toBe('check-kimi-code-docs');
+    expect(CHECK_KIMI_CODE_DOCS_SKILL.source).toBe('builtin');
+    expect(CHECK_KIMI_CODE_DOCS_SKILL.description.length).toBeGreaterThan(0);
+    expect(CHECK_KIMI_CODE_DOCS_SKILL.metadata.type).toBe('inline');
+  });
+
+  it('is model-invocable (does not disable model invocation)', () => {
+    expect(CHECK_KIMI_CODE_DOCS_SKILL.metadata.disableModelInvocation).not.toBe(true);
+  });
+
+  it('pins the official docs site and the module routing list', () => {
+    const content = CHECK_KIMI_CODE_DOCS_SKILL.content;
+    expect(content).toContain('https://www.kimi.com/code/docs/en/');
+    expect(content).toContain('kimi-code-cli/configuration/');
+    expect(content).toContain('kimi-code-cli/customization/');
+    expect(content).toContain('kimi-code/membership.html');
+    expect(content).toContain('kimi-code/error-reference.html');
+    expect(content).toContain('FetchURL');
+  });
+
+  it('registers through registerBuiltinSkills and shows up as model-invocable', () => {
+    const registry = new SessionSkillRegistry();
+    registerBuiltinSkills(registry);
+
+    expect(registry.getSkill('check-kimi-code-docs')).toBeDefined();
+    expect(
+      registry.listInvocableSkills().some((skill) => skill.name === 'check-kimi-code-docs'),
+    ).toBe(true);
+  });
+});
diff --git a/packages/agent-core/test/tools/ask-user.test.ts b/packages/agent-core/test/tools/ask-user.test.ts
index 1d5676aec..dca808e1d 100644
--- a/packages/agent-core/test/tools/ask-user.test.ts
+++ b/packages/agent-core/test/tools/ask-user.test.ts
@@ -298,6 +298,7 @@ describe('AskUserQuestionTool', () => {
     const agent = {
       rpc: { requestQuestion },
       telemetry: { track: telemetryTrack },
+      turn: { traceIdForTurn: () => undefined },
       background: manager,
     } as unknown as Agent;
     const tool = new AskUserQuestionTool(agent);
@@ -345,6 +346,7 @@ describe('AskUserQuestionTool', () => {
     const agent = {
       rpc: { requestQuestion },
       telemetry: { track: vi.fn() },
+      turn: { traceIdForTurn: () => undefined },
       background: manager,
     } as unknown as Agent;
     const tool = new AskUserQuestionTool(agent);
@@ -383,7 +385,24 @@ describe('AskUserQuestionTool', () => {
     expect(result).toMatchObject({ isError: false });
     expect(result.output).toContain('dismissed');
     expect(result.output).toContain('answers');
-    expect(telemetryTrack).toHaveBeenCalledWith('question_dismissed');
+    expect(telemetryTrack).toHaveBeenCalledWith('question_dismissed', { trace_id: undefined });
+  });
+
+  it('attaches the request trace id to question telemetry', async () => {
+    const { tool, telemetryTrack } = makeTool();
+
+    await executeTool(tool, {
+      turnId: '0',
+      toolCallId: 'call_question',
+      traceId: 'trace-question-1',
+      args: input(),
+      signal,
+    });
+
+    expect(telemetryTrack).toHaveBeenCalledWith(
+      'question_answered',
+      expect.objectContaining({ answered: 1, trace_id: 'trace-question-1' }),
+    );
   });
 
   it('resolves question rpc error responses as dismissed answers', async () => {
diff --git a/packages/agent-core/test/tools/bash.test.ts b/packages/agent-core/test/tools/bash.test.ts
index 0ab643644..29be1910e 100644
--- a/packages/agent-core/test/tools/bash.test.ts
+++ b/packages/agent-core/test/tools/bash.test.ts
@@ -883,6 +883,107 @@ describe('BashTool', () => {
     expect(manager.list(false)).toHaveLength(1);
   });
 
+  describe('background timeout default (backgroundTimeoutS)', () => {
+    async function launchBackground(
+      manager: ReturnType<typeof createBackgroundManager>['manager'],
+      options?: ConstructorParameters<typeof BashTool>[3],
+      args?: Partial<BashInput>,
+    ) {
+      const registerSpy = vi.spyOn(manager, 'registerTask');
+      const execWithEnv = vi.fn().mockResolvedValue(processWithOutput());
+      const tool = bashTool(createFakeKaos({ execWithEnv, osEnv: posixEnv }), '/workspace', manager, options);
+      const result = await executeTool(tool,
+        context({ command: 'sleep 10', run_in_background: true, description: 'task', ...args }),
+      );
+      expect(result.isError).not.toBe(true);
+      return registerSpy.mock.calls[0]?.[1];
+    }
+
+    it('defaults to a 600s deadline and detach re-arm when no config is provided', async () => {
+      const manager = createBackgroundManager().manager;
+      const options = await launchBackground(manager);
+      expect(options).toMatchObject({ timeoutMs: 600_000, detachTimeoutMs: 600_000 });
+    });
+
+    it('arms no timer when backgroundTimeoutS is 0', async () => {
+      const manager = createBackgroundManager().manager;
+      const options = await launchBackground(manager, { backgroundTimeoutS: 0 });
+      // detachTimeoutMs must be `0` (clear-on-detach), not `undefined`
+      // (which would keep the armed foreground deadline).
+      expect(options).toMatchObject({ timeoutMs: undefined, detachTimeoutMs: 0 });
+    });
+
+    it('uses the configured seconds as the default deadline and detach re-arm', async () => {
+      const manager = createBackgroundManager().manager;
+      const options = await launchBackground(manager, { backgroundTimeoutS: 30 });
+      expect(options).toMatchObject({ timeoutMs: 30_000, detachTimeoutMs: 30_000 });
+    });
+
+    it('honors an explicit per-call timeout even when the default is disabled', async () => {
+      const manager = createBackgroundManager().manager;
+      const options = await launchBackground(manager, { backgroundTimeoutS: 0 }, { timeout: 42 });
+      expect(options?.timeoutMs).toBe(42_000);
+    });
+
+    it('keeps disable_timeout authoritative regardless of the configured default', async () => {
+      const manager = createBackgroundManager().manager;
+      const options = await launchBackground(manager, { backgroundTimeoutS: 30 }, { disable_timeout: true });
+      expect(options?.timeoutMs).toBeUndefined();
+    });
+
+    it('keeps a manually detached foreground command alive when backgroundTimeoutS is 0', async () => {
+      vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+      try {
+        const manager = createBackgroundManager().manager;
+        const { proc, finish } = pendingProcess();
+        const execWithEnv = vi.fn().mockResolvedValue(proc);
+        const tool = bashTool(
+          createFakeKaos({ execWithEnv, osEnv: posixEnv }),
+          '/workspace',
+          manager,
+          { backgroundTimeoutS: 0 },
+        );
+        let foregroundTaskId: string | undefined;
+        const run = executeTool(tool, {
+          ...context({ command: 'sleep 10', timeout: 1 }),
+          onForegroundTaskStart: (taskId: string) => {
+            foregroundTaskId = taskId;
+          },
+        });
+        // Flush the async spawn + registration, then detach before the 1s
+        // foreground deadline fires.
+        await vi.advanceTimersByTimeAsync(0);
+        expect(foregroundTaskId).toBeDefined();
+        manager.detach(foregroundTaskId!);
+        const released = await run;
+        expect(released.output).toContain(foregroundTaskId);
+        // Without the clear-on-detach fix, the original 1s deadline would
+        // still fire here and settle the task as timed_out.
+        await vi.advanceTimersByTimeAsync(2_000);
+        expect(manager.getTask(foregroundTaskId!)?.status).toBe('running');
+        finish();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it('tells the model there is no default timeout when backgroundTimeoutS is 0', () => {
+      const tool = bashTool(
+        createFakeKaos({ osEnv: posixEnv }),
+        '/workspace',
+        createBackgroundManager().manager,
+        { backgroundTimeoutS: 0 },
+      );
+      expect(tool.description).toContain('Background commands have no timeout by default');
+      expect(tool.description).not.toContain('default to a 600s timeout');
+      const timeoutParam = (
+        tool.parameters as { properties: { timeout: { description?: string } } }
+      ).properties.timeout;
+      expect(timeoutParam.description).toContain('Background default no timeout');
+      expect(timeoutParam.description).not.toContain('Background default 600s');
+    });
+  });
+
   it('kills a spawned background command when the task limit is reached', async () => {
     const manager = createBackgroundManager({ maxRunningTasks: 1 }).manager;
     registerProcess(manager, processWithOutput(), 'sleep 10', 'existing task');
diff --git a/packages/agent-core/test/tools/builtin-current.test.ts b/packages/agent-core/test/tools/builtin-current.test.ts
index 977d32b83..f9bae6ea6 100644
--- a/packages/agent-core/test/tools/builtin-current.test.ts
+++ b/packages/agent-core/test/tools/builtin-current.test.ts
@@ -259,6 +259,7 @@ describe('current builtin collaboration tools', () => {
         requestQuestion: vi.fn(async () => ({ 'Which path?': 'A' })),
       },
       telemetry: { track: vi.fn() },
+      turn: { traceIdForTurn: () => undefined },
     } as unknown as Agent);
 
     const input = {
diff --git a/packages/agent-core/test/tools/planning/exit-plan-mode-telemetry.test.ts b/packages/agent-core/test/tools/planning/exit-plan-mode-telemetry.test.ts
index 2dea41d53..f939c5e4a 100644
--- a/packages/agent-core/test/tools/planning/exit-plan-mode-telemetry.test.ts
+++ b/packages/agent-core/test/tools/planning/exit-plan-mode-telemetry.test.ts
@@ -62,6 +62,7 @@ function makeAgent(input: {
       requestApproval: vi.fn(async () => input.approval ?? { decision: 'approved' }),
     },
     telemetry: { track: telemetryTrack },
+    turn: { traceIdForTurn: () => undefined },
   } as unknown as Agent;
   return { agent, telemetryTrack, exitPlanMode };
 }
diff --git a/packages/agent-core/test/tools/providers/local-fetch-url.test.ts b/packages/agent-core/test/tools/providers/local-fetch-url.test.ts
index 2c0ce931f..ff23ea1d8 100644
--- a/packages/agent-core/test/tools/providers/local-fetch-url.test.ts
+++ b/packages/agent-core/test/tools/providers/local-fetch-url.test.ts
@@ -1,15 +1,48 @@
 /**
- * Covers: LocalFetchURLProvider content-kind reporting.
+ * Covers: LocalFetchURLProvider content-kind reporting, SSRF guard, and
+ * redirect handling.
  *
  * Verifies the provider tells callers whether the returned content is a
  * verbatim passthrough of the response body or the main text extracted
- * from an HTML page.
+ * from an HTML page; that it rejects URLs whose IP literal or resolved
+ * address is private / loopback / link-local; and that redirects are
+ * followed manually with every hop re-validated.
  */
 
-import { describe, expect, it, vi } from 'vitest';
+import { lookup } from 'node:dns/promises';
+
+import { Agent } from 'undici';
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
 
 import { LocalFetchURLProvider } from '../../../src/tools/providers/local-fetch-url';
 
+vi.mock('node:dns/promises', () => ({ lookup: vi.fn() }));
+
+const lookupMock = lookup as unknown as Mock;
+
+// The init's dispatcher property is typed by @types/node's bundled
+// undici-types, while the runtime value is the undici package's Agent —
+// convert through unknown to bridge the two declarations.
+function asUndiciAgent(dispatcher: RequestInit['dispatcher']): Agent {
+  return dispatcher as unknown as Agent;
+}
+
+// Keep DNS hermetic: every hostname resolves to a public address unless a
+// test overrides it (mockReset clears per-test overrides first).
+beforeEach(() => {
+  lookupMock.mockReset();
+  lookupMock.mockResolvedValue([{ address: '93.184.216.34', family: 4 }]);
+  // Connection pinning is skipped when a proxy is configured — keep the
+  // environment free of proxy variables so tests stay hermetic anywhere.
+  for (const key of ['http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY', 'all_proxy', 'ALL_PROXY']) {
+    vi.stubEnv(key, '');
+  }
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
 function htmlResponse(body: string, contentType: string): Response {
   return new Response(body, {
     status: 200,
@@ -56,3 +89,307 @@ describe('LocalFetchURLProvider content kind', () => {
     expect(result.content).toContain('quick brown fox');
   });
 });
+
+describe('LocalFetchURLProvider SSRF guard', () => {
+  it('rejects a loopback IPv4 literal without fetching or resolving DNS', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://127.0.0.1:1337/')).rejects.toThrow(
+      'Refusing to fetch private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+    expect(lookupMock).not.toHaveBeenCalled();
+  });
+
+  it('rejects an IPv4-mapped IPv6 literal', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://[::ffff:127.0.0.1]/')).rejects.toThrow(
+      'Refusing to fetch private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects localhost and *.localhost aliases', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://localhost:1337/')).rejects.toThrow(
+      'Refusing to fetch private host',
+    );
+    await expect(provider.fetch('http://ev1l.localhost/')).rejects.toThrow(
+      'Refusing to fetch private host',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects a hostname that resolves to a loopback address', async () => {
+    lookupMock.mockResolvedValue([
+      { address: '::1', family: 6 },
+      { address: '127.0.0.1', family: 4 },
+    ]);
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://localtest.me/')).rejects.toThrow(
+      'resolves to private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects a hostname that resolves to an IPv4-mapped IPv6 address', async () => {
+    lookupMock.mockResolvedValue([{ address: '::ffff:169.254.169.254', family: 6 }]);
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://sneaky.example.com/')).rejects.toThrow(
+      'resolves to private address',
+    );
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('fails closed when DNS resolution fails', async () => {
+    lookupMock.mockRejectedValue(new Error('getaddrinfo ENOTFOUND b0rked.example'));
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('http://b0rked.example/')).rejects.toThrow('Cannot resolve host');
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('rejects non-http(s) schemes before any network access', async () => {
+    const fetchImpl = vi.fn<typeof fetch>();
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('file:///etc/passwd')).rejects.toThrow('Unsupported URL scheme');
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('fetches public hosts normally', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/');
+
+    expect(result.content).toBe('ok');
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(lookupMock).toHaveBeenCalledWith('example.com', { all: true });
+  });
+
+  it('skips all checks when allowPrivateAddresses is set', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('local', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl, allowPrivateAddresses: true });
+
+    const result = await provider.fetch('http://127.0.0.1:1337/');
+
+    expect(result.content).toBe('local');
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(lookupMock).not.toHaveBeenCalled();
+  });
+});
+
+describe('LocalFetchURLProvider redirects', () => {
+  it('follows a redirect after re-validating the target, fetching manually', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(
+        new Response(null, {
+          status: 302,
+          headers: { location: 'https://cdn.example.com/page' },
+        }),
+      )
+      .mockResolvedValueOnce(htmlResponse('final body', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/start');
+
+    expect(result.content).toBe('final body');
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+    expect(lookupMock).toHaveBeenCalledWith('cdn.example.com', { all: true });
+    const [, firstInit] = fetchImpl.mock.calls[0]!;
+    expect((firstInit as RequestInit).redirect).toBe('manual');
+  });
+
+  it('resolves relative redirect targets against the current URL', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(new Response(null, { status: 301, headers: { location: '/final' } }))
+      .mockResolvedValueOnce(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/start');
+
+    const [secondUrl] = fetchImpl.mock.calls[1]!;
+    expect(secondUrl).toBe('https://example.com/final');
+  });
+
+  it('refuses a redirect to a private IP literal', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(
+      new Response(null, {
+        status: 302,
+        headers: { location: 'http://169.254.169.254/latest/meta-data' },
+      }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/start')).rejects.toThrow(
+      'Refusing to fetch private address',
+    );
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it('refuses a redirect whose target host resolves to a private address', async () => {
+    lookupMock.mockImplementation(async (host: string) =>
+      host === 'internal.example.com'
+        ? [{ address: '10.0.0.7', family: 4 }]
+        : [{ address: '93.184.216.34', family: 4 }],
+    );
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(
+      new Response(null, {
+        status: 302,
+        headers: { location: 'https://internal.example.com/' },
+      }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/')).rejects.toThrow(
+      'resolves to private address',
+    );
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it('gives up after too many redirects', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockImplementation(
+      async () => new Response(null, { status: 302, headers: { location: '/loop' } }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/loop')).rejects.toThrow(
+      'Too many redirects',
+    );
+    expect(fetchImpl).toHaveBeenCalledTimes(11);
+  });
+
+  it('treats a redirect response without a Location header as final', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(
+        new Response('odd', { status: 302, headers: { 'content-type': 'text/plain' } }),
+      );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/odd');
+
+    expect(result.content).toBe('odd');
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('LocalFetchURLProvider connection pinning', () => {
+  it('pins a public-host fetch to the addresses validated by the safety check', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    const result = await provider.fetch('https://example.com/');
+
+    expect(result.content).toBe('ok');
+    const [, init] = fetchImpl.mock.calls[0]!;
+    const dispatcher = (init as RequestInit).dispatcher;
+    expect(dispatcher).toBeInstanceOf(Agent);
+    // The DNS answer was validated once and reused for the connection.
+    expect(lookupMock).toHaveBeenCalledTimes(1);
+    // The per-hop Agent is closed once the body has been consumed.
+    expect(asUndiciAgent(dispatcher).closed).toBe(true);
+  });
+
+  it('pins every redirect hop to its own validated addresses and closes both Agents', async () => {
+    const fetchImpl = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(new Response(null, { status: 302, headers: { location: '/next' } }))
+      .mockResolvedValueOnce(htmlResponse('done', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/start');
+
+    const first = (fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher;
+    const second = (fetchImpl.mock.calls[1]![1] as RequestInit).dispatcher;
+    expect(first).toBeInstanceOf(Agent);
+    expect(second).toBeInstanceOf(Agent);
+    expect(first).not.toBe(second);
+    expect(asUndiciAgent(first).closed).toBe(true);
+    expect(asUndiciAgent(second).closed).toBe(true);
+    expect(lookupMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('passes no dispatcher for an IP literal', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('http://93.184.216.34/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeUndefined();
+  });
+
+  it('passes no dispatcher when allowPrivateAddresses is set', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl, allowPrivateAddresses: true });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeUndefined();
+  });
+
+  it('passes no dispatcher when an HTTP proxy is configured', async () => {
+    vi.stubEnv('http_proxy', 'http://proxy.example:8080');
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeUndefined();
+  });
+
+  it('still pins when the request bypasses the proxy via NO_PROXY wildcard', async () => {
+    vi.stubEnv('http_proxy', 'http://proxy.example:8080');
+    vi.stubEnv('no_proxy', '*');
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeInstanceOf(Agent);
+  });
+
+  it('still pins when NO_PROXY exempts the target host specifically', async () => {
+    vi.stubEnv('http_proxy', 'http://proxy.example:8080');
+    vi.stubEnv('no_proxy', 'example.com');
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(htmlResponse('ok', 'text/plain'));
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await provider.fetch('https://example.com/');
+
+    expect((fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher).toBeInstanceOf(Agent);
+  });
+
+  it('rejects oversized responses by content-length and still closes the pinned Agent', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(
+      new Response('short', {
+        status: 200,
+        headers: {
+          'content-type': 'text/plain',
+          'content-length': String(11 * 1024 * 1024),
+        },
+      }),
+    );
+    const provider = new LocalFetchURLProvider({ fetchImpl });
+
+    await expect(provider.fetch('https://example.com/big')).rejects.toThrow(
+      'Response body too large',
+    );
+
+    const dispatcher = (fetchImpl.mock.calls[0]![1] as RequestInit).dispatcher;
+    expect(asUndiciAgent(dispatcher).closed).toBe(true);
+  });
+});
diff --git a/packages/agent-core/test/tools/todo-list.test.ts b/packages/agent-core/test/tools/todo-list.test.ts
index 003e14a2e..56094f532 100644
--- a/packages/agent-core/test/tools/todo-list.test.ts
+++ b/packages/agent-core/test/tools/todo-list.test.ts
@@ -113,6 +113,18 @@ describe('TodoListTool', () => {
     expect(getTodos()).toEqual([{ title: 'existing', status: 'in_progress' }]);
   });
 
+  it('exposes the visible todo items in the tool-call display', () => {
+    const { tool } = makeTool([{ title: 'existing', status: 'in_progress' }]);
+
+    const execution = tool.resolveExecution({});
+
+    if (execution.isError === true) throw new TypeError('expected runnable execution');
+    expect(execution.display).toEqual({
+      kind: 'todo_list',
+      items: [{ title: 'existing', status: 'in_progress' }],
+    });
+  });
+
   it('write mode replaces the list and defensively copies todos into the store', async () => {
     const { tool, getTodos } = makeTool();
     const todos: TodoItem[] = [
diff --git a/packages/kap-server/package.json b/packages/kap-server/package.json
index 0addee44b..622e82212 100644
--- a/packages/kap-server/package.json
+++ b/packages/kap-server/package.json
@@ -24,7 +24,6 @@
     "@fastify/multipart": "^10.0.0",
     "@fastify/swagger": "^9.7.0",
     "@moonshot-ai/agent-core-v2": "workspace:^",
-    "@moonshot-ai/protocol": "workspace:^",
     "bcryptjs": "^2.4.3",
     "fastify": "^5.1.0",
     "pino": "^9.5.0",
diff --git a/packages/kap-server/src/envelope.ts b/packages/kap-server/src/envelope.ts
index e1982c4a2..88f626cca 100644
--- a/packages/kap-server/src/envelope.ts
+++ b/packages/kap-server/src/envelope.ts
@@ -1,12 +1,7 @@
 /**
- * Re-export the envelope helpers from `@moonshot-ai/protocol`.
+ * Re-export the envelope helpers from the local `protocol` module.
  *
- * The wire-shape source of truth lives in `@moonshot-ai/protocol`. Re-exporting
- * the protocol helpers preserves field order and JSON output for server
- * responses.
- *
- * Keep this file as a re-export shim (not a direct re-export from the package
- * barrel) so downstream `from './envelope'` imports inside the server stay
- * stable and don't all need to be touched.
+ * Keep this file as a re-export shim so downstream `from './envelope'`
+ * imports inside the server stay stable and don't all need to be touched.
  */
-export { okEnvelope, errEnvelope, type Envelope } from '@moonshot-ai/protocol';
+export { okEnvelope, errEnvelope, type Envelope } from './protocol/envelope';
diff --git a/packages/kap-server/src/error-handler.ts b/packages/kap-server/src/error-handler.ts
index e2d17e75c..010eb6a05 100644
--- a/packages/kap-server/src/error-handler.ts
+++ b/packages/kap-server/src/error-handler.ts
@@ -17,7 +17,8 @@
  * we never bleed it into the JSON response.
  */
 
-import { errEnvelope, ErrorCode } from '@moonshot-ai/protocol';
+import { errEnvelope } from './envelope';
+import { ErrorCode } from './protocol/error-codes';
 import type { FastifyError } from 'fastify';
 
 /**
diff --git a/packages/kap-server/src/lib/requestLog.ts b/packages/kap-server/src/lib/requestLog.ts
new file mode 100644
index 000000000..bf58f244b
--- /dev/null
+++ b/packages/kap-server/src/lib/requestLog.ts
@@ -0,0 +1,20 @@
+/**
+ * Per-request pino logger access for route handlers whose request type is
+ * structurally narrowed (`defineRoute` declares only the fields a handler
+ * uses). At runtime every handler receives a real Fastify request, which
+ * always carries `log` — the same pattern `error-handler.ts` relies on.
+ */
+
+import type { Logger } from 'pino';
+
+/** Minimal pino surface used by route handlers. */
+export type RequestLogger = Pick<Logger, 'info' | 'warn' | 'error'>;
+
+/**
+ * Extract Fastify's per-request logger from a narrowed route-handler request.
+ * Returns `undefined` only for hand-rolled test doubles that never install a
+ * logger — callers should use optional chaining.
+ */
+export function requestLog(req: { id: string }): RequestLogger | undefined {
+  return (req as { log?: RequestLogger }).log;
+}
diff --git a/packages/kap-server/src/middleware/auth.ts b/packages/kap-server/src/middleware/auth.ts
index f3a1d670d..b79711242 100644
--- a/packages/kap-server/src/middleware/auth.ts
+++ b/packages/kap-server/src/middleware/auth.ts
@@ -29,6 +29,24 @@ export interface AuthHookOptions {
   readonly validateCredential?: CredentialValidator;
 }
 
+/**
+ * Decode the request path the same way the router does before matching.
+ *
+ * `req.url` is the raw, still percent-encoded URL, while find-my-way matches
+ * routes against the decoded path — so a raw `/%61pi/…` reaches the `/api/…`
+ * handlers. Checking the decoded path keeps the auth decision aligned with
+ * routing. Returns `null` when the path cannot be decoded, in which case the
+ * caller must fail closed.
+ */
+function decodeRequestPath(rawUrl: string): string | null {
+  const path = rawUrl.split('?', 1)[0] ?? rawUrl;
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Default bypass policy — the security boundary.
  *
@@ -47,7 +65,11 @@ function defaultIsBypassed(req: FastifyRequest): boolean {
   if (req.method === 'OPTIONS') {
     return true;
   }
-  const path = req.url.split('?', 1)[0] ?? req.url;
+  const path = decodeRequestPath(req.url);
+  if (path === null) {
+    // Fail closed: an undecodable path must never skip authentication.
+    return false;
+  }
   if (req.method === 'GET' && path === '/api/v1/healthz') {
     return true;
   }
diff --git a/packages/kap-server/src/middleware/rateLimit.ts b/packages/kap-server/src/middleware/rateLimit.ts
index ba400b8de..229e4750f 100644
--- a/packages/kap-server/src/middleware/rateLimit.ts
+++ b/packages/kap-server/src/middleware/rateLimit.ts
@@ -23,6 +23,8 @@ export interface AuthFailureLimiterOptions {
   readonly windowMs?: number;
   /** Ban duration in ms once the threshold is hit. Default `60_000`. */
   readonly banMs?: number;
+  /** Emits a warn line when a source crosses into a ban. */
+  readonly logger?: { warn(obj: unknown, msg: string): void };
 }
 
 /** Minimal surface consumed by `createAuthHook`. */
@@ -87,7 +89,14 @@ export function createAuthFailureLimiter(
       }
       entry.count += 1;
       if (entry.count >= maxFailures) {
+        const wasBanned = entry.bannedUntil > now;
         entry.bannedUntil = now + banMs;
+        if (!wasBanned) {
+          opts?.logger?.warn(
+            { ip, bannedUntil: entry.bannedUntil },
+            'too many failed auth attempts; source temporarily banned',
+          );
+        }
       }
     },
     isBanned(ip: string): boolean {
diff --git a/packages/kap-server/src/middleware/schema.ts b/packages/kap-server/src/middleware/schema.ts
index 76081eff5..209632133 100644
--- a/packages/kap-server/src/middleware/schema.ts
+++ b/packages/kap-server/src/middleware/schema.ts
@@ -7,7 +7,7 @@
  * already drive runtime validation — no second source of truth.
  */
 
-import { envelopeSchema } from '@moonshot-ai/protocol';
+import { envelopeSchema } from '../protocol/envelope';
 import { z } from 'zod';
 
 /**
diff --git a/packages/kap-server/src/middleware/securityHeaders.ts b/packages/kap-server/src/middleware/securityHeaders.ts
index 412218b1a..6df53f750 100644
--- a/packages/kap-server/src/middleware/securityHeaders.ts
+++ b/packages/kap-server/src/middleware/securityHeaders.ts
@@ -9,9 +9,17 @@
  * Headers:
  *   - `X-Content-Type-Options: nosniff` — stop MIME sniffing.
  *   - `Referrer-Policy: no-referrer` — never leak the URL to third parties.
- *   - `Content-Security-Policy` — the bundled Web UI is same-origin. Images
- *     additionally allow `data:` for persisted base64 content and `blob:` for
- *     local attachment previews and authenticated media responses.
+ *   - `Content-Security-Policy` — the bundled Web UI is same-origin, so
+ *     `default-src 'self'` covers scripts, styles, and connections.
+ *     `img-src` additionally allows `data:` (persisted base64 images) and
+ *     `blob:` (local attachment previews, authenticated media — #1672);
+ *     `font-src` additionally allows `data:` (KaTeX and the Inter /
+ *     JetBrains Mono Variable fonts ship `@font-face` data URIs in their
+ *     distributed CSS). `form-action`, `base-uri`, and `frame-ancestors`
+ *     do NOT fall back to `default-src`, so they are set explicitly.
+ *     Invariant: the served bundle must contain no inline scripts (guarded
+ *     by a kimi-web test), so plain `script-src` falling back to
+ *     `default-src 'self'` suffices.
  *   - `Strict-Transport-Security` — ONLY when `opts.tls === true`. In this
  *     phase TLS is terminated by a reverse proxy (Caddy/nginx), so `start.ts`
  *     passes `tls: false` and HSTS is omitted here; the proxy is responsible
@@ -26,7 +34,8 @@ export interface SecurityHeadersOptions {
 }
 
 const HSTS_VALUE = 'max-age=31536000';
-const CONTENT_SECURITY_POLICY = "default-src 'self'; img-src 'self' data: blob:";
+const CONTENT_SECURITY_POLICY =
+  "default-src 'self'; img-src 'self' data: blob:; font-src 'self' data:; form-action 'self'; base-uri 'none'; frame-ancestors 'self'";
 
 /**
  * Build the `onSend` hook. Returns the payload unchanged so Fastify continues
diff --git a/packages/kap-server/src/middleware/validate.ts b/packages/kap-server/src/middleware/validate.ts
index 8439f3688..f3a226f47 100644
--- a/packages/kap-server/src/middleware/validate.ts
+++ b/packages/kap-server/src/middleware/validate.ts
@@ -18,7 +18,7 @@
  * reach the generic error hook, which only emits 50001 for unknown exceptions.
  */
 
-import { ErrorCode } from '@moonshot-ai/protocol';
+import { ErrorCode } from '../protocol/error-codes';
 import type { z } from 'zod';
 
 /**
diff --git a/packages/kap-server/src/openapi/transforms.ts b/packages/kap-server/src/openapi/transforms.ts
index 316d10dcd..ffc27d497 100644
--- a/packages/kap-server/src/openapi/transforms.ts
+++ b/packages/kap-server/src/openapi/transforms.ts
@@ -7,15 +7,16 @@
  * session-action dispatcher only serves `::archive` in v2, so this module
  * projects `/sessions/{tail}` into a single `/sessions/{session_id}:archive`
  * operation — unlike v1, which clones it into fork / compact / undo. Wire
- * schemas are re-used from `@moonshot-ai/protocol`; none are re-declared here.
+ * schemas are re-used from the local `protocol/` tree and `@moonshot-ai/agent-core-v2`; none are re-declared here.
  */
 
 import {
-  archiveSessionResponseSchema,
   fsDiffRequestSchema,
   fsDiffResponseSchema,
   fsGitStatusRequestSchema,
   fsGitStatusResponseSchema,
+} from '@moonshot-ai/agent-core-v2/app/git/git';
+import {
   fsGrepRequestSchema,
   fsGrepResponseSchema,
   fsListManyRequestSchema,
@@ -24,30 +25,35 @@ import {
   fsListResponseSchema,
   fsMkdirRequestSchema,
   fsMkdirResponseSchema,
-  fsOpenInRequestSchema,
-  fsOpenInResponseSchema,
-  fsOpenRequestSchema,
-  fsOpenResponseSchema,
   fsReadRequestSchema,
   fsReadResponseSchema,
-  fsRevealRequestSchema,
-  fsRevealResponseSchema,
   fsSearchRequestSchema,
   fsSearchResponseSchema,
   fsStatManyRequestSchema,
   fsStatManyResponseSchema,
   fsStatRequestSchema,
   fsStatResponseSchema,
-  questionDismissResultSchema,
-  questionResolveRequestSchema,
-  questionResolveResultSchema,
-} from '@moonshot-ai/protocol';
+} from '@moonshot-ai/agent-core-v2/session/sessionFs/fs';
 import { z } from 'zod';
 
 import {
   openApiDocumentEnvelopeJsonSchema,
   openApiDocumentJsonSchema,
 } from '../middleware/schema';
+import {
+  fsOpenInRequestSchema,
+  fsOpenInResponseSchema,
+  fsOpenRequestSchema,
+  fsOpenResponseSchema,
+  fsRevealRequestSchema,
+  fsRevealResponseSchema,
+} from '../protocol/rest-fs';
+import {
+  questionDismissResultSchema,
+  questionResolveRequestSchema,
+  questionResolveResultSchema,
+} from '../protocol/rest-question';
+import { archiveSessionResponseSchema } from '../protocol/rest-session';
 
 const binarySchema = {
   type: 'string',
diff --git a/packages/kap-server/src/protocol/approval.ts b/packages/kap-server/src/protocol/approval.ts
new file mode 100644
index 000000000..0790a59f9
--- /dev/null
+++ b/packages/kap-server/src/protocol/approval.ts
@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+export const approvalDecisionSchema = z.enum(['approved', 'rejected', 'cancelled']);
+export type ApprovalDecision = z.infer<typeof approvalDecisionSchema>;
+
+export const approvalScopeSchema = z.enum(['session']);
+export type ApprovalScope = z.infer<typeof approvalScopeSchema>;
+
+export const approvalRequestSchema = z.object({
+  approval_id: z.string().min(1),
+  session_id: z.string().min(1),
+  turn_id: z.number().int().nonnegative().optional(),
+  tool_call_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  action: z.string(),
+  tool_input_display: z.unknown(),
+  created_at: isoDateTimeSchema,
+  expires_at: isoDateTimeSchema,
+});
+export type ApprovalRequest = z.infer<typeof approvalRequestSchema>;
+
+export const approvalResponseSchema = z.object({
+  decision: approvalDecisionSchema,
+  scope: approvalScopeSchema.optional(),
+  feedback: z.string().optional(),
+  selected_label: z.string().optional(),
+});
+export type ApprovalResponse = z.infer<typeof approvalResponseSchema>;
diff --git a/packages/kap-server/src/protocol/asyncapi.ts b/packages/kap-server/src/protocol/asyncapi.ts
new file mode 100644
index 000000000..5b06b82df
--- /dev/null
+++ b/packages/kap-server/src/protocol/asyncapi.ts
@@ -0,0 +1,144 @@
+import { z } from 'zod';
+
+import { wsOperations, type WsOperationDefinition } from './ws-control';
+
+const ASYNCAPI_VERSION = '3.1.0';
+const DEFAULT_TITLE = 'Kimi Code WebSocket API';
+const DEFAULT_VERSION = '0.1.0';
+const DEFAULT_SERVER_HOST = 'localhost';
+const DEFAULT_WS_PATH = '/api/v1/ws';
+const CHANNEL_ID = 'kimiCodeWebSocket';
+const ASYNCAPI_OPERATIONS: readonly WsOperationDefinition[] = wsOperations;
+
+export interface AsyncApiDocumentOptions {
+  readonly title?: string;
+  readonly version?: string;
+  readonly serverHost?: string;
+  readonly serverProtocol?: 'ws' | 'wss';
+  readonly wsPath?: string;
+}
+
+export function createAsyncApiDocument(
+  options: AsyncApiDocumentOptions = {},
+): Record<string, unknown> {
+  const title = options.title ?? DEFAULT_TITLE;
+  const version = options.version ?? DEFAULT_VERSION;
+  const serverHost = options.serverHost ?? DEFAULT_SERVER_HOST;
+  const serverProtocol = options.serverProtocol ?? 'ws';
+  const wsPath = options.wsPath ?? DEFAULT_WS_PATH;
+  const messages = buildMessages();
+  const channelMessages = Object.fromEntries(
+    Object.keys(messages).map((id) => [id, { $ref: `#/components/messages/${id}` }]),
+  );
+
+  return {
+    asyncapi: ASYNCAPI_VERSION,
+    info: {
+      title,
+      version,
+      description:
+        'WebSocket protocol for Kimi Code daemon control frames, acknowledgements, system frames, and session event streaming.',
+    },
+    defaultContentType: 'application/json',
+    servers: {
+      local: {
+        host: serverHost,
+        protocol: serverProtocol,
+        pathname: wsPath,
+        description: 'Kimi Code daemon WebSocket endpoint.',
+      },
+    },
+    channels: {
+      [CHANNEL_ID]: {
+        address: wsPath,
+        servers: [{ $ref: '#/servers/local' }],
+        messages: channelMessages,
+      },
+    },
+    operations: {
+      receiveClientMessages: {
+        action: 'receive',
+        channel: { $ref: `#/channels/${CHANNEL_ID}` },
+        messages: operationMessageRefs('client_to_server'),
+      },
+      sendServerMessages: {
+        action: 'send',
+        channel: { $ref: `#/channels/${CHANNEL_ID}` },
+        messages: [
+          ...operationMessageRefs('server_to_client'),
+          ...ackMessageRefs(),
+        ],
+      },
+    },
+    components: {
+      messages,
+    },
+  };
+}
+
+function buildMessages(): Record<string, unknown> {
+  const messages: Record<string, unknown> = {};
+  for (const operation of ASYNCAPI_OPERATIONS) {
+    const id = messageId(operation.type);
+    messages[id] = asyncApiMessage(operation.type, operation.description, operation.messageSchema);
+    if (operation.ackSchema !== undefined) {
+      const ackId = `${id}_ack`;
+      messages[ackId] = asyncApiMessage(
+        `${operation.type}.ack`,
+        `Acknowledgement for ${operation.type}.`,
+        operation.ackSchema,
+      );
+    }
+  }
+  return messages;
+}
+
+function operationMessageRefs(
+  direction: WsOperationDefinition['direction'],
+): Array<{ $ref: string }> {
+  return ASYNCAPI_OPERATIONS
+    .filter((operation) => operation.direction === direction)
+    .map((operation) => ({ $ref: `#/components/messages/${messageId(operation.type)}` }));
+}
+
+function ackMessageRefs(): Array<{ $ref: string }> {
+  return ASYNCAPI_OPERATIONS
+    .filter((operation) => operation.ackSchema !== undefined)
+    .map((operation) => ({ $ref: `#/components/messages/${messageId(operation.type)}_ack` }));
+}
+
+function asyncApiMessage(
+  name: string,
+  summary: string,
+  schema: z.ZodTypeAny,
+): Record<string, unknown> {
+  return {
+    name,
+    title: titleFromName(name),
+    summary,
+    contentType: 'application/json',
+    payload: jsonSchema(schema),
+  };
+}
+
+function jsonSchema(schema: z.ZodTypeAny): Record<string, unknown> {
+  const converted = z.toJSONSchema(schema, {
+    target: 'draft-7',
+    io: 'input',
+    unrepresentable: 'any',
+  }) as Record<string, unknown>;
+  delete converted['$schema'];
+  return converted;
+}
+
+function messageId(type: string): string {
+  return type.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+}
+
+function titleFromName(name: string): string {
+  return name
+    .split(/[^A-Za-z0-9]+/)
+    .filter((part) => part.length > 0)
+    .map((part) => `${part[0]!.toUpperCase()}${part.slice(1)}`)
+    .join(' ');
+}
diff --git a/packages/kap-server/src/protocol/display.ts b/packages/kap-server/src/protocol/display.ts
new file mode 100644
index 000000000..cdf910ae8
--- /dev/null
+++ b/packages/kap-server/src/protocol/display.ts
@@ -0,0 +1,162 @@
+import { z } from 'zod';
+
+export const ToolInputDisplaySchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('command'),
+    command: z.string(),
+    cwd: z.string().optional(),
+    description: z.string().optional(),
+    language: z.literal('bash').optional(),
+  }),
+  z.object({
+    kind: z.literal('file_io'),
+    operation: z.enum(['read', 'write', 'edit', 'glob', 'grep']),
+    path: z.string(),
+    detail: z.string().optional(),
+    content: z.string().optional(),
+    before: z.string().optional(),
+    after: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('diff'),
+    path: z.string(),
+    before: z.string(),
+    after: z.string(),
+    hunks: z.number().optional(),
+  }),
+  z.object({
+    kind: z.literal('search'),
+    query: z.string(),
+    scope: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('url_fetch'),
+    url: z.string(),
+    method: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('agent_call'),
+    agent_name: z.string(),
+    prompt: z.string(),
+    background: z.boolean().optional(),
+  }),
+  z.object({
+    kind: z.literal('skill_call'),
+    skill_name: z.string(),
+    args: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('todo_list'),
+    items: z.array(z.object({ title: z.string(), status: z.string() })),
+  }),
+  z.object({
+    kind: z.literal('task'),
+    task_id: z.string(),
+    status: z.string(),
+    description: z.string(),
+    task_kind: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('task_stop'),
+    task_id: z.string(),
+    task_description: z.string(),
+  }),
+  z.object({
+    kind: z.literal('plan_review'),
+    plan: z.string(),
+    path: z.string().optional(),
+    options: z
+      .array(
+        z.object({
+          label: z.string(),
+          description: z.string(),
+        }),
+      )
+      .readonly()
+      .optional(),
+  }),
+  z.object({
+    kind: z.literal('goal_start'),
+    objective: z.string(),
+    completionCriterion: z.string().optional(),
+    // Current permission mode at approval time. The client uses it to pick the
+    // start menu (manual vs yolo); `auto` never reaches this display because it
+    // auto-approves the goal without a prompt.
+    mode: z.enum(['manual', 'yolo']),
+  }),
+  z.object({
+    kind: z.literal('generic'),
+    summary: z.string(),
+    detail: z.unknown().optional(),
+  }),
+]);
+
+export const ToolResultDisplaySchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('command_output'),
+    exit_code: z.number(),
+    stdout: z.string().optional(),
+    stderr: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('file_content'),
+    path: z.string(),
+    content: z.string(),
+    range: z.object({ start: z.number(), end: z.number() }).optional(),
+    truncated: z.boolean().optional(),
+  }),
+  z.object({
+    kind: z.literal('diff'),
+    path: z.string(),
+    before: z.string(),
+    after: z.string(),
+    hunks: z.number().optional(),
+  }),
+  z.object({
+    kind: z.literal('search_results'),
+    query: z.string(),
+    matches: z.array(z.object({ file: z.string(), line: z.number(), text: z.string() })),
+  }),
+  z.object({
+    kind: z.literal('url_content'),
+    url: z.string(),
+    status: z.number(),
+    preview: z.string().optional(),
+    content_type: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('agent_summary'),
+    agent_name: z.string(),
+    result: z.string().optional(),
+    steps: z.number().optional(),
+  }),
+  z.object({
+    kind: z.literal('task'),
+    task_id: z.string(),
+    status: z.string(),
+    description: z.string(),
+  }),
+  z.object({
+    kind: z.literal('todo_list'),
+    items: z.array(z.object({ title: z.string(), status: z.string() })),
+  }),
+  z.object({ kind: z.literal('structured'), data: z.unknown() }),
+  z.object({
+    kind: z.literal('text'),
+    text: z.string(),
+    truncated: z.boolean().optional(),
+  }),
+  z.object({
+    kind: z.literal('error'),
+    message: z.string(),
+    code: z.string().optional(),
+  }),
+  z.object({
+    kind: z.literal('generic'),
+    summary: z.string(),
+    detail: z.unknown().optional(),
+  }),
+]);
+
+export type ToolInputDisplay = z.infer<typeof ToolInputDisplaySchema>;
+export type ToolResultDisplay = z.infer<typeof ToolResultDisplaySchema>;
diff --git a/packages/kap-server/src/protocol/envelope.ts b/packages/kap-server/src/protocol/envelope.ts
new file mode 100644
index 000000000..620a4ae62
--- /dev/null
+++ b/packages/kap-server/src/protocol/envelope.ts
@@ -0,0 +1,46 @@
+/**
+ * The wire envelope `{ code, msg, data, request_id }` every REST response is
+ * wrapped in, plus the envelope JSON-schema factory used for OpenAPI
+ * generation. Owned by the server: it is a pure transport concern.
+ */
+
+import { z } from 'zod';
+
+export const envelopeSchema = <T extends z.ZodTypeAny>(data: T) =>
+  z.object({
+    code: z.number().int(),
+    msg: z.string(),
+    data: data.nullable(),
+    request_id: z.string(),
+    details: z.unknown().optional(),
+    stack: z.string().optional(),
+  });
+
+export interface Envelope<T> {
+  code: number;
+  msg: string;
+  data: T | null;
+  request_id: string;
+  details?: unknown;
+  stack?: string;
+}
+
+export function okEnvelope<T>(data: T, requestId: string): Envelope<T> {
+  return { code: 0, msg: 'success', data, request_id: requestId };
+}
+
+/**
+ * Build an error envelope. When `stack` is provided it is surfaced verbatim on
+ * the wire so operators can see where a thrown error originated; when omitted
+ * (or `undefined`) the field is absent and the wire shape stays byte-identical
+ * to the original `{ code, msg, data: null, request_id }` — `JSON.stringify`
+ * drops `undefined` properties, so callers that have no stack are unaffected.
+ */
+export function errEnvelope(
+  code: number,
+  msg: string,
+  requestId: string,
+  stack?: string,
+): Envelope<null> {
+  return { code, msg, data: null, request_id: requestId, stack };
+}
diff --git a/packages/kap-server/src/protocol/error-codes.ts b/packages/kap-server/src/protocol/error-codes.ts
new file mode 100644
index 000000000..775f89592
--- /dev/null
+++ b/packages/kap-server/src/protocol/error-codes.ts
@@ -0,0 +1,155 @@
+/**
+ * The numeric wire error-code table carried in envelope `code` fields.
+ *
+ * Integer namespaces:
+ *   - 0          success
+ *   - 4xxxx      client errors (HTTP-4xx analog)
+ *   - 5xxxx      server internal errors
+ *   - 6xxxx      tool runtime
+ *   - 7xxxx      LLM provider passthrough (msg = original upstream text)
+ *   - 8xxxx      MCP server passthrough (msg = original upstream text)
+ *   - 9xxxx      reserved
+ *
+ * Domain `KimiError` string codes are mapped onto these numbers at the
+ * transport boundary (`transport/errors.ts`, route-level `sendMappedError`).
+ */
+
+export const ErrorCode = {
+  /** 成功 */
+  SUCCESS: 0,
+
+  /** Zod 校验失败，`details` 含字段路径列表 */
+  VALIDATION_FAILED: 40001,
+  /** JSON 解析失败、字段类型错 */
+  REQUEST_MALFORMED: 40002,
+
+  /** daemon 没有任何 provider 配置 */
+  AUTH_PROVISIONING_REQUIRED: 40110,
+  /** provider 存在但 token / api_key 缺失 */
+  AUTH_TOKEN_MISSING: 40111,
+  /** 刷新 token 收到 401（用户撤销了授权） */
+  AUTH_TOKEN_UNAUTHORIZED: 40112,
+  /** 默认 / 请求的 model 解析不到 provider */
+  AUTH_MODEL_NOT_RESOLVED: 40113,
+
+  /** session_id 不存在 */
+  SESSION_NOT_FOUND: 40401,
+  /** prompt_id 不存在 */
+  PROMPT_NOT_FOUND: 40402,
+  /** message_id 不存在 */
+  MESSAGE_NOT_FOUND: 40403,
+  /** approval_id 不存在 */
+  APPROVAL_NOT_FOUND: 40404,
+  /** question_id 不存在 */
+  QUESTION_NOT_FOUND: 40405,
+  /** task_id 不存在 */
+  TASK_NOT_FOUND: 40406,
+  /** file_id 不存在 */
+  FILE_NOT_FOUND: 40407,
+  /** mcp_server_id 不存在 */
+  MCP_SERVER_NOT_FOUND: 40408,
+  /** fs path 不存在 */
+  FS_PATH_NOT_FOUND: 40409,
+  /** workspace_id 不存在 */
+  WORKSPACE_NOT_FOUND: 40410,
+  /** fs 路径存在但当前进程无权限读取 */
+  FS_PERMISSION_DENIED: 40411,
+  /** provider_id 不存在 */
+  PROVIDER_NOT_FOUND: 40412,
+  /** model_id 不存在 */
+  MODEL_NOT_FOUND: 40413,
+  /** terminal_id 不存在 */
+  TERMINAL_NOT_FOUND: 40414,
+  /** skill_name 不存在 */
+  SKILL_NOT_FOUND: 40415,
+
+  /** session 有正在进行的 prompt，拒绝新请求 */
+  SESSION_BUSY: 40901,
+  /** approval 已被其他 client 应答 */
+  APPROVAL_ALREADY_RESOLVED: 40902,
+  /** prompt 已结束（abort 幂等返回 0） */
+  PROMPT_ALREADY_COMPLETED: 40903,
+  /** task 已完结，无法取消 */
+  TASK_ALREADY_FINISHED: 40904,
+  /** mcp restart 时若已在 connecting/connected */
+  MCP_ALREADY_CONNECTED: 40905,
+  /** fs.read 请求 file，但 path 是目录 */
+  FS_IS_DIRECTORY: 40906,
+  /** fs.read 请求 utf-8，但 path 是二进制；client 改走 `:download` */
+  FS_IS_BINARY: 40907,
+  /** fs.git_status 但 session.cwd 不是 git repo */
+  FS_GIT_UNAVAILABLE: 40908,
+  /** 用户 ESC / 关闭面板放弃整组（client 调 `:dismiss`） */
+  QUESTION_DISMISSED: 40909,
+  /** 当前历史没有可 compact 的前缀 */
+  COMPACTION_UNABLE: 40910,
+  /** 当前历史没有足够的用户提示词可撤回 */
+  SESSION_UNDO_UNAVAILABLE: 40911,
+  /** skill 存在但类型不支持用户激活（如 reference 类型） */
+  SKILL_NOT_ACTIVATABLE: 40912,
+
+  /** 当前会话已存在活跃 goal */
+  GOAL_ALREADY_EXISTS: 40913,
+  /** 目标不存在 */
+  GOAL_NOT_FOUND: 40914,
+  /** goal 状态不允许该操作 */
+  GOAL_STATUS_INVALID: 40915,
+  /** goal 当前状态不可恢复 */
+  GOAL_NOT_RESUMABLE: 40916,
+  /** goal objective 为空 */
+  GOAL_OBJECTIVE_EMPTY: 40917,
+  /** goal objective 超过长度限制 */
+  GOAL_OBJECTIVE_TOO_LONG: 40918,
+  /** fs.mkdir 目标路径已存在（文件或目录） */
+  FS_ALREADY_EXISTS: 40919,
+  /** goal 只允许主 agent 使用 */
+  GOAL_UNSUPPORTED_AGENT: 40920,
+
+  /** approval 60s 超时 */
+  APPROVAL_EXPIRED: 41001,
+  /** question 60s 超时 */
+  QUESTION_EXPIRED: 41002,
+  /** 临时文件已过期 */
+  FILE_EXPIRED: 41003,
+
+  /** 上传超 50MB */
+  FILE_TOO_LARGE: 41301,
+  /** fs.read 超 10MB */
+  FS_TOO_LARGE: 41302,
+  /** fs.list / fs.search / fs.grep 命中超上限 */
+  FS_TOO_MANY_RESULTS: 41303,
+  /** path 越出 session cwd 边界 */
+  FS_PATH_ESCAPES_SESSION: 41304,
+  /** fs.grep 执行 >30s */
+  FS_GREP_TIMEOUT: 41305,
+
+  /** WS 单连接 watch_paths > 100 */
+  FS_WATCH_LIMIT_EXCEEDED: 42902,
+
+  /** 兜底 */
+  INTERNAL_ERROR: 50001,
+  /** 写入 session 持久化失败 */
+  PERSISTENCE_FAILURE: 50003,
+
+  /** tool 执行抛错 */
+  TOOL_EXECUTION_FAILED: 60001,
+  /** tool 在此 session 未启用 */
+  TOOL_NOT_AVAILABLE: 60002,
+
+  /** provider.* — provider 原 code 含义保留；`msg` 字段透传上游错误文本。 */
+  /** mcp.* — mcp server 原 code 含义保留；`msg` 字段透传上游错误文本。 */
+} as const;
+
+/**
+ * Reserved (intentionally unallocated; do NOT reuse for new variants):
+ *   - 40101 auth.invalid_token        (daemon's own token; future)
+ *   - 40102 auth.missing_token        (daemon's own token; future)
+ *   - 40103 auth.forbidden_origin     (daemon's own token; future)
+ *   - 42901 rate.limited
+ *   - 50002 protocol.version_mismatch
+ *
+ * (`ErrorCodeReason` 不随本表迁移：server 侧没有消费方；数字码到字符串
+ * reason 的映射仍由 protocol 包为 v1 链路和 server-e2e 持有。)
+ */
+
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
diff --git a/packages/kap-server/src/protocol/events-zod.ts b/packages/kap-server/src/protocol/events-zod.ts
new file mode 100644
index 000000000..9b66bd1c2
--- /dev/null
+++ b/packages/kap-server/src/protocol/events-zod.ts
@@ -0,0 +1,948 @@
+/**
+ * Zod schema half of the v1 event catalog (`packages/protocol/src/events.ts`),
+ * ported verbatim for byte-level AsyncAPI/JSON-Schema compatibility. Interface
+ * declarations and the deprecated volatile-event helpers are intentionally not
+ * ported; `satisfies z.ZodType<T>` clauses are kept only where `T` is
+ * importable from an agent-core-v2 leaf path and dropped elsewhere (dropped
+ * clauses do not affect the emitted JSON Schema).
+ */
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+import type { TurnEndReason } from '@moonshot-ai/agent-core-v2/agent/loop/turnEvents';
+import type {
+  CompactionSummaryOrigin,
+  CronJobOrigin,
+  CronMissedOrigin,
+  HookResultOrigin,
+  InjectionOrigin,
+  PluginCommandOrigin,
+  RetryOrigin,
+  ShellCommandOrigin,
+  SkillActivationOrigin,
+  SkillSource,
+  SystemTriggerOrigin,
+  TaskOrigin,
+  UserPromptOrigin,
+} from '@moonshot-ai/agent-core-v2/agent/contextMemory/types';
+import { messageContentSchema } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+import type { HookResultEvent } from '@moonshot-ai/agent-core-v2/agent/externalHooks/externalHooksService';
+import type {
+  CompactionBlockedEvent,
+  CompactionCancelledEvent,
+  CompactionCompletedEvent,
+  CompactionStartedEvent,
+} from '@moonshot-ai/agent-core-v2/agent/fullCompaction/compactionOps';
+import type { CompactionResult } from '@moonshot-ai/agent-core-v2/agent/fullCompaction/types';
+import type {
+  GoalActor,
+  GoalBudgetLimits,
+  GoalBudgetReport,
+  GoalChange,
+  GoalChangeKind,
+  GoalChangeStats,
+  GoalSnapshot,
+  GoalStatus,
+  GoalToolResult,
+} from '@moonshot-ai/agent-core-v2/agent/goal/types';
+import type {
+  AssistantDeltaEvent,
+  ThinkingDeltaEvent,
+  ToolCallDeltaEvent,
+  TurnStepCompletedEvent,
+  TurnStepInterruptedEvent,
+  TurnStepStartedEvent,
+} from '@moonshot-ai/agent-core-v2/agent/loop/turnEvents';
+import type {
+  McpServerStatusEvent,
+  McpServerStatusPayload,
+  ToolListUpdatedEvent,
+  ToolListUpdatedReason,
+} from '@moonshot-ai/agent-core-v2/agent/mcp/mcpService';
+import type { McpOAuthAuthorizationUrlUpdateData } from '@moonshot-ai/agent-core-v2/agent/mcp/tools/auth';
+import type { PermissionMode } from '@moonshot-ai/agent-core-v2/agent/permissionPolicy/types';
+import type { WarningEvent } from '@moonshot-ai/agent-core-v2/agent/profile/profileService';
+import type { PluginCommandActivatedEvent } from '@moonshot-ai/agent-core-v2/agent/rpc/rpcService';
+import type {
+  ShellOutputEvent,
+  ShellStartedEvent,
+} from '@moonshot-ai/agent-core-v2/agent/shellCommand/shellCommandService';
+import type { TurnStepRetryingEvent } from '@moonshot-ai/agent-core-v2/agent/stepRetry/stepRetryService';
+import type { AgentTaskStatus } from '@moonshot-ai/agent-core-v2/agent/task/types';
+import type {
+  ToolCallStartedEvent,
+  ToolProgressEvent,
+  ToolResultEvent,
+} from '@moonshot-ai/agent-core-v2/agent/toolExecutor/toolExecutorEvents';
+import type { UsageStatus } from '@moonshot-ai/agent-core-v2/agent/usage/usage';
+import type { FinishReason } from '@moonshot-ai/agent-core-v2/app/llmProtocol/finishReason';
+import type { TokenUsage } from '@moonshot-ai/agent-core-v2/app/llmProtocol/usage';
+import type {
+  SubagentCompletedEvent,
+  SubagentFailedEvent,
+  SubagentSpawnedEvent,
+  SubagentStartedEvent,
+} from '@moonshot-ai/agent-core-v2/session/subagent/mirrorAgentRun';
+import type { SubagentSuspendedEvent } from '@moonshot-ai/agent-core-v2/session/swarm/sessionSwarmService';
+import type { ToolUpdate } from '@moonshot-ai/agent-core-v2/tool/toolContract';
+
+import { ToolInputDisplaySchema } from './display';
+import { configResponseSchema } from './rest-config';
+import { sessionPendingInteractionSchema, sessionSchema } from './session';
+import { workspaceSchema } from './workspace';
+
+export const tokenUsageSchema = z.object({
+  inputOther: z.number(),
+  output: z.number(),
+  inputCacheRead: z.number(),
+  inputCacheCreation: z.number(),
+}) satisfies z.ZodType<TokenUsage>;
+
+export const finishReasonSchema = z.enum([
+  'completed',
+  'tool_calls',
+  'truncated',
+  'filtered',
+  'paused',
+  'other',
+]) satisfies z.ZodType<FinishReason>;
+
+export const usageStatusSchema = z.object({
+  byModel: z.record(z.string(), tokenUsageSchema).optional(),
+  currentTurn: tokenUsageSchema.optional(),
+  total: tokenUsageSchema.optional(),
+}) satisfies z.ZodType<UsageStatus>;
+
+export const permissionModeSchema = z.enum(['manual', 'yolo', 'auto']) satisfies z.ZodType<PermissionMode>;
+
+export const skillSourceSchema = z.enum(['project', 'user', 'extra', 'builtin']) satisfies z.ZodType<SkillSource>;
+
+export const userPromptOriginSchema = z.object({
+  kind: z.literal('user'),
+}) satisfies z.ZodType<UserPromptOrigin>;
+
+export const skillActivationOriginSchema = z.object({
+  kind: z.literal('skill_activation'),
+  activationId: z.string(),
+  skillName: z.string(),
+  skillArgs: z.string().optional(),
+  trigger: z.enum(['user-slash', 'model-tool', 'nested-skill']),
+  skillType: z.string().optional(),
+  skillPath: z.string().optional(),
+  skillSource: skillSourceSchema.optional(),
+}) satisfies z.ZodType<SkillActivationOrigin>;
+
+export const pluginCommandOriginSchema = z.object({
+  kind: z.literal('plugin_command'),
+  activationId: z.string(),
+  pluginId: z.string(),
+  commandName: z.string(),
+  commandArgs: z.string().optional(),
+  trigger: z.literal('user-slash'),
+}) satisfies z.ZodType<PluginCommandOrigin>;
+
+export const injectionOriginSchema = z.object({
+  kind: z.literal('injection'),
+  variant: z.string(),
+}) satisfies z.ZodType<InjectionOrigin>;
+
+export const shellCommandOriginSchema = z.object({
+  kind: z.literal('shell_command'),
+  phase: z.enum(['input', 'output']),
+  isError: z.boolean().optional(),
+}) satisfies z.ZodType<ShellCommandOrigin>;
+
+export const compactionSummaryOriginSchema = z.object({
+  kind: z.literal('compaction_summary'),
+}) satisfies z.ZodType<CompactionSummaryOrigin>;
+
+export const systemTriggerOriginSchema = z.object({
+  kind: z.literal('system_trigger'),
+  name: z.string(),
+}) satisfies z.ZodType<SystemTriggerOrigin>;
+
+export const taskLifecycleStatusSchema = z.enum([
+  'running',
+  'completed',
+  'failed',
+  'timed_out',
+  'killed',
+  'lost',
+]) satisfies z.ZodType<AgentTaskStatus>;
+
+export const taskOriginSchema = z.object({
+  kind: z.literal('task'),
+  taskId: z.string(),
+  status: taskLifecycleStatusSchema,
+  notificationId: z.string(),
+}) satisfies z.ZodType<TaskOrigin>;
+
+export const backgroundTaskOriginSchema = z.object({
+  kind: z.literal('background_task'),
+  taskId: z.string(),
+  status: taskLifecycleStatusSchema,
+  notificationId: z.string(),
+});
+
+export const cronJobOriginSchema = z.object({
+  kind: z.literal('cron_job'),
+  jobId: z.string(),
+  cron: z.string(),
+  recurring: z.boolean(),
+  coalescedCount: z.number(),
+  stale: z.boolean(),
+}) satisfies z.ZodType<CronJobOrigin>;
+
+export const cronMissedOriginSchema = z.object({
+  kind: z.literal('cron_missed'),
+  count: z.number(),
+}) satisfies z.ZodType<CronMissedOrigin>;
+
+export const hookResultOriginSchema = z.object({
+  kind: z.literal('hook_result'),
+  event: z.string(),
+  blocked: z.boolean().optional(),
+}) satisfies z.ZodType<HookResultOrigin>;
+
+export const retryOriginSchema = z.object({
+  kind: z.literal('retry'),
+  trigger: z.string().optional(),
+}) satisfies z.ZodType<RetryOrigin>;
+
+export const promptOriginSchema = z.discriminatedUnion('kind', [
+  userPromptOriginSchema,
+  skillActivationOriginSchema,
+  pluginCommandOriginSchema,
+  injectionOriginSchema,
+  shellCommandOriginSchema,
+  compactionSummaryOriginSchema,
+  systemTriggerOriginSchema,
+  taskOriginSchema,
+  backgroundTaskOriginSchema,
+  cronJobOriginSchema,
+  cronMissedOriginSchema,
+  hookResultOriginSchema,
+  retryOriginSchema,
+]);
+
+export const goalStatusSchema = z.enum(['active', 'paused', 'blocked', 'complete']) satisfies z.ZodType<GoalStatus>;
+
+export const goalActorSchema = z.enum(['user', 'model', 'runtime', 'system']) satisfies z.ZodType<GoalActor>;
+
+export const goalBudgetLimitsSchema = z.object({
+  tokenBudget: z.number().optional(),
+  turnBudget: z.number().optional(),
+  wallClockBudgetMs: z.number().optional(),
+}) satisfies z.ZodType<GoalBudgetLimits>;
+
+export const goalBudgetReportSchema = z.object({
+  tokenBudget: z.number().nullable(),
+  turnBudget: z.number().nullable(),
+  wallClockBudgetMs: z.number().nullable(),
+  remainingTokens: z.number().nullable(),
+  remainingTurns: z.number().nullable(),
+  remainingWallClockMs: z.number().nullable(),
+  tokenBudgetReached: z.boolean(),
+  turnBudgetReached: z.boolean(),
+  wallClockBudgetReached: z.boolean(),
+  overBudget: z.boolean(),
+}) satisfies z.ZodType<GoalBudgetReport>;
+
+export const goalSnapshotSchema = z.object({
+  goalId: z.string(),
+  objective: z.string(),
+  completionCriterion: z.string().optional(),
+  status: goalStatusSchema,
+  turnsUsed: z.number(),
+  tokensUsed: z.number(),
+  wallClockMs: z.number(),
+  budget: goalBudgetReportSchema,
+  terminalReason: z.string().optional(),
+}) satisfies z.ZodType<GoalSnapshot>;
+
+export const goalToolResultSchema = z.object({
+  goal: goalSnapshotSchema.nullable(),
+}) satisfies z.ZodType<GoalToolResult>;
+
+export const goalChangeStatsSchema = z.object({
+  turnsUsed: z.number(),
+  tokensUsed: z.number(),
+  wallClockMs: z.number(),
+}) satisfies z.ZodType<GoalChangeStats>;
+
+export const goalChangeKindSchema = z.enum(['lifecycle', 'completion']) satisfies z.ZodType<GoalChangeKind>;
+
+export const goalChangeSchema = z.object({
+  kind: goalChangeKindSchema,
+  status: goalStatusSchema.optional(),
+  reason: z.string().optional(),
+  stats: goalChangeStatsSchema.optional(),
+  actor: goalActorSchema.optional(),
+}) satisfies z.ZodType<GoalChange>;
+
+export const kimiErrorCodeSchema = z.enum([
+  'config.invalid',
+  'session.not_found',
+  'session.already_exists',
+  'session.id_invalid',
+  'session.id_required',
+  'session.id_empty',
+  'session.title_empty',
+  'session.state_not_found',
+  'session.state_invalid',
+  'session.fork_active_turn',
+  'session.undo_unavailable',
+  'session.export_not_found',
+  'session.export_missing_version',
+  'session.export_output_conflict',
+  'session.export_too_large',
+  'session.closed',
+  'session.permission_mode_invalid',
+  'session.thinking_empty',
+  'session.model_empty',
+  'session.plan_mode_invalid',
+  'session.approval_handler_error',
+  'session.question_handler_error',
+  'session.init_failed',
+  'agent.not_found',
+  'activity.agent_busy',
+  'activity.cancelling',
+  'activity.disposing',
+  'activity.disposed',
+  'activity.initializing',
+  'activity.session_rejected',
+  'turn.agent_busy',
+  'goal.already_exists',
+  'goal.not_found',
+  'goal.objective_empty',
+  'goal.objective_too_long',
+  'goal.status_invalid',
+  'goal.metadata_reserved',
+  'goal.not_resumable',
+  'goal.unsupported_agent',
+  'model.not_configured',
+  'model.config_invalid',
+  'profile.thinking_alias_conflict',
+  'model.not_found',
+  'auth.login_required',
+  'auth.provisioning_required',
+  'auth.token_missing',
+  'auth.token_unauthorized',
+  'auth.model_not_resolved',
+  'context.overflow',
+  'loop.max_steps_exceeded',
+  'provider.api_error',
+  'provider.filtered',
+  'provider.rate_limit',
+  'provider.auth_error',
+  'provider.connection_error',
+  'provider.overloaded',
+  'provider.not_found',
+  'skill.not_found',
+  'skill.type_unsupported',
+  'skill.name_empty',
+  'records.write_failed',
+  'compaction.failed',
+  'compaction.unable',
+  'task.task_id_empty',
+  'usage.turn_id_conflict',
+  'mcp.server_not_found',
+  'mcp.server_disabled',
+  'mcp.startup_failed',
+  'mcp.tool_name_collision',
+  'message.not_found',
+  'plugin.not_found',
+  'plugin.load_failed',
+  'request.invalid',
+  'request.work_dir_required',
+  'request.prompt_input_empty',
+  'prompt.not_found',
+  'prompt.already_completed',
+  'session.busy',
+  'shell.git_bash_not_found',
+  'workspace.not_found',
+  'terminal.not_found',
+  'file.not_found',
+  'file.too_large',
+  'fs.path_not_found',
+  'fs.permission_denied',
+  'fs.path_escapes',
+  'fs.is_directory',
+  'fs.is_binary',
+  'fs.too_large',
+  'fs.already_exists',
+  'fs.too_many_results',
+  'fs.grep_timeout',
+  'fs.git_unavailable',
+  'validation.failed',
+  'not_implemented',
+  'internal',
+]);
+
+export const kimiErrorPayloadSchema: z.ZodType<unknown> = z.lazy(
+  () => kimiErrorPayloadObjectSchema,
+);
+
+const kimiErrorPayloadObjectSchema = z.object({
+  code: kimiErrorCodeSchema,
+  message: z.string(),
+  name: z.string().optional(),
+  details: z.record(z.string(), z.unknown()).optional(),
+  retryable: z.boolean(),
+  cause: kimiErrorPayloadSchema.optional(),
+});
+
+export const taskInfoBaseSchema = z.object({
+  taskId: z.string(),
+  description: z.string(),
+  status: taskLifecycleStatusSchema,
+  detached: z.boolean().optional(),
+  startedAt: z.number(),
+  endedAt: z.number().nullable(),
+  stopReason: z.string().optional(),
+  terminalNotificationSuppressed: z.boolean().optional(),
+  timeoutMs: z.number().optional(),
+});
+
+export const processTaskInfoSchema = taskInfoBaseSchema.extend({
+  kind: z.literal('process'),
+  command: z.string(),
+  pid: z.number(),
+  exitCode: z.number().nullable(),
+});
+
+export const agentTaskInfoSchema = taskInfoBaseSchema.extend({
+  kind: z.literal('agent'),
+  agentId: z.string().optional(),
+  subagentType: z.string().optional(),
+});
+
+export const questionTaskInfoSchema = taskInfoBaseSchema.extend({
+  kind: z.literal('question'),
+  questionCount: z.number(),
+  toolCallId: z.string().optional(),
+});
+
+export const taskInfoSchema = z.discriminatedUnion('kind', [
+  processTaskInfoSchema,
+  agentTaskInfoSchema,
+  questionTaskInfoSchema,
+]);
+
+export const compactionResultSchema = z.object({
+  summary: z.string(),
+  compactedCount: z.number(),
+  tokensBefore: z.number(),
+  tokensAfter: z.number(),
+  keptUserMessageCount: z.number().optional(),
+  keptHeadUserMessageCount: z.number().optional(),
+  droppedCount: z.number().optional(),
+}) satisfies z.ZodType<CompactionResult>;
+
+export const toolUpdateSchema = z.object({
+  kind: z.enum(['stdout', 'stderr', 'progress', 'status', 'custom']),
+  text: z.string().optional(),
+  percent: z.number().optional(),
+  customKind: z.string().optional(),
+  customData: z.unknown().optional(),
+}) satisfies z.ZodType<ToolUpdate>;
+
+export const mcpOAuthAuthorizationUrlUpdateDataSchema = z.object({
+  serverName: z.string(),
+  authorizationUrl: z.string(),
+}) satisfies z.ZodType<McpOAuthAuthorizationUrlUpdateData>;
+
+export const turnEndReasonSchema = z.enum(['completed', 'cancelled', 'failed', 'blocked']) satisfies z.ZodType<TurnEndReason>;
+
+export const agentPhaseSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('idle') }),
+  z.object({
+    kind: z.literal('running'),
+    turnId: z.number(),
+    step: z.number(),
+    stepId: z.string(),
+    since: z.number(),
+  }),
+  z.object({
+    kind: z.literal('streaming'),
+    turnId: z.number(),
+    step: z.number(),
+    stepId: z.string(),
+    stream: z.enum(['assistant', 'thinking', 'tool_call']),
+    toolCallId: z.string().optional(),
+    toolName: z.string().optional(),
+    since: z.number(),
+  }),
+  z.object({
+    kind: z.literal('tool_call'),
+    turnId: z.number(),
+    step: z.number(),
+    toolCallId: z.string(),
+    name: z.string(),
+    since: z.number(),
+  }),
+  z.object({
+    kind: z.literal('retrying'),
+    turnId: z.number(),
+    step: z.number(),
+    stepId: z.string(),
+    failedAttempt: z.number(),
+    nextAttempt: z.number(),
+    maxAttempts: z.number(),
+    delayMs: z.number(),
+    errorName: z.string().optional(),
+    statusCode: z.number().optional(),
+    since: z.number(),
+  }),
+  z.object({
+    kind: z.literal('awaiting_approval'),
+    turnId: z.number(),
+    step: z.number().optional(),
+    approval: z.unknown().optional(),
+    since: z.number(),
+  }),
+  z.object({
+    kind: z.literal('interrupted'),
+    turnId: z.number(),
+    step: z.number().optional(),
+    reason: z.enum(['aborted', 'max_steps', 'error']),
+    message: z.string().optional(),
+    at: z.number(),
+  }),
+  z.object({
+    kind: z.literal('ended'),
+    turnId: z.number(),
+    reason: turnEndReasonSchema,
+    durationMs: z.number().optional(),
+    at: z.number(),
+  }),
+]);
+
+export const agentStatusUpdatedEventSchema = z.object({
+  type: z.literal('agent.status.updated'),
+  model: z.string().optional(),
+  thinkingEffort: z.string().optional(),
+  contextTokens: z.number().optional(),
+  maxContextTokens: z.number().optional(),
+  contextUsage: z.number().optional(),
+  planMode: z.boolean().optional(),
+  swarmMode: z.boolean().optional(),
+  permission: permissionModeSchema.optional(),
+  usage: usageStatusSchema.optional(),
+  phase: agentPhaseSchema.optional(),
+});
+
+export const sessionMetaUpdatedEventSchema = z.object({
+  type: z.literal('session.meta.updated'),
+  title: z.string().optional(),
+  patch: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const sessionCreatedEventSchema = z.object({
+  type: z.literal('event.session.created'),
+  session: sessionSchema,
+});
+
+export const workspaceCreatedEventSchema = z.object({
+  type: z.literal('event.workspace.created'),
+  workspace: workspaceSchema,
+});
+
+export const workspaceUpdatedEventSchema = z.object({
+  type: z.literal('event.workspace.updated'),
+  workspace: workspaceSchema,
+});
+
+export const workspaceDeletedEventSchema = z.object({
+  type: z.literal('event.workspace.deleted'),
+  workspace_id: z.string().min(1),
+  root: z.string().min(1),
+});
+
+export const sessionWorkChangedEventSchema = z.object({
+  type: z.literal('event.session.work_changed'),
+  busy: z.boolean(),
+  main_turn_active: z.boolean().optional(),
+  pending_interaction: sessionPendingInteractionSchema.optional(),
+  last_turn_reason: z.enum(['completed', 'cancelled', 'failed']).optional(),
+});
+
+const legacySessionStatusSchema = z.enum([
+  'idle',
+  'running',
+  'awaiting_approval',
+  'awaiting_question',
+  'aborted',
+]);
+
+export const sessionStatusChangedEventSchema = z.object({
+  type: z.literal('event.session.status_changed'),
+  status: legacySessionStatusSchema,
+  previous_status: legacySessionStatusSchema,
+  current_prompt_id: z.string().min(1).optional(),
+});
+
+export const configChangedEventSchema = z.object({
+  type: z.literal('event.config.changed'),
+  changedFields: z.array(z.string()),
+  config: configResponseSchema,
+});
+
+export const goalUpdatedEventSchema = z.object({
+  type: z.literal('goal.updated'),
+  snapshot: goalSnapshotSchema.nullable(),
+  change: goalChangeSchema.optional(),
+});
+
+export const skillActivatedEventSchema = z.object({
+  type: z.literal('skill.activated'),
+  activationId: z.string(),
+  skillName: z.string(),
+  skillArgs: z.string().optional(),
+  trigger: z.enum(['user-slash', 'model-tool', 'nested-skill']),
+  skillPath: z.string().optional(),
+  skillSource: skillSourceSchema.optional(),
+});
+
+export const pluginCommandActivatedEventSchema = z.object({
+  type: z.literal('plugin_command.activated'),
+  activationId: z.string(),
+  pluginId: z.string(),
+  commandName: z.string(),
+  commandArgs: z.string().optional(),
+  trigger: z.literal('user-slash'),
+}) satisfies z.ZodType<PluginCommandActivatedEvent>;
+
+export const errorEventSchema = kimiErrorPayloadObjectSchema.extend({
+  type: z.literal('error'),
+});
+
+export const warningEventSchema = z.object({
+  type: z.literal('warning'),
+  message: z.string(),
+  code: z.string().optional(),
+}) satisfies z.ZodType<WarningEvent>;
+
+export const turnStartedEventSchema = z.object({
+  type: z.literal('turn.started'),
+  turnId: z.number(),
+  origin: promptOriginSchema,
+});
+
+export const turnEndedEventSchema = z.object({
+  type: z.literal('turn.ended'),
+  turnId: z.number(),
+  reason: turnEndReasonSchema,
+  error: kimiErrorPayloadSchema.optional(),
+  durationMs: z.number().optional(),
+});
+
+export const turnStepStartedEventSchema = z.object({
+  type: z.literal('turn.step.started'),
+  turnId: z.number(),
+  step: z.number(),
+  stepId: z.string().optional(),
+}) satisfies z.ZodType<TurnStepStartedEvent>;
+
+export const turnStepCompletedEventSchema = z.object({
+  type: z.literal('turn.step.completed'),
+  turnId: z.number(),
+  step: z.number(),
+  stepId: z.string().optional(),
+  usage: tokenUsageSchema.optional(),
+  finishReason: z.string().optional(),
+  llmFirstTokenLatencyMs: z.number().optional(),
+  llmStreamDurationMs: z.number().optional(),
+  llmRequestBuildMs: z.number().optional(),
+  llmServerFirstTokenMs: z.number().optional(),
+  llmServerDecodeMs: z.number().optional(),
+  llmClientConsumeMs: z.number().optional(),
+  providerFinishReason: finishReasonSchema.optional(),
+  rawFinishReason: z.string().optional(),
+}) satisfies z.ZodType<TurnStepCompletedEvent>;
+
+export const turnStepRetryingEventSchema = z.object({
+  type: z.literal('turn.step.retrying'),
+  turnId: z.number(),
+  step: z.number(),
+  stepId: z.string().optional(),
+  failedAttempt: z.number(),
+  nextAttempt: z.number(),
+  maxAttempts: z.number(),
+  delayMs: z.number(),
+  errorName: z.string(),
+  errorMessage: z.string(),
+  statusCode: z.number().optional(),
+}) satisfies z.ZodType<TurnStepRetryingEvent>;
+
+export const turnStepInterruptedEventSchema = z.object({
+  type: z.literal('turn.step.interrupted'),
+  turnId: z.number(),
+  step: z.number(),
+  stepId: z.string().optional(),
+  reason: z.string(),
+  message: z.string().optional(),
+}) satisfies z.ZodType<TurnStepInterruptedEvent>;
+
+export const assistantDeltaEventSchema = z.object({
+  type: z.literal('assistant.delta'),
+  turnId: z.number(),
+  delta: z.string(),
+}) satisfies z.ZodType<AssistantDeltaEvent>;
+
+export const hookResultEventSchema = z.object({
+  type: z.literal('hook.result'),
+  turnId: z.number().optional(),
+  hookEvent: z.string(),
+  content: z.string(),
+  blocked: z.boolean().optional(),
+}) satisfies z.ZodType<HookResultEvent>;
+
+export const thinkingDeltaEventSchema = z.object({
+  type: z.literal('thinking.delta'),
+  turnId: z.number(),
+  delta: z.string(),
+}) satisfies z.ZodType<ThinkingDeltaEvent>;
+
+export const toolCallDeltaEventSchema = z.object({
+  type: z.literal('tool.call.delta'),
+  turnId: z.number(),
+  toolCallId: z.string(),
+  name: z.string().optional(),
+  argumentsPart: z.string().optional(),
+}) satisfies z.ZodType<ToolCallDeltaEvent>;
+
+export const toolCallStartedEventSchema = z.object({
+  type: z.literal('tool.call.started'),
+  turnId: z.number(),
+  toolCallId: z.string(),
+  name: z.string(),
+  args: z.unknown(),
+  description: z.string().optional(),
+  display: ToolInputDisplaySchema.optional(),
+}) satisfies z.ZodType<ToolCallStartedEvent>;
+
+export const toolProgressEventSchema = z.object({
+  type: z.literal('tool.progress'),
+  turnId: z.number(),
+  toolCallId: z.string(),
+  update: toolUpdateSchema,
+}) satisfies z.ZodType<ToolProgressEvent>;
+
+export const shellOutputEventSchema = z.object({
+  type: z.literal('shell.output'),
+  commandId: z.string(),
+  update: toolUpdateSchema,
+}) satisfies z.ZodType<ShellOutputEvent>;
+
+export const shellStartedEventSchema = z.object({
+  type: z.literal('shell.started'),
+  commandId: z.string(),
+  taskId: z.string(),
+}) satisfies z.ZodType<ShellStartedEvent>;
+
+export const toolResultEventSchema = z.object({
+  type: z.literal('tool.result'),
+  turnId: z.number(),
+  toolCallId: z.string(),
+  output: z.unknown(),
+  isError: z.boolean().optional(),
+  synthetic: z.boolean().optional(),
+}) satisfies z.ZodType<ToolResultEvent>;
+
+export const subagentSpawnedEventSchema = z.object({
+  type: z.literal('subagent.spawned'),
+  subagentId: z.string(),
+  subagentName: z.string(),
+  parentToolCallId: z.string(),
+  parentToolCallUuid: z.string().optional(),
+  parentAgentId: z.string().optional(),
+  callerAgentId: z.string().optional(),
+  description: z.string().optional(),
+  swarmIndex: z.number().optional(),
+  runInBackground: z.boolean(),
+}) satisfies z.ZodType<SubagentSpawnedEvent>;
+
+export const subagentStartedEventSchema = z.object({
+  type: z.literal('subagent.started'),
+  subagentId: z.string(),
+}) satisfies z.ZodType<SubagentStartedEvent>;
+
+export const subagentSuspendedEventSchema = z.object({
+  type: z.literal('subagent.suspended'),
+  subagentId: z.string(),
+  reason: z.string(),
+}) satisfies z.ZodType<SubagentSuspendedEvent>;
+
+export const subagentCompletedEventSchema = z.object({
+  type: z.literal('subagent.completed'),
+  subagentId: z.string(),
+  resultSummary: z.string(),
+  usage: tokenUsageSchema.optional(),
+  contextTokens: z.number().optional(),
+}) satisfies z.ZodType<SubagentCompletedEvent>;
+
+export const subagentFailedEventSchema = z.object({
+  type: z.literal('subagent.failed'),
+  subagentId: z.string(),
+  error: z.string(),
+}) satisfies z.ZodType<SubagentFailedEvent>;
+
+export const compactionStartedEventSchema = z.object({
+  type: z.literal('compaction.started'),
+  trigger: z.enum(['manual', 'auto']),
+  instruction: z.string().optional(),
+}) satisfies z.ZodType<CompactionStartedEvent>;
+
+export const compactionBlockedEventSchema = z.object({
+  type: z.literal('compaction.blocked'),
+  turnId: z.number().optional(),
+}) satisfies z.ZodType<CompactionBlockedEvent>;
+
+export const compactionCancelledEventSchema = z.object({
+  type: z.literal('compaction.cancelled'),
+}) satisfies z.ZodType<CompactionCancelledEvent>;
+
+export const compactionCompletedEventSchema = z.object({
+  type: z.literal('compaction.completed'),
+  result: compactionResultSchema,
+}) satisfies z.ZodType<CompactionCompletedEvent>;
+
+export const taskStartedEventSchema = z.object({
+  type: z.literal('task.started'),
+  info: taskInfoSchema,
+});
+
+export const taskTerminatedEventSchema = z.object({
+  type: z.literal('task.terminated'),
+  info: taskInfoSchema,
+});
+
+export const backgroundTaskStartedEventSchema = z.object({
+  type: z.literal('background.task.started'),
+  info: taskInfoSchema,
+});
+
+export const backgroundTaskTerminatedEventSchema = z.object({
+  type: z.literal('background.task.terminated'),
+  info: taskInfoSchema,
+});
+
+export const cronFiredEventSchema = z.object({
+  type: z.literal('cron.fired'),
+  origin: cronJobOriginSchema,
+  prompt: z.string(),
+});
+
+export const promptSubmittedEventSchema = z.object({
+  type: z.literal('prompt.submitted'),
+  promptId: z.string(),
+  userMessageId: z.string(),
+  status: z.enum(['running', 'queued', 'blocked']),
+  content: z.array(messageContentSchema),
+  createdAt: isoDateTimeSchema,
+});
+
+export const promptCompletedEventSchema = z.object({
+  type: z.literal('prompt.completed'),
+  promptId: z.string(),
+  finishedAt: isoDateTimeSchema,
+  reason: z.enum(['completed', 'failed', 'blocked']).optional(),
+});
+
+export const promptAbortedEventSchema = z.object({
+  type: z.literal('prompt.aborted'),
+  promptId: z.string(),
+  abortedAt: isoDateTimeSchema,
+});
+
+export const promptSteeredEventSchema = z.object({
+  type: z.literal('prompt.steered'),
+  activePromptId: z.string(),
+  promptIds: z.array(z.string()),
+  content: z.array(messageContentSchema),
+  steeredAt: isoDateTimeSchema,
+});
+
+export const toolListUpdatedReasonSchema = z.enum([
+  'mcp.connected',
+  'mcp.disconnected',
+  'mcp.failed',
+]) satisfies z.ZodType<ToolListUpdatedReason>;
+
+export const toolListUpdatedEventSchema = z.object({
+  type: z.literal('tool.list.updated'),
+  reason: toolListUpdatedReasonSchema,
+  serverName: z.string(),
+}) satisfies z.ZodType<ToolListUpdatedEvent>;
+
+export const mcpServerStatusPayloadSchema = z.object({
+  name: z.string(),
+  transport: z.enum(['stdio', 'http']),
+  status: z.enum(['pending', 'connected', 'failed', 'disabled', 'needs-auth']),
+  toolCount: z.number(),
+  error: z.string().optional(),
+}) satisfies z.ZodType<McpServerStatusPayload>;
+
+export const mcpServerStatusEventSchema = z.object({
+  type: z.literal('mcp.server.status'),
+  server: mcpServerStatusPayloadSchema,
+}) satisfies z.ZodType<McpServerStatusEvent>;
+
+export const agentEventSchema = z.discriminatedUnion('type', [
+  errorEventSchema,
+  warningEventSchema,
+  agentStatusUpdatedEventSchema,
+  sessionMetaUpdatedEventSchema,
+  sessionCreatedEventSchema,
+  workspaceCreatedEventSchema,
+  workspaceUpdatedEventSchema,
+  workspaceDeletedEventSchema,
+  sessionWorkChangedEventSchema,
+  sessionStatusChangedEventSchema,
+  goalUpdatedEventSchema,
+  skillActivatedEventSchema,
+  pluginCommandActivatedEventSchema,
+  turnStartedEventSchema,
+  turnEndedEventSchema,
+  turnStepStartedEventSchema,
+  turnStepCompletedEventSchema,
+  turnStepRetryingEventSchema,
+  turnStepInterruptedEventSchema,
+  assistantDeltaEventSchema,
+  hookResultEventSchema,
+  thinkingDeltaEventSchema,
+  toolCallDeltaEventSchema,
+  toolCallStartedEventSchema,
+  toolProgressEventSchema,
+  shellOutputEventSchema,
+  shellStartedEventSchema,
+  toolResultEventSchema,
+  toolListUpdatedEventSchema,
+  mcpServerStatusEventSchema,
+  subagentSpawnedEventSchema,
+  subagentStartedEventSchema,
+  subagentSuspendedEventSchema,
+  subagentCompletedEventSchema,
+  subagentFailedEventSchema,
+  compactionStartedEventSchema,
+  compactionBlockedEventSchema,
+  compactionCancelledEventSchema,
+  compactionCompletedEventSchema,
+  taskStartedEventSchema,
+  taskTerminatedEventSchema,
+  backgroundTaskStartedEventSchema,
+  backgroundTaskTerminatedEventSchema,
+  cronFiredEventSchema,
+  promptSubmittedEventSchema,
+  promptCompletedEventSchema,
+  promptAbortedEventSchema,
+  promptSteeredEventSchema,
+]);
+
+export const eventSchema = agentEventSchema.and(
+  z.object({
+    agentId: z.string(),
+    sessionId: z.string(),
+  }),
+);
diff --git a/packages/kap-server/src/protocol/goal.ts b/packages/kap-server/src/protocol/goal.ts
new file mode 100644
index 000000000..91f28d535
--- /dev/null
+++ b/packages/kap-server/src/protocol/goal.ts
@@ -0,0 +1,31 @@
+import { z } from 'zod';
+
+export const goalStatusSchema = z.enum(['active', 'paused', 'blocked', 'complete']);
+export type GoalStatus = z.infer<typeof goalStatusSchema>;
+
+export const goalBudgetReportSchema = z.object({
+  tokenBudget: z.number().nullable(),
+  turnBudget: z.number().nullable(),
+  wallClockBudgetMs: z.number().nullable(),
+  remainingTokens: z.number().nullable(),
+  remainingTurns: z.number().nullable(),
+  remainingWallClockMs: z.number().nullable(),
+  tokenBudgetReached: z.boolean(),
+  turnBudgetReached: z.boolean(),
+  wallClockBudgetReached: z.boolean(),
+  overBudget: z.boolean(),
+});
+export type GoalBudgetReport = z.infer<typeof goalBudgetReportSchema>;
+
+export const goalSnapshotSchema = z.object({
+  goalId: z.string(),
+  objective: z.string(),
+  completionCriterion: z.string().optional(),
+  status: goalStatusSchema,
+  turnsUsed: z.number(),
+  tokensUsed: z.number(),
+  wallClockMs: z.number(),
+  budget: goalBudgetReportSchema,
+  terminalReason: z.string().optional(),
+});
+export type GoalSnapshotWire = z.infer<typeof goalSnapshotSchema>;
diff --git a/packages/kap-server/src/protocol/pagination.ts b/packages/kap-server/src/protocol/pagination.ts
new file mode 100644
index 000000000..ccad723e2
--- /dev/null
+++ b/packages/kap-server/src/protocol/pagination.ts
@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+import { ErrorCode } from './error-codes';
+
+export const cursorQuerySchema = z
+  .object({
+    before_id: z.string().min(1).optional(),
+    after_id: z.string().min(1).optional(),
+    page_size: z.number().int().min(1).max(100).optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (value.before_id !== undefined && value.after_id !== undefined) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'before_id and after_id are mutually exclusive',
+        path: ['before_id'],
+        params: { code: ErrorCode.VALIDATION_FAILED },
+      });
+    }
+  });
+
+export type CursorQuery = z.infer<typeof cursorQuerySchema>;
+
+export const pageResponseSchema = <T extends z.ZodTypeAny>(item: T) =>
+  z.object({
+    items: z.array(item),
+    has_more: z.boolean(),
+  });
+
+export interface PageResponse<T> {
+  items: T[];
+  has_more: boolean;
+}
diff --git a/packages/kap-server/src/protocol/question.ts b/packages/kap-server/src/protocol/question.ts
new file mode 100644
index 000000000..d00baed04
--- /dev/null
+++ b/packages/kap-server/src/protocol/question.ts
@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+export const questionOptionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().optional(),
+});
+export type QuestionOption = z.infer<typeof questionOptionSchema>;
+
+export const questionItemSchema = z.object({
+  id: z.string().min(1),
+  question: z.string().min(1),
+  header: z.string().optional(),
+  body: z.string().optional(),
+  options: z.array(questionOptionSchema).min(2).max(4),
+  multi_select: z.boolean().optional(),
+  allow_other: z.boolean().optional(),
+  other_label: z.string().optional(),
+  other_description: z.string().optional(),
+});
+export type QuestionItem = z.infer<typeof questionItemSchema>;
+
+export const questionRequestSchema = z.object({
+  question_id: z.string().min(1),
+  session_id: z.string().min(1),
+  turn_id: z.number().int().nonnegative().optional(),
+  tool_call_id: z.string().min(1).optional(),
+  questions: z.array(questionItemSchema).min(1).max(4),
+  created_at: isoDateTimeSchema,
+});
+export type QuestionRequest = z.infer<typeof questionRequestSchema>;
+
+export const questionAnswerSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('single'), option_id: z.string().min(1) }),
+  z.object({ kind: z.literal('multi'), option_ids: z.array(z.string().min(1)).min(1) }),
+  z.object({ kind: z.literal('other'), text: z.string() }),
+  z.object({
+    kind: z.literal('multi_with_other'),
+    option_ids: z.array(z.string().min(1)),
+    other_text: z.string(),
+  }),
+  z.object({ kind: z.literal('skipped') }),
+]);
+export type QuestionAnswer = z.infer<typeof questionAnswerSchema>;
+
+export const questionAnswerMethodSchema = z.enum(['enter', 'space', 'number_key', 'click']);
+export type QuestionAnswerMethod = z.infer<typeof questionAnswerMethodSchema>;
+
+export const questionResponseSchema = z.object({
+  answers: z.record(z.string().min(1), questionAnswerSchema),
+  method: questionAnswerMethodSchema.optional(),
+  note: z.string().optional(),
+});
+export type QuestionResponse = z.infer<typeof questionResponseSchema>;
diff --git a/packages/kap-server/src/protocol/request-id.ts b/packages/kap-server/src/protocol/request-id.ts
new file mode 100644
index 000000000..2ed5c9df2
--- /dev/null
+++ b/packages/kap-server/src/protocol/request-id.ts
@@ -0,0 +1,14 @@
+import { isValid, ulid } from 'ulid';
+
+export const ulidRegex = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
+
+export function parseOrGenerateRequestId(headerValue: string | undefined): string {
+  if (typeof headerValue === 'string' && isValid(headerValue)) {
+    return headerValue;
+  }
+  return ulid();
+}
+
+export function isUlid(value: string): boolean {
+  return isValid(value);
+}
diff --git a/packages/kap-server/src/protocol/rest-approval.ts b/packages/kap-server/src/protocol/rest-approval.ts
new file mode 100644
index 000000000..a8b61c9a3
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-approval.ts
@@ -0,0 +1,34 @@
+/**
+ *   GET  /v1/sessions/{session_id}/approvals?status=pending
+ *   POST /v1/sessions/{session_id}/approvals/{approval_id}
+ */
+
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+import { approvalRequestSchema, approvalResponseSchema } from './approval';
+
+export const listPendingApprovalsQuerySchema = z.object({
+  status: z.literal('pending'),
+});
+export type ListPendingApprovalsQuery = z.infer<typeof listPendingApprovalsQuerySchema>;
+
+export const listPendingApprovalsResponseSchema = z.object({
+  items: z.array(approvalRequestSchema),
+});
+export type ListPendingApprovalsResponse = z.infer<typeof listPendingApprovalsResponseSchema>;
+
+export const approvalResolveRequestSchema = approvalResponseSchema;
+export type ApprovalResolveRequest = z.infer<typeof approvalResolveRequestSchema>;
+
+export const approvalResolveResultSchema = z.object({
+  resolved: z.literal(true),
+  resolved_at: isoDateTimeSchema,
+});
+export type ApprovalResolveResult = z.infer<typeof approvalResolveResultSchema>;
+
+export const approvalAlreadyResolvedDataSchema = z.object({
+  resolved: z.literal(false),
+});
+export type ApprovalAlreadyResolvedData = z.infer<typeof approvalAlreadyResolvedDataSchema>;
diff --git a/packages/kap-server/src/protocol/rest-config.ts b/packages/kap-server/src/protocol/rest-config.ts
new file mode 100644
index 000000000..5dcb7d45a
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-config.ts
@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+export const providerConfigResponseSchema = z.object({
+  type: z.string(),
+  base_url: z.string().optional(),
+  default_model: z.string().optional(),
+  has_api_key: z.boolean(),
+});
+export type ProviderConfigResponse = z.infer<typeof providerConfigResponseSchema>;
+
+export const configResponseSchema = z.object({
+  providers: z.record(z.string(), providerConfigResponseSchema).default({}),
+  default_provider: z.string().optional(),
+  default_model: z.string().optional(),
+  models: z.record(z.string(), z.unknown()).optional(),
+  thinking: z.unknown().optional(),
+  plan_mode: z.boolean().optional(),
+  yolo: z.boolean().optional(),
+  default_permission_mode: z.string().optional(),
+  default_plan_mode: z.boolean().optional(),
+  permission: z.unknown().optional(),
+  hooks: z.array(z.unknown()).optional(),
+  services: z.unknown().optional(),
+  merge_all_available_skills: z.boolean().optional(),
+  extra_skill_dirs: z.array(z.string()).optional(),
+  loop_control: z.unknown().optional(),
+  background: z.unknown().optional(),
+  experimental: z.record(z.string(), z.boolean()).optional(),
+  telemetry: z.boolean().optional(),
+  raw: z.record(z.string(), z.unknown()).optional(),
+});
+export type ConfigResponse = z.infer<typeof configResponseSchema>;
+
+export const patchConfigRequestSchema = z.object({
+  providers: z.record(z.string(), z.unknown()).optional(),
+  default_provider: z.string().optional(),
+  default_model: z.string().optional(),
+  models: z.record(z.string(), z.unknown()).optional(),
+  thinking: z.unknown().optional(),
+  plan_mode: z.boolean().optional(),
+  yolo: z.boolean().optional(),
+  default_permission_mode: z.string().optional(),
+  default_plan_mode: z.boolean().optional(),
+  permission: z.unknown().optional(),
+  hooks: z.array(z.unknown()).optional(),
+  services: z.unknown().optional(),
+  merge_all_available_skills: z.boolean().optional(),
+  extra_skill_dirs: z.array(z.string()).optional(),
+  loop_control: z.unknown().optional(),
+  background: z.unknown().optional(),
+  experimental: z.record(z.string(), z.boolean()).optional(),
+  telemetry: z.boolean().optional(),
+});
+export type PatchConfigRequest = z.infer<typeof patchConfigRequestSchema>;
diff --git a/packages/kap-server/src/protocol/rest-connection.ts b/packages/kap-server/src/protocol/rest-connection.ts
new file mode 100644
index 000000000..6fda7eb76
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-connection.ts
@@ -0,0 +1,34 @@
+/**
+ * GET /v1/connections
+ *   Reply: ConnectionsListResponse { connections: Connection[] }
+ *
+ * A `Connection` is a live WebSocket client attached to `/v1/ws`. It is the
+ * server's only stateful client concept — REST is stateless, and agent sessions
+ * are a separate resource (`/sessions`).
+ */
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+export const connectionSchema = z.object({
+  /** Server-assigned connection id (`conn_<ulid>`). */
+  id: z.string().min(1),
+  /** ISO 8601 UTC timestamp the socket was accepted at. */
+  connected_at: isoDateTimeSchema,
+  /** Peer address as seen by the server socket. Null when unavailable. */
+  remote_address: z.string().nullable(),
+  /** `User-Agent` header from the upgrade request. Null when absent. */
+  user_agent: z.string().nullable(),
+  /** Whether the client has completed the `client_hello` handshake. */
+  has_client_hello: z.boolean(),
+  /** Session ids this connection is currently subscribed to. */
+  subscriptions: z.array(z.string()),
+});
+
+export type Connection = z.infer<typeof connectionSchema>;
+
+export const connectionsListResponseSchema = z.object({
+  connections: z.array(connectionSchema),
+});
+
+export type ConnectionsListResponse = z.infer<typeof connectionsListResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-file.ts b/packages/kap-server/src/protocol/rest-file.ts
new file mode 100644
index 000000000..21d6a119c
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-file.ts
@@ -0,0 +1,27 @@
+/**
+ *   POST   /v1/files                  (multipart upload)
+ *   GET    /v1/files/{file_id}        (binary stream)
+ *   DELETE /v1/files/{file_id}
+ */
+
+import { z } from 'zod';
+
+import { fileMetaSchema } from '@moonshot-ai/agent-core-v2/app/file/fileService';
+
+export const uploadFileResponseSchema = fileMetaSchema;
+export type UploadFileResponse = z.infer<typeof uploadFileResponseSchema>;
+
+export const getFileParamSchema = z.object({
+  file_id: z.string().min(1),
+});
+export type GetFileParam = z.infer<typeof getFileParamSchema>;
+
+export const deleteFileParamSchema = z.object({
+  file_id: z.string().min(1),
+});
+export type DeleteFileParam = z.infer<typeof deleteFileParamSchema>;
+
+export const deleteFileResponseSchema = z.object({
+  deleted: z.literal(true),
+});
+export type DeleteFileResponse = z.infer<typeof deleteFileResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-fs.ts b/packages/kap-server/src/protocol/rest-fs.ts
new file mode 100644
index 000000000..113c4cbb3
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-fs.ts
@@ -0,0 +1,57 @@
+/**
+ * The `fs:open` / `fs:open_in` / `fs:reveal` request schemas — the only fs
+ * wire shapes the engine does not own (the `sessionFs` domain in agent-core-v2
+ * holds the rest). Also home of `fsOpenInAppIdSchema`, referenced by the
+ * `/v1/meta` capabilities document.
+ */
+
+import { z } from 'zod';
+
+export const fsOpenRequestSchema = z.object({
+  path: z.string().min(1),
+  line: z.number().int().positive().optional(),
+});
+export type FsOpenRequest = z.infer<typeof fsOpenRequestSchema>;
+
+export const fsOpenResponseSchema = z.object({
+  opened: z.literal(true),
+});
+export type FsOpenResponse = z.infer<typeof fsOpenResponseSchema>;
+
+export const fsRevealRequestSchema = z.object({
+  path: z.string().min(1),
+});
+export type FsRevealRequest = z.infer<typeof fsRevealRequestSchema>;
+
+export const fsRevealResponseSchema = z.object({
+  revealed: z.literal(true),
+});
+export type FsRevealResponse = z.infer<typeof fsRevealResponseSchema>;
+
+export const fsOpenInAppIdSchema = z.enum([
+  'finder',
+  'cursor',
+  'vscode',
+  'iterm',
+  'terminal',
+]);
+export type FsOpenInAppId = z.infer<typeof fsOpenInAppIdSchema>;
+
+export const fsOpenInRequestSchema = z.object({
+  app_id: fsOpenInAppIdSchema,
+  path: z.string().min(1),
+  line: z.number().int().positive().optional(),
+});
+export type FsOpenInRequest = z.infer<typeof fsOpenInRequestSchema>;
+
+export const fsOpenInResponseSchema = z.object({
+  opened: z.literal(true),
+});
+export type FsOpenInResponse = z.infer<typeof fsOpenInResponseSchema>;
+
+export const fsDownloadParamsSchema = z.object({
+  path: z.string().min(1),
+  range: z.string().optional(),
+  if_none_match: z.string().optional(),
+});
+export type FsDownloadParams = z.infer<typeof fsDownloadParamsSchema>;
diff --git a/packages/kap-server/src/protocol/rest-guiStore.ts b/packages/kap-server/src/protocol/rest-guiStore.ts
new file mode 100644
index 000000000..b7daf1910
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-guiStore.ts
@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+const keySchema = z.string().min(1).max(256);
+
+export const guiStoreGetItemQuerySchema = z.object({ key: keySchema });
+
+export const guiStoreSetItemBodySchema = z.object({
+  key: keySchema,
+  value: z.string(),
+});
+
+export const guiStoreRemoveItemBodySchema = z.object({ key: keySchema });
+
+export const guiStoreGetItemResponseSchema = z.object({
+  value: z.string().nullable(),
+});
+export type GuiStoreGetItemResponse = z.infer<typeof guiStoreGetItemResponseSchema>;
+
+export const guiStoreLengthResponseSchema = z.object({
+  length: z.number(),
+});
+export type GuiStoreLengthResponse = z.infer<typeof guiStoreLengthResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-message.ts b/packages/kap-server/src/protocol/rest-message.ts
new file mode 100644
index 000000000..a2b7bcbaf
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-message.ts
@@ -0,0 +1,26 @@
+/**
+ *   GET /v1/sessions/{session_id}/messages
+ *   GET /v1/sessions/{session_id}/messages/{message_id}
+ */
+
+import { z } from 'zod';
+
+import { messageRoleSchema, messageSchema } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+
+import { cursorQuerySchema } from './pagination';
+
+export const listMessagesQuerySchema = cursorQuerySchema.and(
+  z.object({
+    role: messageRoleSchema.optional(),
+  }),
+);
+export type ListMessagesQuery = z.infer<typeof listMessagesQuerySchema>;
+
+export const listMessagesResponseSchema = z.object({
+  items: z.array(messageSchema),
+  has_more: z.boolean(),
+});
+export type ListMessagesResponse = z.infer<typeof listMessagesResponseSchema>;
+
+export const getMessageResponseSchema = messageSchema;
+export type GetMessageResponse = z.infer<typeof getMessageResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-meta.ts b/packages/kap-server/src/protocol/rest-meta.ts
new file mode 100644
index 000000000..090712e27
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-meta.ts
@@ -0,0 +1,44 @@
+/**
+ * GET /v1/meta
+ *   Reply: MetaResponse { server_version, capabilities, server_id, started_at }
+ */
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+import { fsOpenInAppIdSchema } from './rest-fs';
+
+export const metaCapabilitiesSchema = z.object({
+  websocket: z.literal(true),
+  file_upload: z.literal(true),
+  fs_query: z.literal(true),
+  mcp: z.literal(true),
+  tasks: z.literal(true),
+  terminal: z.literal(true),
+});
+
+export type MetaCapabilities = z.infer<typeof metaCapabilitiesSchema>;
+
+export const metaResponseSchema = z.object({
+  server_version: z.string().min(1),
+  capabilities: metaCapabilitiesSchema,
+  server_id: z.string().min(1),
+  started_at: isoDateTimeSchema,
+  open_in_apps: z.array(fsOpenInAppIdSchema),
+  /**
+   * True when the server was started with `--dangerous-bypass-auth`, meaning
+   * the bearer-token gate is disabled on every REST and WebSocket route. The
+   * web UI reads this to skip the token prompt and connect without a
+   * credential. Defaults to false on hardened boots.
+   */
+  dangerous_bypass_auth: z.boolean(),
+  /**
+   * Backend engine generation serving this API. `'v2'` is the DI × Scope
+   * engine (`@moonshot-ai/kap-server` / `agent-core-v2`); older servers omit
+   * the field (treat absence as v1). Lets clients identify the backend without
+   * probing routes.
+   */
+  backend: z.enum(['v1', 'v2']).optional(),
+});
+
+export type MetaResponse = z.infer<typeof metaResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-modelCatalog.ts b/packages/kap-server/src/protocol/rest-modelCatalog.ts
new file mode 100644
index 000000000..f9b2fb66e
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-modelCatalog.ts
@@ -0,0 +1,29 @@
+/**
+ *   GET /v1/models
+ *   GET /v1/providers
+ *   GET /v1/providers/{provider_id}
+ *
+ * The catalog item shapes are owned by the engine
+ * (`app/modelCatalog/modelCatalog`); these are only the REST list/get wrappers
+ * around them.
+ */
+
+import { z } from 'zod';
+
+import {
+  modelCatalogItemSchema,
+  providerCatalogItemSchema,
+} from '@moonshot-ai/agent-core-v2/app/modelCatalog/modelCatalog';
+
+export const listModelsResponseSchema = z.object({
+  items: z.array(modelCatalogItemSchema),
+});
+export type ListModelsResponse = z.infer<typeof listModelsResponseSchema>;
+
+export const listProvidersResponseSchema = z.object({
+  items: z.array(providerCatalogItemSchema),
+});
+export type ListProvidersResponse = z.infer<typeof listProvidersResponseSchema>;
+
+export const getProviderResponseSchema = providerCatalogItemSchema;
+export type GetProviderResponse = z.infer<typeof getProviderResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-oauth.ts b/packages/kap-server/src/protocol/rest-oauth.ts
new file mode 100644
index 000000000..d1cb43690
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-oauth.ts
@@ -0,0 +1,25 @@
+/**
+ *   POST   /v1/oauth/login
+ *   GET    /v1/oauth/login
+ *   POST   /v1/oauth/logout
+ *
+ * Request-side query/body schemas for the OAuth routes. The response shapes are
+ * owned by the engine (`app/auth/oauthProtocol`).
+ */
+
+import { z } from 'zod';
+
+export const oauthLoginStartRequestSchema = z.object({
+  provider: z.string().min(1).optional(),
+});
+export type OAuthLoginStartRequest = z.infer<typeof oauthLoginStartRequestSchema>;
+
+export const oauthLoginQuerySchema = z.object({
+  provider: z.string().min(1).optional(),
+});
+export type OAuthLoginQuery = z.infer<typeof oauthLoginQuerySchema>;
+
+export const oauthLogoutRequestSchema = z.object({
+  provider: z.string().min(1).optional(),
+});
+export type OAuthLogoutRequest = z.infer<typeof oauthLogoutRequestSchema>;
diff --git a/packages/kap-server/src/protocol/rest-prompt.ts b/packages/kap-server/src/protocol/rest-prompt.ts
new file mode 100644
index 000000000..d1bed6169
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-prompt.ts
@@ -0,0 +1,81 @@
+/**
+ *   POST /v1/sessions/{sid}/prompts
+ *     Body:  PromptSubmission { content, metadata?, agent_id?, model?, thinking?,
+ *              permission_mode?, plan_mode?, swarm_mode?, goal_objective?, goal_control? }
+ *     Reply: PromptSubmitResult { prompt_id, user_message_id, status, content, created_at }
+ *
+ *   GET /v1/sessions/{sid}/prompts
+ *     Reply: { active: PromptItem | null, queued: PromptItem[] }
+ *
+ *   POST /v1/sessions/{sid}/prompts/{pid}:steer
+ *   POST /v1/sessions/{sid}/prompts:steer
+ *     Reply: { steered: true, prompt_ids: string[] }
+ *
+ *   POST /v1/sessions/{sid}/prompts/{pid}:abort
+ *     Reply: { aborted: true, at_seq: number }   (envelope code 0)
+ *            { aborted: false, at_seq: number }  (envelope code 40903, idempotent)
+ */
+
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+import { messageContentSchema } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+import {
+  promptPermissionModeSchema,
+  promptThinkingSchema,
+} from '@moonshot-ai/agent-core-v2/app/sessionLegacy/sessionProtocol';
+
+export { promptPermissionModeSchema, promptThinkingSchema };
+export type { PromptPermissionMode, PromptThinking } from '@moonshot-ai/agent-core-v2/app/sessionLegacy/sessionProtocol';
+
+export const promptSubmissionSchema = z.object({
+  content: z.array(messageContentSchema).min(1),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  agent_id: z.string().min(1).optional(),
+  model: z.string().min(1).optional(),
+  thinking: promptThinkingSchema.optional(),
+  permission_mode: promptPermissionModeSchema.optional(),
+  plan_mode: z.boolean().optional(),
+  swarm_mode: z.boolean().optional(),
+  goal_objective: z.string().optional(),
+  goal_control: z.enum(['pause', 'resume', 'cancel']).optional(),
+});
+export type PromptSubmission = z.infer<typeof promptSubmissionSchema>;
+
+export const promptStatusSchema = z.enum(['running', 'queued', 'blocked']);
+export type PromptStatus = z.infer<typeof promptStatusSchema>;
+
+export const promptItemSchema = z.object({
+  prompt_id: z.string().min(1),
+  user_message_id: z.string().min(1),
+  status: promptStatusSchema,
+  content: z.array(messageContentSchema).min(1),
+  created_at: isoDateTimeSchema,
+});
+export type PromptItem = z.infer<typeof promptItemSchema>;
+
+export const promptListResponseSchema = z.object({
+  active: promptItemSchema.nullable(),
+  queued: z.array(promptItemSchema),
+});
+export type PromptListResponse = z.infer<typeof promptListResponseSchema>;
+
+export const promptSubmitResultSchema = promptItemSchema;
+export type PromptSubmitResult = z.infer<typeof promptSubmitResultSchema>;
+
+export const promptSteerRequestSchema = z.object({
+  prompt_ids: z.array(z.string().min(1)).min(1),
+});
+export type PromptSteerRequest = z.infer<typeof promptSteerRequestSchema>;
+
+export const promptSteerResultSchema = z.object({
+  steered: z.literal(true),
+  prompt_ids: z.array(z.string().min(1)).min(1),
+});
+export type PromptSteerResult = z.infer<typeof promptSteerResultSchema>;
+
+export const promptAbortResponseSchema = z.object({
+  aborted: z.boolean(),
+  at_seq: z.number().int().nonnegative().optional(),
+});
+export type PromptAbortResponse = z.infer<typeof promptAbortResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-question.ts b/packages/kap-server/src/protocol/rest-question.ts
new file mode 100644
index 000000000..e56588435
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-question.ts
@@ -0,0 +1,41 @@
+/**
+ *   GET    /v1/sessions/{sid}/questions?status=pending
+ *   POST   /v1/sessions/{sid}/questions/{qid}             (resolve)
+ *   POST   /v1/sessions/{sid}/questions/{qid}:dismiss     (dismiss)
+ */
+
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+import { questionRequestSchema, questionResponseSchema } from './question';
+
+export const listPendingQuestionsQuerySchema = z.object({
+  status: z.literal('pending'),
+});
+export type ListPendingQuestionsQuery = z.infer<typeof listPendingQuestionsQuerySchema>;
+
+export const listPendingQuestionsResponseSchema = z.object({
+  items: z.array(questionRequestSchema),
+});
+export type ListPendingQuestionsResponse = z.infer<typeof listPendingQuestionsResponseSchema>;
+
+export const questionResolveRequestSchema = questionResponseSchema;
+export type QuestionResolveRequest = z.infer<typeof questionResolveRequestSchema>;
+
+export const questionResolveResultSchema = z.object({
+  resolved: z.literal(true),
+  resolved_at: isoDateTimeSchema,
+});
+export type QuestionResolveResult = z.infer<typeof questionResolveResultSchema>;
+
+export const questionAlreadyResolvedDataSchema = z.object({
+  resolved: z.literal(false),
+});
+export type QuestionAlreadyResolvedData = z.infer<typeof questionAlreadyResolvedDataSchema>;
+
+export const questionDismissResultSchema = z.object({
+  dismissed: z.literal(true),
+  dismissed_at: isoDateTimeSchema,
+});
+export type QuestionDismissResult = z.infer<typeof questionDismissResultSchema>;
diff --git a/packages/kap-server/src/protocol/rest-session.ts b/packages/kap-server/src/protocol/rest-session.ts
new file mode 100644
index 000000000..57528dfe1
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-session.ts
@@ -0,0 +1,213 @@
+/**
+ *   POST    /v1/sessions                  body: SessionCreate   data: Session
+ *   GET     /v1/sessions                  query: ListSessions   data: Page<Session>
+ *   GET     /v1/sessions/{id}             -                     data: Session
+ *   GET     /v1/sessions/{id}/profile     -                     data: Session
+ *   POST    /v1/sessions/{id}/profile     body: SessionUpdate   data: Session
+ *   POST    /v1/sessions/{id}:fork        body: SessionFork     data: Session
+ *   POST    /v1/sessions/{id}:btw         -                     data: StartBtwSession
+ *   GET     /v1/sessions/{id}/children    query: ListSessions   data: Page<Session>
+ *   POST    /v1/sessions/{id}/children    body: SessionChild    data: Session
+ *   GET     /v1/sessions/{id}/status      -                     data: SessionStatus
+ *   POST    /v1/sessions/{id}:compact     body: CompactSession  data: {}
+ *   POST    /v1/sessions/{id}:undo        body: UndoSession     data: UndoSession
+ *   POST    /v1/sessions/{id}:archive     -                     data: { archived: true }
+ *   POST    /v1/sessions/{id}:restore     -                     data: Session
+ */
+
+import { z } from 'zod';
+
+import { messageSchema } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+import {
+  sessionStatusResponseSchema,
+  sessionWarningSchema,
+  sessionWarningsResponseSchema,
+  updateSessionProfileRequestSchema,
+  type UpdateSessionProfileRequest,
+} from '@moonshot-ai/agent-core-v2/app/sessionLegacy/sessionProtocol';
+
+import { goalSnapshotSchema } from './goal';
+import { cursorQuerySchema, pageResponseSchema } from './pagination';
+import {
+  sessionChildCreateSchema,
+  sessionCreateSchema,
+  sessionForkSchema,
+  sessionSchema,
+} from './session';
+
+export {
+  sessionStatusResponseSchema,
+  sessionWarningSchema,
+  sessionWarningsResponseSchema,
+  updateSessionProfileRequestSchema,
+};
+export type {
+  SessionStatusResponse,
+  SessionWarning,
+  SessionWarningsResponse,
+  UpdateSessionProfileRequest,
+} from '@moonshot-ai/agent-core-v2/app/sessionLegacy/sessionProtocol';
+
+export const createSessionRequestSchema = sessionCreateSchema;
+export type CreateSessionRequest = z.infer<typeof createSessionRequestSchema>;
+
+export const createSessionResponseSchema = sessionSchema;
+export type CreateSessionResponse = z.infer<typeof createSessionResponseSchema>;
+
+const booleanQueryParam = z.preprocess(
+  (value) => {
+    if (value === 'true' || value === '1' || value === 1 || value === true) return true;
+    if (value === 'false' || value === '0' || value === 0 || value === false) return false;
+    return value;
+  },
+  z.boolean().optional(),
+);
+
+export const listSessionsQuerySchema = cursorQuerySchema.and(
+  z.object({
+    busy: booleanQueryParam,
+    include_archive: booleanQueryParam,
+    archived_only: booleanQueryParam,
+    exclude_empty: booleanQueryParam,
+  }),
+);
+export type ListSessionsQuery = z.infer<typeof listSessionsQuerySchema>;
+
+export const getSessionResponseSchema = sessionSchema;
+export type GetSessionResponse = z.infer<typeof getSessionResponseSchema>;
+
+export const getSessionProfileResponseSchema = sessionSchema;
+export type GetSessionProfileResponse = z.infer<typeof getSessionProfileResponseSchema>;
+
+export const MAX_SESSION_EXPORT_WEB_LOG_BYTES = 256 * 1024;
+
+export const exportSessionParamsSchema = z.object({
+  session_id: z.string().min(1),
+});
+export type ExportSessionParams = z.infer<typeof exportSessionParamsSchema>;
+
+export const exportSessionRequestSchema = z
+  .object({
+    web_log: z
+      .string()
+      .refine((value) => fitsUtf8ByteLimit(value, MAX_SESSION_EXPORT_WEB_LOG_BYTES), {
+        message: `web_log must not exceed ${MAX_SESSION_EXPORT_WEB_LOG_BYTES} UTF-8 bytes`,
+      })
+      .optional(),
+  })
+  .strict();
+export type ExportSessionRequest = z.infer<typeof exportSessionRequestSchema>;
+
+export const updateSessionProfileResponseSchema = sessionSchema;
+export type UpdateSessionProfileResponse = z.infer<typeof updateSessionProfileResponseSchema>;
+
+export const updateSessionMetaRequestSchema = updateSessionProfileRequestSchema;
+export type UpdateSessionMetaRequest = UpdateSessionProfileRequest;
+
+export const updateSessionMetaResponseSchema = updateSessionProfileResponseSchema;
+export type UpdateSessionMetaResponse = UpdateSessionProfileResponse;
+
+export const updateSessionRequestSchema = updateSessionProfileRequestSchema;
+export type UpdateSessionRequest = z.infer<typeof updateSessionRequestSchema>;
+
+export const updateSessionResponseSchema = sessionSchema;
+export type UpdateSessionResponse = z.infer<typeof updateSessionResponseSchema>;
+
+export const forkSessionRequestSchema = sessionForkSchema;
+export type ForkSessionRequest = z.infer<typeof forkSessionRequestSchema>;
+
+export const forkSessionResponseSchema = sessionSchema;
+export type ForkSessionResponse = z.infer<typeof forkSessionResponseSchema>;
+
+export const startBtwSessionResponseSchema = z.object({
+  agent_id: z.string().min(1),
+});
+export type StartBtwSessionResponse = z.infer<typeof startBtwSessionResponseSchema>;
+
+// Child lists intentionally omit exclude_empty: the /sessions/{id}/children route
+// does not filter by it, so advertising it would mislead generated clients.
+export const listSessionChildrenQuerySchema = cursorQuerySchema.and(
+  z.object({
+    busy: booleanQueryParam,
+    include_archive: booleanQueryParam,
+  }),
+);
+export type ListSessionChildrenQuery = z.infer<typeof listSessionChildrenQuerySchema>;
+
+export const listSessionChildrenResponseSchema = pageResponseSchema(sessionSchema);
+export type ListSessionChildrenResponse = z.infer<typeof listSessionChildrenResponseSchema>;
+
+export const createSessionChildRequestSchema = sessionChildCreateSchema;
+export type CreateSessionChildRequest = z.infer<typeof createSessionChildRequestSchema>;
+
+export const createSessionChildResponseSchema = sessionSchema;
+export type CreateSessionChildResponse = z.infer<typeof createSessionChildResponseSchema>;
+
+// GET /sessions/{id}/goal — the session's current goal snapshot (camelCase,
+// same shape as the `goal.updated` WS event payload), or null when none is
+// active.
+export const getSessionGoalResponseSchema = goalSnapshotSchema.nullable();
+export type GetSessionGoalResponse = z.infer<typeof getSessionGoalResponseSchema>;
+
+export const compactSessionRequestSchema = z.preprocess(
+  (value) => value === undefined ? {} : value,
+  z.object({
+    instruction: z.string().optional(),
+  }),
+);
+export type CompactSessionRequest = z.infer<typeof compactSessionRequestSchema>;
+
+export const compactSessionResponseSchema = z.object({});
+export type CompactSessionResponse = z.infer<typeof compactSessionResponseSchema>;
+
+export const undoSessionRequestSchema = z.preprocess(
+  (value) => value === undefined ? {} : value,
+  z.object({
+    count: z.number().int().positive().default(1),
+    page_size: z.number().int().min(1).max(100).optional(),
+  }),
+);
+export type UndoSessionRequest = z.infer<typeof undoSessionRequestSchema>;
+
+export const undoSessionResponseSchema = z.object({
+  messages: pageResponseSchema(messageSchema),
+  status: sessionStatusResponseSchema,
+});
+export type UndoSessionResponse = z.infer<typeof undoSessionResponseSchema>;
+
+export const archiveSessionResponseSchema = z.object({
+  archived: z.literal(true),
+});
+export type ArchiveSessionResponse = z.infer<typeof archiveSessionResponseSchema>;
+
+export const restoreSessionResponseSchema = sessionSchema;
+export type RestoreSessionResponse = z.infer<typeof restoreSessionResponseSchema>;
+
+/** @deprecated kept as an alias for backward compatibility; prefer archiveSessionResponseSchema. */
+export const deleteSessionResponseSchema = archiveSessionResponseSchema;
+/** @deprecated kept as an alias for backward compatibility; prefer ArchiveSessionResponse. */
+export type DeleteSessionResponse = ArchiveSessionResponse;
+
+export const sessionAbortResponseSchema = z.object({
+  aborted: z.boolean(),
+});
+export type SessionAbortResponse = z.infer<typeof sessionAbortResponseSchema>;
+
+function fitsUtf8ByteLimit(value: string, limit: number): boolean {
+  let bytes = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const codePoint = value.codePointAt(index)!;
+    if (codePoint < 0x80) {
+      bytes += 1;
+    } else if (codePoint < 0x800) {
+      bytes += 2;
+    } else if (codePoint > 0xffff) {
+      bytes += 4;
+      index += 1;
+    } else {
+      bytes += 3;
+    }
+    if (bytes > limit) return false;
+  }
+  return true;
+}
diff --git a/packages/kap-server/src/protocol/rest-skill.ts b/packages/kap-server/src/protocol/rest-skill.ts
new file mode 100644
index 000000000..1aa26b471
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-skill.ts
@@ -0,0 +1,25 @@
+/**
+ *   GET  /v1/sessions/{session_id}/skills
+ *   POST /v1/sessions/{session_id}/skills/{skill_name}:activate
+ */
+
+import { z } from 'zod';
+
+import { skillDescriptorSchema } from './skill';
+
+export const listSkillsResponseSchema = z.object({
+  skills: z.array(skillDescriptorSchema),
+});
+export type ListSkillsResponse = z.infer<typeof listSkillsResponseSchema>;
+
+export const activateSkillRequestSchema = z.object({
+  /** Raw argument string appended after the slash command, e.g. `/review --fix` → `--fix`. */
+  args: z.string().optional(),
+});
+export type ActivateSkillRequest = z.infer<typeof activateSkillRequestSchema>;
+
+export const activateSkillResultSchema = z.object({
+  activated: z.literal(true),
+  skill_name: z.string().min(1),
+});
+export type ActivateSkillResult = z.infer<typeof activateSkillResultSchema>;
diff --git a/packages/kap-server/src/protocol/rest-snapshot.ts b/packages/kap-server/src/protocol/rest-snapshot.ts
new file mode 100644
index 000000000..9b445d615
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-snapshot.ts
@@ -0,0 +1,92 @@
+/**
+ * `GET /v1/sessions/{session_id}/snapshot` — IM-style "initial sync".
+ *
+ * Returns an atomic-at-a-watermark view of everything a client needs to
+ * rebuild a session's UI state, so the standard multi-device rebuild flow is:
+ *
+ *   1. `GET /sessions/{sid}/snapshot`            → state + `as_of_seq` + `epoch`
+ *   2. WS `subscribe` with `cursors[sid] = { seq: as_of_seq, epoch }`
+ *   3. apply live durable events (`seq > as_of_seq`) on top
+ *
+ * `in_flight_turn` carries the accumulated state of a currently-running turn
+ * (volatile deltas are not replayable; this is how a reconnecting client
+ * recovers mid-turn assistant/thinking text and running tool calls).
+ */
+
+import { z } from 'zod';
+
+import { messageSchema } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+
+import { approvalRequestSchema } from './approval';
+import { questionRequestSchema } from './question';
+import { sessionSchema } from './session';
+import { taskSchema } from './task';
+
+export const inFlightToolCallSchema = z.object({
+  tool_call_id: z.string().min(1),
+  name: z.string().min(1),
+  args: z.unknown().optional(),
+  description: z.string().optional(),
+  /** Display payload from `tool.call.started` (ToolInputDisplay). */
+  display: z.unknown().optional(),
+  /** Most recent `tool.progress` update, if any. */
+  last_progress: z
+    .object({
+      kind: z.enum(['stdout', 'stderr', 'progress', 'status', 'custom']),
+      text: z.string().optional(),
+      percent: z.number().optional(),
+    })
+    .optional(),
+});
+export type InFlightToolCall = z.infer<typeof inFlightToolCallSchema>;
+
+export const inFlightTurnSchema = z.object({
+  turn_id: z.number().int().nonnegative(),
+  /** Assistant text accumulated from `assistant.delta` in the current step (reset on `turn.step.started`; earlier steps are in `messages`). */
+  assistant_text: z.string(),
+  /** Thinking text accumulated from `thinking.delta` in the current step (reset on `turn.step.started`). */
+  thinking_text: z.string(),
+  /** Tool calls started but without a `tool.result` yet. */
+  running_tools: z.array(inFlightToolCallSchema),
+  /** Daemon prompt_id of the active prompt, if the turn was started by IPromptService. */
+  current_prompt_id: z.string().optional(),
+});
+export type InFlightTurn = z.infer<typeof inFlightTurnSchema>;
+
+/**
+ * A live subagent task as of the snapshot watermark. Extends the base task
+ * wire shape with the swarm identity metadata that otherwise only rides the
+ * (non-replayed) `subagent.spawned` WS event.
+ */
+export const snapshotSubagentSchema = taskSchema.extend({
+  subagent_phase: z.enum(['queued', 'working', 'suspended', 'completed', 'failed']).optional(),
+  subagent_type: z.string().optional(),
+  parent_tool_call_id: z.string().optional(),
+  suspended_reason: z.string().optional(),
+  swarm_index: z.number().int().nonnegative().optional(),
+  run_in_background: z.boolean().optional(),
+});
+export type SnapshotSubagent = z.infer<typeof snapshotSubagentSchema>;
+
+export const sessionSnapshotResponseSchema = z.object({
+  /** Durable event watermark this snapshot is consistent with. */
+  as_of_seq: z.number().int().nonnegative(),
+  /** Journal epoch — pass back via the WS cursor for invalidation detection. */
+  epoch: z.string().min(1),
+  session: sessionSchema,
+  /** Most recent messages (chronological ascending), bounded page. */
+  messages: z.object({
+    items: z.array(messageSchema),
+    has_more: z.boolean(),
+  }),
+  in_flight_turn: inFlightTurnSchema.nullable(),
+  /**
+   * Roster of live subagent tasks at the watermark, so a reconnecting client
+   * can rebuild swarm cards before the swarm's tool result lands. Optional
+   * for cross-version tolerance: older servers do not send it.
+   */
+  subagents: z.array(snapshotSubagentSchema).optional(),
+  pending_approvals: z.array(approvalRequestSchema),
+  pending_questions: z.array(questionRequestSchema),
+});
+export type SessionSnapshotResponse = z.infer<typeof sessionSnapshotResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-task.ts b/packages/kap-server/src/protocol/rest-task.ts
new file mode 100644
index 000000000..0cb9e84e4
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-task.ts
@@ -0,0 +1,38 @@
+/**
+ *   GET  /v1/sessions/{session_id}/tasks                 query: {status?}
+ *   GET  /v1/sessions/{session_id}/tasks/{task_id}       query: {with_output?, output_bytes?}
+ *   POST /v1/sessions/{session_id}/tasks/{task_id}:cancel
+ */
+
+import { z } from 'zod';
+
+import { taskSchema, taskStatusSchema } from './task';
+
+export const listTasksQuerySchema = z.object({
+  status: taskStatusSchema.optional(),
+});
+export type ListTasksQuery = z.infer<typeof listTasksQuerySchema>;
+
+export const listTasksResponseSchema = z.object({
+  items: z.array(taskSchema),
+});
+export type ListTasksResponse = z.infer<typeof listTasksResponseSchema>;
+
+export const getTaskQuerySchema = z.object({
+  with_output: z.coerce.boolean().optional(),
+  output_bytes: z.coerce.number().int().nonnegative().optional(),
+});
+export type GetTaskQuery = z.infer<typeof getTaskQuerySchema>;
+
+export const getTaskResponseSchema = taskSchema;
+export type GetTaskResponse = z.infer<typeof getTaskResponseSchema>;
+
+export const cancelTaskResultSchema = z.object({
+  cancelled: z.literal(true),
+});
+export type CancelTaskResult = z.infer<typeof cancelTaskResultSchema>;
+
+export const taskAlreadyFinishedDataSchema = z.object({
+  cancelled: z.literal(false),
+});
+export type TaskAlreadyFinishedData = z.infer<typeof taskAlreadyFinishedDataSchema>;
diff --git a/packages/kap-server/src/protocol/rest-terminal.ts b/packages/kap-server/src/protocol/rest-terminal.ts
new file mode 100644
index 000000000..8f0479e1f
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-terminal.ts
@@ -0,0 +1,25 @@
+/**
+ *   GET    /v1/sessions/{session_id}/terminals
+ *   GET    /v1/sessions/{session_id}/terminals/{terminal_id}
+ *   DELETE /v1/sessions/{session_id}/terminals/{terminal_id}
+ *
+ * The `Terminal` shape itself is owned by the engine (`os/interface/terminal`);
+ * these are only the REST list/get/close wrappers around it.
+ */
+
+import { z } from 'zod';
+
+import { terminalSchema } from '@moonshot-ai/agent-core-v2/os/interface/terminal';
+
+export const getTerminalResponseSchema = terminalSchema;
+export type GetTerminalResponse = z.infer<typeof getTerminalResponseSchema>;
+
+export const listTerminalsResponseSchema = z.object({
+  items: z.array(terminalSchema),
+});
+export type ListTerminalsResponse = z.infer<typeof listTerminalsResponseSchema>;
+
+export const closeTerminalResponseSchema = z.object({
+  closed: z.literal(true),
+});
+export type CloseTerminalResponse = z.infer<typeof closeTerminalResponseSchema>;
diff --git a/packages/kap-server/src/protocol/rest-tool.ts b/packages/kap-server/src/protocol/rest-tool.ts
new file mode 100644
index 000000000..4316b3df5
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-tool.ts
@@ -0,0 +1,29 @@
+/**
+ *   GET  /v1/tools                       query: { session_id? }
+ *   GET  /v1/mcp/servers
+ *   POST /v1/mcp/servers/{mcp_server_id}:restart
+ */
+
+import { z } from 'zod';
+
+import { mcpServerSchema, toolDescriptorSchema } from './tool';
+
+export const listToolsQuerySchema = z.object({
+  session_id: z.string().min(1).optional(),
+});
+export type ListToolsQuery = z.infer<typeof listToolsQuerySchema>;
+
+export const listToolsResponseSchema = z.object({
+  tools: z.array(toolDescriptorSchema),
+});
+export type ListToolsResponse = z.infer<typeof listToolsResponseSchema>;
+
+export const listMcpServersResponseSchema = z.object({
+  servers: z.array(mcpServerSchema),
+});
+export type ListMcpServersResponse = z.infer<typeof listMcpServersResponseSchema>;
+
+export const restartMcpServerResultSchema = z.object({
+  restarting: z.literal(true),
+});
+export type RestartMcpServerResult = z.infer<typeof restartMcpServerResultSchema>;
diff --git a/packages/kap-server/src/protocol/rest-workspace.ts b/packages/kap-server/src/protocol/rest-workspace.ts
new file mode 100644
index 000000000..73d9a9dfc
--- /dev/null
+++ b/packages/kap-server/src/protocol/rest-workspace.ts
@@ -0,0 +1,42 @@
+/**
+ *   GET    /v1/workspaces
+ *   POST   /v1/workspaces
+ *   PATCH  /v1/workspaces/{workspace_id}
+ *   DELETE /v1/workspaces/{workspace_id}
+ */
+
+import { z } from 'zod';
+
+import {
+  workspaceCreateSchema,
+  workspaceIdSchema,
+  workspaceSchema,
+  workspaceUpdateSchema,
+} from './workspace';
+
+export const listWorkspacesResponseSchema = z.object({
+  items: z.array(workspaceSchema),
+});
+export type ListWorkspacesResponse = z.infer<typeof listWorkspacesResponseSchema>;
+
+export const createWorkspaceRequestSchema = workspaceCreateSchema;
+export type CreateWorkspaceRequest = z.infer<typeof createWorkspaceRequestSchema>;
+
+export const createWorkspaceResponseSchema = workspaceSchema;
+export type CreateWorkspaceResponse = z.infer<typeof createWorkspaceResponseSchema>;
+
+export const workspaceIdParamSchema = z.object({
+  workspace_id: workspaceIdSchema,
+});
+export type WorkspaceIdParam = z.infer<typeof workspaceIdParamSchema>;
+
+export const updateWorkspaceRequestSchema = workspaceUpdateSchema;
+export type UpdateWorkspaceRequest = z.infer<typeof updateWorkspaceRequestSchema>;
+
+export const updateWorkspaceResponseSchema = workspaceSchema;
+export type UpdateWorkspaceResponse = z.infer<typeof updateWorkspaceResponseSchema>;
+
+export const deleteWorkspaceResponseSchema = z.object({
+  deleted: z.literal(true),
+});
+export type DeleteWorkspaceResponse = z.infer<typeof deleteWorkspaceResponseSchema>;
diff --git a/packages/kap-server/src/protocol/session.ts b/packages/kap-server/src/protocol/session.ts
new file mode 100644
index 000000000..9fa454244
--- /dev/null
+++ b/packages/kap-server/src/protocol/session.ts
@@ -0,0 +1,91 @@
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+import {
+  permissionRuleSchema,
+  sessionAgentConfigPartialSchema,
+  sessionAgentConfigSchema,
+  sessionMetadataSchema,
+} from '@moonshot-ai/agent-core-v2/app/sessionLegacy/sessionProtocol';
+
+import { workspaceIdSchema } from './workspace';
+
+export const sessionUsageSchema = z.object({
+  input_tokens: z.number().int().nonnegative(),
+  output_tokens: z.number().int().nonnegative(),
+  cache_read_tokens: z.number().int().nonnegative(),
+  cache_creation_tokens: z.number().int().nonnegative(),
+  total_cost_usd: z.number().nonnegative(),
+  context_tokens: z.number().int().nonnegative(),
+  context_limit: z.number().int().nonnegative(),
+  turn_count: z.number().int().nonnegative(),
+});
+
+export type SessionUsage = z.infer<typeof sessionUsageSchema>;
+
+export function emptySessionUsage(): SessionUsage {
+  return {
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_creation_tokens: 0,
+    total_cost_usd: 0,
+    context_tokens: 0,
+    context_limit: 0,
+    turn_count: 0,
+  };
+}
+
+export const sessionPendingInteractionSchema = z.enum(['none', 'approval', 'question']);
+export type SessionPendingInteraction = z.infer<typeof sessionPendingInteractionSchema>;
+
+export const sessionSchema = z.object({
+  id: z.string().min(1),
+  workspace_id: workspaceIdSchema,
+  title: z.string(),
+  created_at: isoDateTimeSchema,
+  updated_at: isoDateTimeSchema,
+  /** Any agent in the session holds an active turn or background lease. */
+  busy: z.boolean(),
+  /** Whether the main agent currently owns an active turn. */
+  main_turn_active: z.boolean().optional(),
+  /** Highest-priority pending human interaction. */
+  pending_interaction: sessionPendingInteractionSchema.optional(),
+  /** Outcome of the main agent's most recent turn. */
+  last_turn_reason: z.enum(['completed', 'cancelled', 'failed']).optional(),
+  archived: z.boolean().optional(),
+  current_prompt_id: z.string().min(1).optional(),
+  /** Text of the most recent user prompt, for search/preview. Absent for empty sessions. */
+  last_prompt: z.string().optional(),
+  metadata: sessionMetadataSchema,
+  agent_config: sessionAgentConfigSchema,
+  usage: sessionUsageSchema,
+  permission_rules: z.array(permissionRuleSchema),
+  message_count: z.number().int().nonnegative(),
+  last_seq: z.number().int().nonnegative(),
+});
+
+export type Session = z.infer<typeof sessionSchema>;
+
+export const sessionCreateSchema = z.object({
+  title: z.string().min(1).optional(),
+  metadata: sessionMetadataSchema.optional(),
+  agent_config: sessionAgentConfigPartialSchema.optional(),
+  workspace_id: workspaceIdSchema.optional(),
+});
+
+export type SessionCreate = z.infer<typeof sessionCreateSchema>;
+
+export const sessionForkSchema = z.object({
+  title: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type SessionFork = z.infer<typeof sessionForkSchema>;
+
+export const sessionChildCreateSchema = z.object({
+  title: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type SessionChildCreate = z.infer<typeof sessionChildCreateSchema>;
diff --git a/packages/kap-server/src/protocol/skill.ts b/packages/kap-server/src/protocol/skill.ts
new file mode 100644
index 000000000..3a5afdc7f
--- /dev/null
+++ b/packages/kap-server/src/protocol/skill.ts
@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const skillSourceSchema = z.enum(['project', 'user', 'extra', 'builtin']);
+export type SkillSource = z.infer<typeof skillSourceSchema>;
+
+export const skillDescriptorSchema = z.object({
+  name: z.string().min(1),
+  description: z.string(),
+  path: z.string(),
+  source: skillSourceSchema,
+  type: z.string().optional(),
+  /** `true` when the skill is user-slash only (model must not auto-invoke). */
+  disable_model_invocation: z.boolean().optional(),
+});
+export type SkillDescriptor = z.infer<typeof skillDescriptorSchema>;
diff --git a/packages/kap-server/src/protocol/task.ts b/packages/kap-server/src/protocol/task.ts
new file mode 100644
index 000000000..7d64135e8
--- /dev/null
+++ b/packages/kap-server/src/protocol/task.ts
@@ -0,0 +1,29 @@
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+export const taskKindSchema = z.enum(['subagent', 'bash', 'tool']);
+export type TaskKind = z.infer<typeof taskKindSchema>;
+
+export const taskStatusSchema = z.enum([
+  'running',
+  'completed',
+  'failed',
+  'cancelled',
+]);
+export type TaskStatus = z.infer<typeof taskStatusSchema>;
+
+export const taskSchema = z.object({
+  id: z.string().min(1),
+  session_id: z.string().min(1),
+  kind: taskKindSchema,
+  description: z.string(),
+  status: taskStatusSchema,
+  command: z.string().optional(),
+  created_at: isoDateTimeSchema,
+  started_at: isoDateTimeSchema.optional(),
+  completed_at: isoDateTimeSchema.optional(),
+  output_preview: z.string().optional(),
+  output_bytes: z.number().int().nonnegative().optional(),
+});
+export type Task = z.infer<typeof taskSchema>;
diff --git a/packages/kap-server/src/protocol/tool.ts b/packages/kap-server/src/protocol/tool.ts
new file mode 100644
index 000000000..92ad7fac0
--- /dev/null
+++ b/packages/kap-server/src/protocol/tool.ts
@@ -0,0 +1,34 @@
+import { z } from 'zod';
+
+export const toolSourceSchema = z.enum(['builtin', 'skill', 'mcp']);
+export type ToolSource = z.infer<typeof toolSourceSchema>;
+
+export const toolDescriptorSchema = z.object({
+  name: z.string().min(1),
+  description: z.string(),
+  input_schema: z.unknown(),
+  source: toolSourceSchema,
+  mcp_server_id: z.string().min(1).optional(),
+});
+export type ToolDescriptor = z.infer<typeof toolDescriptorSchema>;
+
+export const mcpServerStatusSchema = z.enum([
+  'connected',
+  'connecting',
+  'disconnected',
+  'error',
+]);
+export type McpServerStatus = z.infer<typeof mcpServerStatusSchema>;
+
+export const mcpServerTransportSchema = z.enum(['stdio', 'http', 'sse']);
+export type McpServerTransport = z.infer<typeof mcpServerTransportSchema>;
+
+export const mcpServerSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  transport: mcpServerTransportSchema,
+  status: mcpServerStatusSchema,
+  last_error: z.string().optional(),
+  tool_count: z.number().int().nonnegative(),
+});
+export type McpServer = z.infer<typeof mcpServerSchema>;
diff --git a/packages/kap-server/src/protocol/workspace.ts b/packages/kap-server/src/protocol/workspace.ts
new file mode 100644
index 000000000..d3c48c76e
--- /dev/null
+++ b/packages/kap-server/src/protocol/workspace.ts
@@ -0,0 +1,35 @@
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+export const workspaceIdSchema = z
+  .string()
+  .regex(/^wd_[a-z0-9._-]+_[0-9a-f]{12}$/, {
+    message: 'workspace_id must be a wd_<slug>_<hash12> string',
+  });
+
+export type WorkspaceId = z.infer<typeof workspaceIdSchema>;
+
+export const workspaceSchema = z.object({
+  id: workspaceIdSchema,
+  root: z.string().min(1),
+  name: z.string().min(1).max(100),
+  created_at: isoDateTimeSchema,
+  last_opened_at: isoDateTimeSchema,
+  session_count: z.number().int().nonnegative(),
+});
+
+export type Workspace = z.infer<typeof workspaceSchema>;
+
+export const workspaceCreateSchema = z.object({
+  root: z.string().min(1),
+  name: z.string().min(1).max(100).optional(),
+});
+
+export type WorkspaceCreate = z.infer<typeof workspaceCreateSchema>;
+
+export const workspaceUpdateSchema = z.object({
+  name: z.string().min(1).max(100),
+});
+
+export type WorkspaceUpdate = z.infer<typeof workspaceUpdateSchema>;
diff --git a/packages/kap-server/src/protocol/ws-control.ts b/packages/kap-server/src/protocol/ws-control.ts
new file mode 100644
index 000000000..f44b43a72
--- /dev/null
+++ b/packages/kap-server/src/protocol/ws-control.ts
@@ -0,0 +1,646 @@
+/**
+ *   Event:   { type, seq, session_id?, timestamp, payload }
+ *   Control: { type, id?, payload }
+ *   Ack:     { type: 'ack', id, code, msg, payload }
+ */
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '@moonshot-ai/agent-core-v2/_base/utils/isoDateTime';
+
+import { eventSchema } from './events-zod';
+
+/**
+ * WS protocol version. v2 (breaking, IM-style multi-device sync):
+ *   - per-session cursors are `{ seq, epoch }` instead of a bare seq
+ *   - `seq` is durable (journal offset, survives daemon restarts)
+ *   - volatile events carry `volatile: true` and do not advance `seq`
+ *   - `resync_required` gains the `epoch_changed` reason + `epoch` field
+ */
+export const WS_PROTOCOL_VERSION = 2;
+
+/**
+ * Per-session sync cursor. `seq` is the last durable event seq the client
+ * has applied (journal offset). `epoch` identifies the journal incarnation
+ * (changes when a session's journal is recreated); a cursor whose epoch does
+ * not match the server's current epoch is invalid and triggers
+ * `resync_required(epoch_changed)`. `epoch` is absent on a fresh cursor.
+ */
+export const sessionCursorSchema = z.object({
+  seq: z.number().int().nonnegative(),
+  epoch: z.string().min(1).optional(),
+});
+
+export type SessionCursor = z.infer<typeof sessionCursorSchema>;
+
+export const cursorsBySessionSchema = z.record(z.string(), sessionCursorSchema);
+
+export type CursorsBySession = z.infer<typeof cursorsBySessionSchema>;
+
+export const wsEventEnvelopeSchema = <T extends z.ZodTypeAny>(payload: T) =>
+  z.object({
+    type: z.string(),
+    seq: z.number().int().nonnegative(),
+    epoch: z.string().optional(),
+    volatile: z.boolean().optional(),
+    /**
+     * For volatile text-delta frames (`assistant.delta` / `thinking.delta`):
+     * the cumulative character offset of this delta within the in-flight
+     * turn's accumulated stream. Clients align against
+     * `snapshot.in_flight_turn.*_text.length` — `offset < local length` is a
+     * duplicate (skip), `offset > local length` means deltas were missed
+     * (re-snapshot).
+     */
+    offset: z.number().int().nonnegative().optional(),
+    session_id: z.string().optional(),
+    timestamp: isoDateTimeSchema,
+    payload,
+  });
+
+export const wsControlEnvelopeSchema = <T extends z.ZodTypeAny>(payload: T) =>
+  z.object({
+    type: z.string(),
+    id: z.string().optional(),
+    payload,
+  });
+
+export const wsAckEnvelopeSchema = <T extends z.ZodTypeAny>(payload: T) =>
+  z.object({
+    type: z.literal('ack'),
+    id: z.string(),
+    code: z.number().int(),
+    msg: z.string(),
+    payload,
+  });
+
+export const serverHelloPayloadSchema = z.object({
+  ws_connection_id: z.string(),
+  protocol_version: z.number().int().positive(),
+  /**
+   * Legacy servers advertise their ping interval here. kap-server dropped the
+   * server-initiated heartbeat and omits this field — clients must treat it as
+   * advisory and not require it.
+   */
+  heartbeat_ms: z.number().int().positive().optional(),
+  max_event_buffer_size: z.number().int().positive(),
+  capabilities: z.object({
+    event_batching: z.boolean(),
+    compression: z.boolean(),
+  }),
+});
+
+export const serverHelloMessageSchema = z.object({
+  type: z.literal('server_hello'),
+  timestamp: isoDateTimeSchema,
+  payload: serverHelloPayloadSchema,
+});
+
+export type ServerHelloMessage = z.infer<typeof serverHelloMessageSchema>;
+
+/**
+ * Per-session agent allowlist for fine-grained v1 event subscriptions. Keys are
+ * session ids, values are the non-empty set of agent ids the client wants to
+ * receive events for within that session. Sessions absent from the map (or the
+ * whole field omitted) fall back to receiving every agent — the legacy
+ * session-grained behavior.
+ */
+export const agentFilterSchema = z.record(z.string(), z.array(z.string()).min(1));
+
+export type AgentFilter = z.infer<typeof agentFilterSchema>;
+
+export const clientHelloPayloadSchema = z.object({
+  client_id: z.string(),
+  subscriptions: z.array(z.string()),
+  cursors: cursorsBySessionSchema.optional(),
+  agent_filter: agentFilterSchema.optional(),
+});
+
+export const clientHelloMessageSchema = z.object({
+  type: z.literal('client_hello'),
+  id: z.string(),
+  payload: clientHelloPayloadSchema,
+});
+
+export type ClientHelloMessage = z.infer<typeof clientHelloMessageSchema>;
+
+export const clientHelloAckPayloadSchema = z.object({
+  accepted_subscriptions: z.array(z.string()),
+  resync_required: z.array(z.string()),
+  /** Server-side current cursor per accepted session ({seq, epoch}). */
+  cursors: cursorsBySessionSchema.optional(),
+});
+
+export const helloAckPayloadSchema = clientHelloAckPayloadSchema;
+
+export const clientHelloAckMessageSchema = wsAckEnvelopeSchema(clientHelloAckPayloadSchema);
+
+export const watchFsConfigSchema = z.object({
+  paths: z.array(z.string()),
+  recursive: z.boolean().optional(),
+});
+
+export const subscribePayloadSchema = z.object({
+  session_ids: z.array(z.string()),
+  cursors: cursorsBySessionSchema.optional(),
+  watch_fs: z.record(z.string(), watchFsConfigSchema).optional(),
+  agent_filter: agentFilterSchema.optional(),
+});
+
+export const subscribeMessageSchema = z.object({
+  type: z.literal('subscribe'),
+  id: z.string(),
+  payload: subscribePayloadSchema,
+});
+
+export type SubscribeMessage = z.infer<typeof subscribeMessageSchema>;
+
+export const subscribeAckPayloadSchema = z.object({
+  accepted: z.array(z.string()),
+  not_found: z.array(z.string()),
+  resync_required: z.array(z.string()),
+  /** Server-side current cursor per accepted session ({seq, epoch}). */
+  cursors: cursorsBySessionSchema.optional(),
+});
+
+export const subscribeAckMessageSchema = wsAckEnvelopeSchema(subscribeAckPayloadSchema);
+
+export const unsubscribePayloadSchema = z.object({
+  session_ids: z.array(z.string()),
+});
+
+export const unsubscribeMessageSchema = z.object({
+  type: z.literal('unsubscribe'),
+  id: z.string(),
+  payload: unsubscribePayloadSchema,
+});
+
+export type UnsubscribeMessage = z.infer<typeof unsubscribeMessageSchema>;
+
+export const unsubscribeAckPayloadSchema = subscribeAckPayloadSchema;
+
+export const unsubscribeAckMessageSchema = wsAckEnvelopeSchema(unsubscribeAckPayloadSchema);
+
+export const watchFsAddPayloadSchema = z.object({
+  session_id: z.string(),
+  paths: z.array(z.string()),
+  recursive: z.boolean().optional(),
+});
+
+export const watchFsAddMessageSchema = z.object({
+  type: z.literal('watch_fs_add'),
+  id: z.string(),
+  payload: watchFsAddPayloadSchema,
+});
+
+export type WatchFsAddMessage = z.infer<typeof watchFsAddMessageSchema>;
+
+export const watchFsRemovePayloadSchema = z.object({
+  session_id: z.string(),
+  paths: z.array(z.string()),
+});
+
+export const watchFsRemoveMessageSchema = z.object({
+  type: z.literal('watch_fs_remove'),
+  id: z.string(),
+  payload: watchFsRemovePayloadSchema,
+});
+
+export type WatchFsRemoveMessage = z.infer<typeof watchFsRemoveMessageSchema>;
+
+export const watchFsAckPayloadSchema = z.object({
+  watched_paths: z.array(z.string()).optional(),
+  current_count: z.number().int().nonnegative().optional(),
+});
+
+export const watchFsAckMessageSchema = wsAckEnvelopeSchema(watchFsAckPayloadSchema);
+
+/**
+ * Filesystem change-notification payloads, ported verbatim from the v1
+ * protocol's `fs.ts` (agent-core-v2 only carries the plain types). Emitted by
+ * the `watch_fs` notification path on subscribed sessions.
+ */
+export const fsChangeKindSchema = z.enum(['file', 'directory', 'symlink']);
+export type FsChangeKind = z.infer<typeof fsChangeKindSchema>;
+
+export const fsChangeActionSchema = z.enum(['created', 'modified', 'deleted']);
+export type FsChangeAction = z.infer<typeof fsChangeActionSchema>;
+
+export const fsChangeEntrySchema = z.object({
+  path: z.string(),
+  change: fsChangeActionSchema,
+  kind: fsChangeKindSchema,
+  size_delta: z.number().int().optional(),
+  etag: z.string().optional(),
+});
+export type FsChangeEntry = z.infer<typeof fsChangeEntrySchema>;
+
+export const fsChangeEventSchema = z.object({
+  changes: z.array(fsChangeEntrySchema),
+  coalesced_window_ms: z.number().int().positive(),
+  truncated: z.boolean().optional(),
+  count: z.number().int().nonnegative().optional(),
+});
+export type FsChangeEvent = z.infer<typeof fsChangeEventSchema>;
+
+export const abortPayloadSchema = z.object({
+  session_id: z.string(),
+  prompt_id: z.string(),
+});
+
+export const abortMessageSchema = z.object({
+  type: z.literal('abort'),
+  id: z.string(),
+  payload: abortPayloadSchema,
+});
+
+export type AbortMessage = z.infer<typeof abortMessageSchema>;
+
+export const abortAckPayloadSchema = z.object({
+  aborted: z.boolean().optional(),
+  at_seq: z.number().int().nonnegative().optional(),
+});
+
+export const abortAckMessageSchema = wsAckEnvelopeSchema(abortAckPayloadSchema);
+
+export const terminalAttachPayloadSchema = z.object({
+  session_id: z.string().min(1),
+  terminal_id: z.string().min(1),
+  since_seq: z.number().int().nonnegative().optional(),
+});
+
+export const terminalAttachMessageSchema = z.object({
+  type: z.literal('terminal_attach'),
+  id: z.string(),
+  payload: terminalAttachPayloadSchema,
+});
+
+export type TerminalAttachMessage = z.infer<typeof terminalAttachMessageSchema>;
+
+export const terminalAttachAckPayloadSchema = z.object({
+  attached: z.literal(true),
+  replayed: z.number().int().nonnegative(),
+});
+
+export const terminalAttachAckMessageSchema = wsAckEnvelopeSchema(
+  terminalAttachAckPayloadSchema,
+);
+
+export const terminalDetachPayloadSchema = z.object({
+  session_id: z.string().min(1),
+  terminal_id: z.string().min(1),
+});
+
+export const terminalDetachMessageSchema = z.object({
+  type: z.literal('terminal_detach'),
+  id: z.string(),
+  payload: terminalDetachPayloadSchema,
+});
+
+export type TerminalDetachMessage = z.infer<typeof terminalDetachMessageSchema>;
+
+export const terminalDetachAckPayloadSchema = z.object({
+  detached: z.literal(true),
+});
+
+export const terminalDetachAckMessageSchema = wsAckEnvelopeSchema(
+  terminalDetachAckPayloadSchema,
+);
+
+export const terminalInputPayloadSchema = z.object({
+  session_id: z.string().min(1),
+  terminal_id: z.string().min(1),
+  data: z.string(),
+});
+
+export const terminalInputMessageSchema = z.object({
+  type: z.literal('terminal_input'),
+  id: z.string(),
+  payload: terminalInputPayloadSchema,
+});
+
+export type TerminalInputMessage = z.infer<typeof terminalInputMessageSchema>;
+
+export const terminalInputAckPayloadSchema = z.object({
+  accepted: z.literal(true),
+});
+
+export const terminalInputAckMessageSchema = wsAckEnvelopeSchema(
+  terminalInputAckPayloadSchema,
+);
+
+export const terminalResizePayloadSchema = z.object({
+  session_id: z.string().min(1),
+  terminal_id: z.string().min(1),
+  cols: z.number().int().positive(),
+  rows: z.number().int().positive(),
+});
+
+export const terminalResizeMessageSchema = z.object({
+  type: z.literal('terminal_resize'),
+  id: z.string(),
+  payload: terminalResizePayloadSchema,
+});
+
+export type TerminalResizeMessage = z.infer<typeof terminalResizeMessageSchema>;
+
+export const terminalResizeAckPayloadSchema = z.object({
+  resized: z.literal(true),
+});
+
+export const terminalResizeAckMessageSchema = wsAckEnvelopeSchema(
+  terminalResizeAckPayloadSchema,
+);
+
+export const terminalClosePayloadSchema = z.object({
+  session_id: z.string().min(1),
+  terminal_id: z.string().min(1),
+});
+
+export const terminalCloseMessageSchema = z.object({
+  type: z.literal('terminal_close'),
+  id: z.string(),
+  payload: terminalClosePayloadSchema,
+});
+
+export type TerminalCloseMessage = z.infer<typeof terminalCloseMessageSchema>;
+
+export const terminalCloseAckPayloadSchema = z.object({
+  closed: z.literal(true),
+});
+
+export const terminalCloseAckMessageSchema = wsAckEnvelopeSchema(
+  terminalCloseAckPayloadSchema,
+);
+
+export const pingPayloadSchema = z.object({
+  nonce: z.string(),
+});
+
+export const pingMessageSchema = z.object({
+  type: z.literal('ping'),
+  timestamp: isoDateTimeSchema,
+  payload: pingPayloadSchema,
+});
+
+export type PingMessage = z.infer<typeof pingMessageSchema>;
+
+export const pongPayloadSchema = z.object({
+  nonce: z.string(),
+});
+
+export const pongMessageSchema = z.object({
+  type: z.literal('pong'),
+  payload: pongPayloadSchema,
+});
+
+export type PongMessage = z.infer<typeof pongMessageSchema>;
+
+export const resyncRequiredPayloadSchema = z.object({
+  session_id: z.string(),
+  reason: z.enum(['buffer_overflow', 'session_recreated', 'epoch_changed']),
+  current_seq: z.number().int().nonnegative(),
+  /** Current journal epoch — the client should adopt it after resyncing. */
+  epoch: z.string().min(1).optional(),
+});
+
+export const resyncRequiredMessageSchema = z.object({
+  type: z.literal('resync_required'),
+  timestamp: isoDateTimeSchema,
+  payload: resyncRequiredPayloadSchema,
+});
+
+export type ResyncRequiredMessage = z.infer<typeof resyncRequiredMessageSchema>;
+
+export const wsErrorPayloadSchema = z.object({
+  code: z.number().int(),
+  msg: z.string(),
+  fatal: z.boolean(),
+  request_id: z.string().optional(),
+  details: z.unknown().optional(),
+});
+
+export const wsErrorMessageSchema = z.object({
+  type: z.literal('error'),
+  timestamp: isoDateTimeSchema,
+  payload: wsErrorPayloadSchema,
+});
+
+export type WsErrorMessage = z.infer<typeof wsErrorMessageSchema>;
+
+export const sessionEventMessageSchema = wsEventEnvelopeSchema(eventSchema);
+
+export const terminalOutputPayloadSchema = z.object({
+  data: z.string(),
+});
+
+export const terminalOutputMessageSchema = z.object({
+  type: z.literal('terminal_output'),
+  seq: z.number().int().positive(),
+  session_id: z.string().min(1),
+  terminal_id: z.string().min(1),
+  timestamp: isoDateTimeSchema,
+  payload: terminalOutputPayloadSchema,
+});
+
+export type TerminalOutputMessage = z.infer<typeof terminalOutputMessageSchema>;
+
+export const terminalExitPayloadSchema = z.object({
+  exit_code: z.number().int().nullable().optional(),
+});
+
+export const terminalExitMessageSchema = z.object({
+  type: z.literal('terminal_exit'),
+  session_id: z.string().min(1),
+  terminal_id: z.string().min(1),
+  timestamp: isoDateTimeSchema,
+  payload: terminalExitPayloadSchema,
+});
+
+export type TerminalExitMessage = z.infer<typeof terminalExitMessageSchema>;
+
+export const clientControlMessageSchema = z.discriminatedUnion('type', [
+  clientHelloMessageSchema,
+  subscribeMessageSchema,
+  unsubscribeMessageSchema,
+  watchFsAddMessageSchema,
+  watchFsRemoveMessageSchema,
+  abortMessageSchema,
+  terminalAttachMessageSchema,
+  terminalDetachMessageSchema,
+  terminalInputMessageSchema,
+  terminalResizeMessageSchema,
+  terminalCloseMessageSchema,
+  pongMessageSchema,
+]);
+
+export type ClientControlMessage = z.infer<typeof clientControlMessageSchema>;
+
+export const serverSystemMessageSchema = z.discriminatedUnion('type', [
+  serverHelloMessageSchema,
+  pingMessageSchema,
+  resyncRequiredMessageSchema,
+  wsErrorMessageSchema,
+]);
+
+export type ServerSystemMessage = z.infer<typeof serverSystemMessageSchema>;
+
+export type WsOperationDirection = 'client_to_server' | 'server_to_client';
+
+export type WsOperationKind = 'control' | 'system' | 'event';
+
+export interface WsOperationDefinition {
+  readonly type: string;
+  readonly direction: WsOperationDirection;
+  readonly kind: WsOperationKind;
+  readonly messageSchema: z.ZodTypeAny;
+  readonly ackSchema?: z.ZodTypeAny;
+  readonly description: string;
+}
+
+export const clientControlOperations = [
+  {
+    type: 'client_hello',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: clientHelloMessageSchema,
+    ackSchema: clientHelloAckMessageSchema,
+    description: 'Start a client session and optionally subscribe to existing daemon sessions.',
+  },
+  {
+    type: 'subscribe',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: subscribeMessageSchema,
+    ackSchema: subscribeAckMessageSchema,
+    description: 'Subscribe the connection to one or more session event streams.',
+  },
+  {
+    type: 'unsubscribe',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: unsubscribeMessageSchema,
+    ackSchema: unsubscribeAckMessageSchema,
+    description: 'Remove one or more session event stream subscriptions.',
+  },
+  {
+    type: 'watch_fs_add',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: watchFsAddMessageSchema,
+    ackSchema: watchFsAckMessageSchema,
+    description: 'Add filesystem watch paths for a subscribed session.',
+  },
+  {
+    type: 'watch_fs_remove',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: watchFsRemoveMessageSchema,
+    ackSchema: watchFsAckMessageSchema,
+    description: 'Remove filesystem watch paths for a subscribed session.',
+  },
+  {
+    type: 'abort',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: abortMessageSchema,
+    ackSchema: abortAckMessageSchema,
+    description: 'Abort a running prompt in a session.',
+  },
+  {
+    type: 'terminal_attach',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: terminalAttachMessageSchema,
+    ackSchema: terminalAttachAckMessageSchema,
+    description: 'Attach this connection to a terminal stream.',
+  },
+  {
+    type: 'terminal_detach',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: terminalDetachMessageSchema,
+    ackSchema: terminalDetachAckMessageSchema,
+    description: 'Detach this connection from a terminal stream.',
+  },
+  {
+    type: 'terminal_input',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: terminalInputMessageSchema,
+    ackSchema: terminalInputAckMessageSchema,
+    description: 'Write raw input bytes to a terminal.',
+  },
+  {
+    type: 'terminal_resize',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: terminalResizeMessageSchema,
+    ackSchema: terminalResizeAckMessageSchema,
+    description: 'Resize a terminal.',
+  },
+  {
+    type: 'terminal_close',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: terminalCloseMessageSchema,
+    ackSchema: terminalCloseAckMessageSchema,
+    description: 'Close a terminal.',
+  },
+  {
+    type: 'pong',
+    direction: 'client_to_server',
+    kind: 'control',
+    messageSchema: pongMessageSchema,
+    description: 'Reply to a server ping with the same nonce.',
+  },
+] as const satisfies readonly WsOperationDefinition[];
+
+export const serverSystemOperations = [
+  {
+    type: 'server_hello',
+    direction: 'server_to_client',
+    kind: 'system',
+    messageSchema: serverHelloMessageSchema,
+    description: 'Initial server greeting sent immediately after the socket opens.',
+  },
+  {
+    type: 'ping',
+    direction: 'server_to_client',
+    kind: 'system',
+    messageSchema: pingMessageSchema,
+    description: 'Heartbeat ping sent by the server; clients must answer with pong.',
+  },
+  {
+    type: 'resync_required',
+    direction: 'server_to_client',
+    kind: 'system',
+    messageSchema: resyncRequiredMessageSchema,
+    description: 'Signals that a client must rebuild local session state from REST history.',
+  },
+  {
+    type: 'error',
+    direction: 'server_to_client',
+    kind: 'system',
+    messageSchema: wsErrorMessageSchema,
+    description: 'Server-side WebSocket protocol or runtime error.',
+  },
+] as const satisfies readonly WsOperationDefinition[];
+
+export const sessionEventOperation = {
+  type: 'session_event',
+  direction: 'server_to_client',
+  kind: 'event',
+  messageSchema: sessionEventMessageSchema,
+  description: 'Session-scoped agent event envelope; frame type is the payload event type.',
+} as const satisfies WsOperationDefinition;
+
+export const wsOperations = [
+  ...clientControlOperations,
+  ...serverSystemOperations,
+  sessionEventOperation,
+] as const satisfies readonly WsOperationDefinition[];
+
+export function getClientControlOperation(
+  type: string,
+): (typeof clientControlOperations)[number] | undefined {
+  return clientControlOperations.find((operation) => operation.type === type);
+}
diff --git a/packages/kap-server/src/request-id.ts b/packages/kap-server/src/request-id.ts
index 48b4e3a24..9d0d7bb57 100644
--- a/packages/kap-server/src/request-id.ts
+++ b/packages/kap-server/src/request-id.ts
@@ -1,14 +1,14 @@
 /**
  * `request_id` resolution at the server's REST boundary.
  *
- * Delegates to `parseOrGenerateRequestId` from `@moonshot-ai/protocol`, which:
+ * Delegates to `parseOrGenerateRequestId` from the local `protocol` module, which:
  *   - returns a bare 26-char ULID (no `req_` prefix);
  *   - validates client-supplied `X-Request-Id` is a real ULID and regenerates
  *     a fresh one on malformed input so operator logs do not carry
  *     attacker-controlled strings verbatim.
  */
 
-import { parseOrGenerateRequestId } from '@moonshot-ai/protocol';
+import { parseOrGenerateRequestId } from './protocol/request-id';
 
 const REQUEST_ID_HEADER = 'x-request-id';
 
diff --git a/packages/kap-server/src/routes/approvals.ts b/packages/kap-server/src/routes/approvals.ts
index 0863c77d7..9e5966948 100644
--- a/packages/kap-server/src/routes/approvals.ts
+++ b/packages/kap-server/src/routes/approvals.ts
@@ -37,17 +37,18 @@ import {
   type Interaction,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
+import { ErrorCode } from '../protocol/error-codes';
 import {
   approvalAlreadyResolvedDataSchema,
   approvalResolveRequestSchema,
   approvalResolveResultSchema,
-  ErrorCode,
   listPendingApprovalsQuerySchema,
   listPendingApprovalsResponseSchema,
-} from '@moonshot-ai/protocol';
+} from '../protocol/rest-approval';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 
 interface ApprovalRouteHost {
@@ -170,6 +171,11 @@ export function registerApprovalsRoutes(app: ApprovalRouteHost, core: Scope): vo
         selectedLabel: body.selected_label,
       };
       handle.accessor.get(ISessionApprovalService).decide(approval_id, response);
+      // Security-sensitive: record who resolved what, and how.
+      requestLog(req)?.info(
+        { session_id, approval_id, decision: response.decision, scope: response.scope },
+        'approval decided',
+      );
       reply.send(
         okEnvelope({ resolved: true as const, resolved_at: new Date().toISOString() }, req.id),
       );
diff --git a/packages/kap-server/src/routes/auth.ts b/packages/kap-server/src/routes/auth.ts
index 870728997..63a7dfb09 100644
--- a/packages/kap-server/src/routes/auth.ts
+++ b/packages/kap-server/src/routes/auth.ts
@@ -13,7 +13,7 @@
  */
 
 import { IAuthLegacyService, type Scope } from '@moonshot-ai/agent-core-v2';
-import { authSummarySchema } from '@moonshot-ai/protocol';
+import { authSummarySchema } from '@moonshot-ai/agent-core-v2/app/authLegacy/authLegacy';
 
 import { okEnvelope } from '../envelope';
 import { defineRoute } from '../middleware/defineRoute';
diff --git a/packages/kap-server/src/routes/config.ts b/packages/kap-server/src/routes/config.ts
index 5e46efe28..c39347f07 100644
--- a/packages/kap-server/src/routes/config.ts
+++ b/packages/kap-server/src/routes/config.ts
@@ -6,7 +6,7 @@
  *   GET  /config   — global Kimi configuration, secrets redacted
  *   POST /config   — update global configuration (merge semantics)
  *
- * **Wire fidelity**: reuses `@moonshot-ai/protocol`'s `configResponseSchema` /
+ * **Wire fidelity**: reuses the local `protocol/rest-config` `configResponseSchema` /
  * `patchConfigRequestSchema` verbatim, so the request/response shape is
  * byte-for-byte compatible with v1's `routes/config.ts`. v2's `IConfigService`
  * is a per-domain registry (`get(domain)` / `set(domain, patch)`) and does not
@@ -27,15 +27,13 @@
  */
 
 import { IConfigService, IEventService, type Scope } from '@moonshot-ai/agent-core-v2';
-import {
-  configResponseSchema,
-  ErrorCode,
-  patchConfigRequestSchema,
-} from '@moonshot-ai/protocol';
-import type { ConfigResponse } from '@moonshot-ai/protocol';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
+import { configResponseSchema, patchConfigRequestSchema } from '../protocol/rest-config';
+import type { ConfigResponse } from '../protocol/rest-config';
 
 type ProviderResponse = ConfigResponse['providers'][string];
 
@@ -103,16 +101,20 @@ export function registerConfigRoutes(app: ConfigRouteHost, core: Scope): void {
           await config.set(domain, camelPatch[domain]);
         }
         const response = toConfigResponse(config.getAll());
+        const changedFields = Object.keys(req.body as Record<string, unknown>);
         core.accessor.get(IEventService).publish({
           type: 'event.config.changed',
           payload: {
-            changedFields: Object.keys(req.body as Record<string, unknown>),
+            changedFields,
             config: response,
           },
         });
+        // Only the changed field *names* — values may carry secrets.
+        requestLog(req)?.info({ changedFields }, 'config updated');
         reply.send(okEnvelope(response, req.id));
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        requestLog(req)?.error({ err: error }, 'config update failed');
         reply.send(errEnvelope(ErrorCode.VALIDATION_FAILED, message, req.id));
       }
     },
diff --git a/packages/kap-server/src/routes/connections.ts b/packages/kap-server/src/routes/connections.ts
index d30ab24e8..5dabc6687 100644
--- a/packages/kap-server/src/routes/connections.ts
+++ b/packages/kap-server/src/routes/connections.ts
@@ -2,8 +2,8 @@
  * `GET /connections` route handler (v1 mirror).
  *
  * Lists the WebSocket clients currently attached to the server, projected onto
- * the v1 wire shape (`connectionsListResponseSchema` from
- * `@moonshot-ai/protocol`). Backed by the in-memory `IConnectionRegistry`.
+ * the v1 wire shape (`connectionsListResponseSchema` from the local
+ * `protocol/rest-connection`). Backed by the in-memory `IConnectionRegistry`.
  *
  * server-v2 serves two WebSocket endpoints, so this lists clients of both:
  *   - `/api/v1/ws` (v1 protocol) — `has_client_hello` reflects the v1
@@ -16,11 +16,10 @@
  * Read-only and infallible: it only snapshots the registry.
  */
 
-import { connectionsListResponseSchema } from '@moonshot-ai/protocol';
-
 import { okEnvelope } from '../envelope';
 import { defineRoute } from '../middleware/defineRoute';
 import { type IConnectionRegistry } from '../transport/ws/connectionRegistry';
+import { connectionsListResponseSchema } from '../protocol/rest-connection';
 
 interface ConnectionsRouteHost {
   get(
diff --git a/packages/kap-server/src/routes/files.ts b/packages/kap-server/src/routes/files.ts
index 909c4cb62..ff74e99ff 100644
--- a/packages/kap-server/src/routes/files.ts
+++ b/packages/kap-server/src/routes/files.ts
@@ -20,18 +20,18 @@ import {
   Error2,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
-import {
-  ErrorCode,
-  deleteFileParamSchema,
-  deleteFileResponseSchema,
-  errEnvelope,
-  getFileParamSchema,
-  okEnvelope,
-  uploadFileResponseSchema,
-} from '@moonshot-ai/protocol';
 import { z } from 'zod';
 
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
+import { errEnvelope, okEnvelope } from '../protocol/envelope';
+import {
+  deleteFileParamSchema,
+  deleteFileResponseSchema,
+  getFileParamSchema,
+  uploadFileResponseSchema,
+} from '../protocol/rest-file';
 
 interface FilesRouteHost {
   register(plugin: unknown, opts?: unknown): unknown;
@@ -129,7 +129,7 @@ export function registerFilesRoutes(app: FilesRouteHost, core: Scope): void {
             } catch {
               // best-effort cleanup of the truncated blob
             }
-            sendMappedError(reply as unknown as FilesReply, req.id, new Error2(
+            sendMappedError(reply as unknown as FilesReply, req, new Error2(
               ErrorCodes.FILE_TOO_LARGE,
               `upload size exceeds limit ${DEFAULT_MAX_UPLOAD_BYTES} bytes`,
             ));
@@ -137,10 +137,10 @@ export function registerFilesRoutes(app: FilesRouteHost, core: Scope): void {
           }
           reply.send(okEnvelope(meta, req.id));
         } catch (error) {
-          sendMappedError(reply as unknown as FilesReply, req.id, error);
+          sendMappedError(reply as unknown as FilesReply, req, error);
         }
       } catch (error) {
-        sendMappedError(reply as unknown as FilesReply, req.id, error);
+        sendMappedError(reply as unknown as FilesReply, req, error);
       }
     },
   );
@@ -194,7 +194,7 @@ export function registerFilesRoutes(app: FilesRouteHost, core: Scope): void {
         r.header('content-length', size).code(200);
         return r.send(file.stream()) as unknown as void;
       } catch (error) {
-        sendMappedError(reply as unknown as FilesReply, req.id, error);
+        sendMappedError(reply as unknown as FilesReply, req, error);
         return;
       }
     },
@@ -219,9 +219,10 @@ export function registerFilesRoutes(app: FilesRouteHost, core: Scope): void {
         const { file_id } = req.params;
         const store = core.accessor.get(IFileService);
         await store.delete(file_id);
+        requestLog(req)?.info({ file_id }, 'file deleted');
         reply.send(okEnvelope({ deleted: true as const }, req.id));
       } catch (error) {
-        sendMappedError(reply as unknown as FilesReply, req.id, error);
+        sendMappedError(reply as unknown as FilesReply, req, error);
       }
     },
   );
@@ -232,7 +233,8 @@ export function registerFilesRoutes(app: FilesRouteHost, core: Scope): void {
   );
 }
 
-function sendMappedError(reply: FilesReply, requestId: string, err: unknown): void {
+function sendMappedError(reply: FilesReply, req: { id: string }, err: unknown): void {
+  const requestId = req.id;
   if (err instanceof Error2 && err.code === ErrorCodes.FILE_NOT_FOUND) {
     reply.code(404).send(errEnvelope(ErrorCode.FILE_NOT_FOUND, 'file not found', requestId));
     return;
@@ -250,6 +252,7 @@ function sendMappedError(reply: FilesReply, requestId: string, err: unknown): vo
     reply.code(413).send(errEnvelope(ErrorCode.FILE_TOO_LARGE, 'upload too large (>50MB)', requestId));
     return;
   }
+  requestLog(req)?.error({ err }, 'file request failed');
   reply
     .code(500)
     .send(
diff --git a/packages/kap-server/src/routes/fs.ts b/packages/kap-server/src/routes/fs.ts
index deb68b44c..bd3433217 100644
--- a/packages/kap-server/src/routes/fs.ts
+++ b/packages/kap-server/src/routes/fs.ts
@@ -5,7 +5,8 @@
  * so existing v1 clients keep working against server-v2. Backed by the v2
  * Session-scoped `ISessionFsService` (`agent-core-v2/src/sessionFs`): the route resolves
  * the session from the URL, then dispatches `fs:<action>` to the matching
- * `ISessionFsService` method. The wire schema is reused from `@moonshot-ai/protocol`.
+ * `ISessionFsService` method. The wire schema comes from the engine's own
+ * `sessionFs` domain contract (`agent-core-v2`).
  */
 
 import { createReadStream } from 'node:fs';
@@ -19,21 +20,17 @@ import {
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
 import {
-  ErrorCode,
   fsDiffRequestSchema,
   fsGitStatusRequestSchema,
   fsGrepRequestSchema,
   fsListManyRequestSchema,
   fsListRequestSchema,
   fsMkdirRequestSchema,
-  fsOpenInRequestSchema,
-  fsOpenRequestSchema,
   fsReadRequestSchema,
-  fsRevealRequestSchema,
   fsSearchRequestSchema,
   fsStatManyRequestSchema,
   fsStatRequestSchema,
-} from '@moonshot-ai/protocol';
+} from '@moonshot-ai/agent-core-v2/session/sessionFs/fs';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
@@ -43,7 +40,14 @@ import {
   openInAppCommandFor,
   revealFileCommandFor,
 } from '../lib/fileLaunch';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
+import {
+  fsOpenInRequestSchema,
+  fsOpenRequestSchema,
+  fsRevealRequestSchema,
+} from '../protocol/rest-fs';
 
 interface FsRouteHost {
   post(
@@ -200,7 +204,7 @@ export function registerFsRoutes(app: FsRouteHost, core: Scope): void {
             return;
         }
       } catch (err) {
-        sendMappedError(reply, req.id, err);
+        sendMappedError(reply, req, err);
       }
     },
   );
@@ -258,7 +262,7 @@ export function registerFsRoutes(app: FsRouteHost, core: Scope): void {
       try {
         resolved = await resolveFs(core, session_id).resolveDownload(relPath);
       } catch (err) {
-        sendMappedError(reply, req.id, err);
+        sendMappedError(reply, req, err);
         return;
       }
 
@@ -289,7 +293,11 @@ export function registerFsRoutes(app: FsRouteHost, core: Scope): void {
           start: range.start,
           end: range.end,
         });
-        stream.on('error', () => {
+        stream.on('error', (error: unknown) => {
+          requestLog(req)?.warn(
+            { session_id, path: relPath, err: error },
+            'fs download stream error',
+          );
           try {
             stream.destroy();
           } catch {
@@ -301,7 +309,11 @@ export function registerFsRoutes(app: FsRouteHost, core: Scope): void {
 
       r.code(200).header('content-length', String(resolved.size));
       const stream = createReadStream(resolved.absolute);
-      stream.on('error', () => {
+      stream.on('error', (error: unknown) => {
+        requestLog(req)?.warn(
+          { session_id, path: relPath, err: error },
+          'fs download stream error',
+        );
         try {
           stream.destroy();
         } catch {
@@ -463,6 +475,10 @@ async function handleOpenIn(core: Scope, sessionId: string, req: Req, reply: Rep
       }),
     );
   } catch (err) {
+    requestLog(req)?.warn(
+      { session_id: sessionId, app_id: body.app_id, err },
+      'fs open-in launch failed',
+    );
     reply.send(
       errEnvelope(
         ErrorCode.INTERNAL_ERROR,
@@ -479,7 +495,9 @@ async function handleOpenIn(core: Scope, sessionId: string, req: Req, reply: Rep
 // Error mapping — domain Error2 codes → protocol wire codes.
 // ---------------------------------------------------------------------------
 
-function sendMappedError(reply: Reply, requestId: string, err: unknown): void {
+function sendMappedError(reply: Reply, req: { id: string }, err: unknown): void {
+  const requestId = req.id;
+  const log = requestLog(req);
   if (isError2(err)) {
     switch (err.code) {
       case ErrorCodes.FS_PATH_ESCAPES:
@@ -530,6 +548,7 @@ function sendMappedError(reply: Reply, requestId: string, err: unknown): void {
         return;
     }
   }
+  log?.error({ err }, 'fs request failed');
   reply.send(
     errEnvelope(
       ErrorCode.INTERNAL_ERROR,
diff --git a/packages/kap-server/src/routes/guiStore.ts b/packages/kap-server/src/routes/guiStore.ts
index edb4e37cd..e00b15948 100644
--- a/packages/kap-server/src/routes/guiStore.ts
+++ b/packages/kap-server/src/routes/guiStore.ts
@@ -2,19 +2,19 @@
  * `/api/v1/gui/store/*` routes — server-backed localStorage mirror.
  */
 
-import {
-  ErrorCode,
-  guiStoreGetItemQuerySchema,
-  guiStoreGetItemResponseSchema,
-  guiStoreLengthResponseSchema,
-  guiStoreRemoveItemBodySchema,
-  guiStoreSetItemBodySchema,
-} from '@moonshot-ai/protocol';
 import { z } from 'zod';
 
 import { okEnvelope } from '../envelope';
 import { defineRoute } from '../middleware/defineRoute';
 import { IGuiStoreService } from '../services/guiStore/guiStore';
+import { ErrorCode } from '../protocol/error-codes';
+import {
+  guiStoreGetItemQuerySchema,
+  guiStoreGetItemResponseSchema,
+  guiStoreLengthResponseSchema,
+  guiStoreRemoveItemBodySchema,
+  guiStoreSetItemBodySchema,
+} from '../protocol/rest-guiStore';
 
 interface GuiStoreRouteHost {
   get(
diff --git a/packages/kap-server/src/routes/messages.ts b/packages/kap-server/src/routes/messages.ts
index cd8956d58..33339245f 100644
--- a/packages/kap-server/src/routes/messages.ts
+++ b/packages/kap-server/src/routes/messages.ts
@@ -18,15 +18,13 @@
  */
 
 import { IMessageLegacyService, isError2, type Scope } from '@moonshot-ai/agent-core-v2';
-import {
-  ErrorCode,
-  getMessageResponseSchema,
-  listMessagesResponseSchema,
-  messageRoleSchema,
-} from '@moonshot-ai/protocol';
+import { messageRoleSchema } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+import { ErrorCode } from '../protocol/error-codes';
+import { getMessageResponseSchema, listMessagesResponseSchema } from '../protocol/rest-message';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 
 interface MessageRouteHost {
@@ -102,7 +100,7 @@ export function registerMessagesRoutes(app: MessageRouteHost, core: Scope): void
         const page = await core.accessor.get(IMessageLegacyService).list(session_id, req.query);
         reply.send(okEnvelope(page, req.id));
       } catch (err) {
-        sendMappedError(reply, req.id, err);
+        sendMappedError(reply, req, err);
       }
     },
   );
@@ -133,7 +131,7 @@ export function registerMessagesRoutes(app: MessageRouteHost, core: Scope): void
         const message = await core.accessor.get(IMessageLegacyService).get(session_id, message_id);
         reply.send(okEnvelope(message, req.id));
       } catch (err) {
-        sendMappedError(reply, req.id, err);
+        sendMappedError(reply, req, err);
       }
     },
   );
@@ -152,9 +150,11 @@ export function registerMessagesRoutes(app: MessageRouteHost, core: Scope): void
  */
 function sendMappedError(
   reply: { send(payload: unknown): unknown },
-  requestId: string,
+  req: { id: string },
   err: unknown,
 ): void {
+  const requestId = req.id;
+  const log = requestLog(req);
   if (isError2(err)) {
     switch (err.code) {
       case 'session.not_found':
@@ -165,6 +165,7 @@ function sendMappedError(
         return;
     }
   }
+  log?.error({ err }, 'message request failed');
   reply.send(
     errEnvelope(ErrorCode.INTERNAL_ERROR, err instanceof Error ? err.message : String(err), requestId, err instanceof Error ? err.stack : undefined),
   );
diff --git a/packages/kap-server/src/routes/meta.ts b/packages/kap-server/src/routes/meta.ts
index 7a120af34..58f279914 100644
--- a/packages/kap-server/src/routes/meta.ts
+++ b/packages/kap-server/src/routes/meta.ts
@@ -14,11 +14,10 @@
  * **No DI**: pure server-self info; the payload is frozen at registration time.
  */
 
-import { metaResponseSchema } from '@moonshot-ai/protocol';
-import type { MetaResponse } from '@moonshot-ai/protocol';
-
 import { okEnvelope } from '../envelope';
 import { defineRoute } from '../middleware/defineRoute';
+import { metaResponseSchema } from '../protocol/rest-meta';
+import type { MetaResponse } from '../protocol/rest-meta';
 
 interface RouteHost {
   get(
diff --git a/packages/kap-server/src/routes/modelCatalog.ts b/packages/kap-server/src/routes/modelCatalog.ts
index 44530abc4..f25946f9f 100644
--- a/packages/kap-server/src/routes/modelCatalog.ts
+++ b/packages/kap-server/src/routes/modelCatalog.ts
@@ -12,7 +12,7 @@
  *   POST /providers:refresh_oauth      — refresh OAuth-backed provider models
  *   POST /providers/{tail} (:refresh)  — refresh a single provider by id
  *
- * **Wire fidelity**: reuses `@moonshot-ai/protocol`'s catalog schemas and the
+ * **Wire fidelity**: reuses agent-core-v2's catalog schemas and the local
  * numeric `ErrorCode` envelope verbatim, so the response shape and error codes
  * (`40412` provider-not-found, `40413` model-not-found, `40001` validation) are
  * byte-for-byte compatible with v1's `routes/modelCatalog.ts`. The v2 domain
@@ -28,17 +28,19 @@ import {
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
 import {
-  ErrorCode,
-  getProviderResponseSchema,
-  listModelsResponseSchema,
-  listProvidersResponseSchema,
   refreshProviderModelsResponseSchema,
   setDefaultModelResponseSchema,
-} from '@moonshot-ai/protocol';
+} from '@moonshot-ai/agent-core-v2/app/modelCatalog/modelCatalog';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
 import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
+import {
+  getProviderResponseSchema,
+  listModelsResponseSchema,
+  listProvidersResponseSchema,
+} from '../protocol/rest-modelCatalog';
 import { parseActionSuffix } from './action-suffix';
 
 interface ModelCatalogRouteHost {
diff --git a/packages/kap-server/src/routes/oauth.ts b/packages/kap-server/src/routes/oauth.ts
index 097aecd0d..774e06688 100644
--- a/packages/kap-server/src/routes/oauth.ts
+++ b/packages/kap-server/src/routes/oauth.ts
@@ -16,15 +16,18 @@ import {
   oauthFlowSnapshotSchema,
   oauthFlowStartSchema,
   oauthLoginCancelResponseSchema,
-  oauthLoginQuerySchema,
-  oauthLoginStartRequestSchema,
-  oauthLogoutRequestSchema,
   oauthLogoutResponseSchema,
-} from '@moonshot-ai/protocol';
+} from '@moonshot-ai/agent-core-v2/app/auth/oauthProtocol';
 import { z } from 'zod';
 
 import { okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
+import {
+  oauthLoginQuerySchema,
+  oauthLoginStartRequestSchema,
+  oauthLogoutRequestSchema,
+} from '../protocol/rest-oauth';
 
 interface RouteHost {
   get(
@@ -71,6 +74,7 @@ export function registerOAuthRoutes(app: RouteHost, core: Scope): void {
     },
     async (req, reply) => {
       const result = await core.accessor.get(IOAuthService).startLogin(req.body.provider);
+      requestLog(req)?.info({ provider: req.body.provider, action: 'login' }, 'oauth login started');
       reply.send(okEnvelope(result, req.id));
     },
   );
@@ -113,6 +117,10 @@ export function registerOAuthRoutes(app: RouteHost, core: Scope): void {
     },
     async (req, reply) => {
       const result = await core.accessor.get(IOAuthService).cancelLogin(req.query.provider);
+      requestLog(req)?.info(
+        { provider: req.query.provider, action: 'cancel_login' },
+        'oauth login cancelled',
+      );
       reply.send(okEnvelope(result, req.id));
     },
   );
@@ -134,6 +142,7 @@ export function registerOAuthRoutes(app: RouteHost, core: Scope): void {
     },
     async (req, reply) => {
       const result = await core.accessor.get(IOAuthService).logout(req.body.provider);
+      requestLog(req)?.info({ provider: req.body.provider, action: 'logout' }, 'oauth logout');
       reply.send(okEnvelope(result, req.id));
     },
   );
diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 2f7565281..1cddd845f 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -5,8 +5,9 @@
  * shapes from `packages/server/src/routes/prompts.ts`.
  */
 
+import { createHash } from 'node:crypto';
 import { createWriteStream } from 'node:fs';
-import { mkdir, stat } from 'node:fs/promises';
+import { mkdir, stat, writeFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 
@@ -46,8 +47,8 @@ import {
   type ISessionScopeHandle,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
+import { ErrorCode } from '../protocol/error-codes';
 import {
-  ErrorCode,
   promptAbortResponseSchema,
   promptListResponseSchema,
   promptSteerRequestSchema,
@@ -55,10 +56,11 @@ import {
   promptSubmissionSchema,
   promptSubmitResultSchema,
   type PromptSubmission,
-} from '@moonshot-ai/protocol';
+} from '../protocol/rest-prompt';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 import { ensureMainAgent, MAIN_AGENT_ID } from '../transport/mainAgent';
 import { parseActionSuffix } from './action-suffix';
@@ -152,7 +154,7 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         const result = projectPromptList((await resolvePrompt(core, session_id)).prompt.list());
         reply.send(okEnvelope(result, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -193,6 +195,11 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
               if (session === undefined) return undefined;
               return sessionMediaOriginalsDir(session.accessor.get(ISessionContext).sessionDir);
             },
+            resolveAttachmentsDir: async () => {
+              const session = await core.accessor.get(ISessionLifecycleService).resume(session_id);
+              if (session === undefined) return undefined;
+              return join(session.accessor.get(ISessionContext).sessionDir, 'attachments');
+            },
           },
         );
         const resolved = await resolvePrompt(core, session_id, resolvedBody.agent_id);
@@ -215,7 +222,7 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         } });
         reply.send(okEnvelope(projectPromptHandle(handle), req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -244,7 +251,7 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         await resolved.prompt.steer(req.body.prompt_ids);
         reply.send(okEnvelope({ steered: true, prompt_ids: [...req.body.prompt_ids] }, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -281,13 +288,14 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         const resolved = await resolvePrompt(core, session_id);
         if (parsed.action === 'abort') {
           resolved.prompt.abort(parsed.id);
+          requestLog(req)?.info({ session_id, prompt_id: parsed.id }, 'prompt aborted');
           reply.send(okEnvelope({ aborted: true }, req.id));
         } else {
           await resolved.prompt.steer([parsed.id]);
           reply.send(okEnvelope({ steered: true, prompt_ids: [parsed.id] }, req.id));
         }
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -357,6 +365,13 @@ interface ResolvePromptMediaOptions {
    * shared temp-dir cache.
    */
   readonly resolveOriginalsDir?: () => Promise<string | undefined>;
+  /**
+   * Lazily resolve the session's attachments dir for materializing arbitrary
+   * file uploads (and image bytes the provider rejects) into a path the model
+   * can open with the Read tool. A failure or undefined result falls back to
+   * the shared cache dir.
+   */
+  readonly resolveAttachmentsDir?: () => Promise<string | undefined>;
   /** Report an `image_compress` event per compressed prompt image. */
   readonly telemetry?: ITelemetryService;
 }
@@ -377,6 +392,15 @@ async function resolvePromptMediaFiles(
     }
     return originalsDir;
   };
+  let attachmentsDir: string | undefined;
+  let attachmentsDirResolved = false;
+  const resolveAttachmentsDir = async (): Promise<string> => {
+    if (!attachmentsDirResolved) {
+      attachmentsDirResolved = true;
+      attachmentsDir = await options.resolveAttachmentsDir?.().catch(() => undefined);
+    }
+    return attachmentsDir ?? cacheDir;
+  };
   const telemetryFor = (source: string): ImageCompressionTelemetry | undefined =>
     options.telemetry === undefined ? undefined : { client: options.telemetry, source };
   const content: PromptSubmission['content'] = [];
@@ -387,14 +411,30 @@ async function resolvePromptMediaFiles(
       // Formats the provider cannot accept must never enter the session
       // history — one unsupported image_url makes every later request fail.
       // The bytes are authoritative: an image labeled image/png that is
-      // actually AVIF is gated on the sniffed format, not the label. Drop
-      // the image; a notice stands in so the model knows what happened.
+      // actually AVIF is gated on the sniffed format, not the label. The
+      // bytes are still the user's content, though: persist them as a
+      // path-referenced attachment so the model can read and convert them
+      // itself (best effort — the plain notice stands in when persisting
+      // fails). Inline base64 has no original name, so the file is addressed
+      // by content hash with a name derived from the sniffed format.
       const effectiveMime = resolveEffectiveImageMime(
         part.source.media_type,
         decodeBase64Prefix(part.source.data),
       );
       if (!isModelAcceptedImageMime(effectiveMime)) {
-        content.push({ type: 'text', text: buildUnsupportedImageNotice(effectiveMime) });
+        const bytes = Buffer.from(part.source.data, 'base64');
+        const name = `image.${imageExtensionForMime(effectiveMime)}`;
+        const persisted = await persistAttachmentBytes(
+          bytes,
+          `${createHash('sha256').update(bytes).digest('hex').slice(0, 32)}-${name}`,
+          await resolveAttachmentsDir(),
+        );
+        content.push({
+          type: 'text',
+          text: persisted === null
+            ? buildUnsupportedImageNotice(effectiveMime)
+            : buildAttachedFileNotice(name, effectiveMime, bytes.length, persisted),
+        });
         changed = true;
         continue;
       }
@@ -454,6 +494,20 @@ async function resolvePromptMediaFiles(
       continue;
     }
 
+    // Arbitrary file attachment: materialize the uploaded bytes next to the
+    // session and replace the part with a path reference — the model opens it
+    // with the Read tool instead of receiving it as a media part.
+    if (part.type === 'file') {
+      const file = await store.get(part.file_id);
+      const attachedPath = await materializeAttachmentToDir(file, await resolveAttachmentsDir());
+      content.push({
+        type: 'text',
+        text: buildAttachedFileNotice(file.meta.name, file.meta.media_type, file.meta.size, attachedPath),
+      });
+      changed = true;
+      continue;
+    }
+
     if ((part.type !== 'image' && part.type !== 'video') || part.source.kind !== 'file') {
       content.push(part);
       continue;
@@ -467,10 +521,23 @@ async function resolvePromptMediaFiles(
       let bytes: Uint8Array = data;
       // Same format gate as the inline path above, and again the bytes are
       // authoritative: an upload whose Content-Type lies (AVIF bytes sent
-      // as image/png) becomes a notice instead of an image part.
+      // as image/png) is gated on the sniffed format. Like the inline path,
+      // keep the bytes as a path-referenced attachment instead of dropping
+      // them (best effort — the plain notice stands in when persisting
+      // fails).
       mediaType = resolveEffectiveImageMime(mediaType, data);
       if (!isModelAcceptedImageMime(mediaType)) {
-        content.push({ type: 'text', text: buildUnsupportedImageNotice(mediaType, file.meta.name) });
+        const persisted = await persistAttachmentBytes(
+          data,
+          `${file.meta.id}-${sanitizeAttachmentName(file.meta.name)}`,
+          await resolveAttachmentsDir(),
+        );
+        content.push({
+          type: 'text',
+          text: persisted === null
+            ? buildUnsupportedImageNotice(mediaType, file.meta.name)
+            : buildAttachedFileNotice(file.meta.name, mediaType, file.meta.size, persisted),
+        });
         changed = true;
         continue;
       }
@@ -534,6 +601,70 @@ async function materializeVideoToCache(file: GetResult, cacheDir: string): Promi
   return target;
 }
 
+const ATTACHMENT_NAME_MAX = 100;
+
+/**
+ * Attachment file names are untrusted (the multipart filename / a wire field):
+ * strip path separators, control chars, and leading dots so the materialized
+ * file can never escape its directory or land as a hidden file, and cap the
+ * length so the path stays manageable.
+ */
+function sanitizeAttachmentName(name: string): string {
+  const cleaned = name
+    .replaceAll(/[\\/]/g, '_')
+    .replaceAll(/[\u0000-\u001F\u007F]/g, '')
+    .replace(/^\.+/, '')
+    .trim()
+    .slice(0, ATTACHMENT_NAME_MAX);
+  return cleaned.length > 0 ? cleaned : 'attachment';
+}
+
+/** Stream an uploaded file into `dir` as `<fileId>-<sanitized name>`. */
+async function materializeAttachmentToDir(file: GetResult, dir: string): Promise<string> {
+  await mkdir(dir, { recursive: true });
+  const target = join(dir, `${file.meta.id}-${sanitizeAttachmentName(file.meta.name)}`);
+  const info = await stat(target).catch(() => undefined);
+  if (info?.size === file.meta.size) return target;
+
+  await pipeline(file.stream(), createWriteStream(target));
+  return target;
+}
+
+/**
+ * Write already-buffered attachment bytes into `dir` under `name` (the caller
+ * builds the name: file-id or content-hash prefixed). Best effort — returns
+ * null instead of throwing so a prompt never fails over the persisted copy.
+ */
+async function persistAttachmentBytes(
+  bytes: Uint8Array,
+  name: string,
+  dir: string,
+): Promise<string | null> {
+  try {
+    await mkdir(dir, { recursive: true });
+    const target = join(dir, name);
+    const info = await stat(target).catch(() => undefined);
+    if (info?.size !== bytes.length) await writeFile(target, bytes);
+    return target;
+  } catch {
+    return null;
+  }
+}
+
+/** Derive a file extension from an image MIME (`image/svg+xml` → `svg`). */
+function imageExtensionForMime(mediaType: string): string {
+  const subtype = mediaType.split('/')[1]?.toLowerCase().split('+')[0] ?? '';
+  const ext = subtype.replaceAll(/[^a-z0-9-]/g, '');
+  return ext.length > 0 ? ext : 'img';
+}
+
+// This notice's exact shape is a client contract: kimi-web's messagesToTurns
+// parses it (ATTACHED_FILE_NOTICE_RE) to rebuild the attachment chip after a
+// resync — change the wording there too.
+function buildAttachedFileNotice(name: string, mediaType: string, size: number, path: string): string {
+  return `Attached file "${name}" (${mediaType}, ${size} bytes): ${path} — open it with the Read tool`;
+}
+
 async function readFileOrStream(file: GetResult): Promise<Buffer> {
   const chunks: Buffer[] = [];
   for await (const chunk of file.stream()) {
@@ -561,9 +692,11 @@ function escapeAttribute(value: string): string {
 
 function sendMappedError(
   reply: { send(payload: unknown): unknown },
-  requestId: string,
+  req: { id: string },
   err: unknown,
 ): void {
+  const requestId = req.id;
+  const log = requestLog(req);
   if (isError2(err)) {
     switch (err.code) {
       case 'session.not_found':
@@ -605,6 +738,7 @@ function sendMappedError(
       case 'auth.token_missing': {
         const details = authProviderDetails(err);
         if (details === undefined) {
+          log?.error({ err }, 'prompt request failed');
           reply.send(
             errEnvelope(
               ErrorCode.INTERNAL_ERROR,
@@ -627,6 +761,7 @@ function sendMappedError(
       case 'auth.token_unauthorized': {
         const details = authProviderDetails(err);
         if (details === undefined) {
+          log?.error({ err }, 'prompt request failed');
           reply.send(
             errEnvelope(
               ErrorCode.INTERNAL_ERROR,
@@ -658,6 +793,7 @@ function sendMappedError(
         return;
     }
   }
+  log?.error({ err }, 'prompt request failed');
   reply.send(
     errEnvelope(
       ErrorCode.INTERNAL_ERROR,
diff --git a/packages/kap-server/src/routes/questions.ts b/packages/kap-server/src/routes/questions.ts
index 5be404885..1ba3ef413 100644
--- a/packages/kap-server/src/routes/questions.ts
+++ b/packages/kap-server/src/routes/questions.ts
@@ -53,22 +53,25 @@ import {
   type QuestionResult,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
+import { ErrorCode } from '../protocol/error-codes';
 import {
-  ErrorCode,
-  listPendingQuestionsQuerySchema,
-  listPendingQuestionsResponseSchema,
   type QuestionItem as ProtocolQuestionItem,
   type QuestionOption as ProtocolQuestionOption,
   type QuestionRequest as ProtocolQuestionRequest,
   type QuestionResponse as ProtocolQuestionResponse,
+} from '../protocol/question';
+import {
+  listPendingQuestionsQuerySchema,
+  listPendingQuestionsResponseSchema,
   questionAlreadyResolvedDataSchema,
   questionDismissResultSchema,
   questionResolveRequestSchema,
   questionResolveResultSchema,
-} from '@moonshot-ai/protocol';
+} from '../protocol/rest-question';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 import { parseActionSuffix } from './action-suffix';
 
@@ -201,6 +204,10 @@ export function registerQuestionsRoutes(app: QuestionRouteHost, core: Scope): vo
 
       if (action === 'dismiss') {
         questions.dismiss(questionId);
+        requestLog(req)?.info(
+          { session_id, question_id: questionId, action: 'dismiss' },
+          'question dismissed',
+        );
         reply.send({
           code: ErrorCode.QUESTION_DISMISSED, // 40909
           msg: `question ${questionId} dismissed`,
@@ -243,6 +250,10 @@ export function registerQuestionsRoutes(app: QuestionRouteHost, core: Scope): vo
         toWireQuestion(pendingInteraction, session_id),
       );
       questions.answer(questionId, result);
+      requestLog(req)?.info(
+        { session_id, question_id: questionId, action: 'answer' },
+        'question answered',
+      );
       reply.send(
         okEnvelope({ resolved: true as const, resolved_at: new Date().toISOString() }, req.id),
       );
diff --git a/packages/kap-server/src/routes/sessionExport.ts b/packages/kap-server/src/routes/sessionExport.ts
index ea10a2832..800766ffa 100644
--- a/packages/kap-server/src/routes/sessionExport.ts
+++ b/packages/kap-server/src/routes/sessionExport.ts
@@ -18,14 +18,15 @@ import {
   isError2,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
+
+import { requestLog } from '../lib/requestLog';
+import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
+import { errEnvelope } from '../protocol/envelope';
 import {
-  ErrorCode,
-  errEnvelope,
   exportSessionParamsSchema,
   exportSessionRequestSchema,
-} from '@moonshot-ai/protocol';
-
-import { defineRoute } from '../middleware/defineRoute';
+} from '../protocol/rest-session';
 
 const MAX_WEB_SESSION_EXPORT_BYTES = 64 * 1024 * 1024;
 
@@ -166,7 +167,7 @@ export function registerSessionExportRoute(
           stream?.destroy();
         }
         await cleanup();
-        if (!aborted) sendMappedError(response, req.id, error);
+        if (!aborted) sendMappedError(response, req, error);
       } finally {
         if (!streaming) response.raw.off('close', onResponseClose);
       }
@@ -184,7 +185,8 @@ function sanitizeSessionId(sessionId: string): string {
   return sessionId.replaceAll(/[^A-Za-z0-9_-]/g, '_').slice(0, 48) || 'session';
 }
 
-function sendMappedError(reply: SessionExportReply, requestId: string, error: unknown): void {
+function sendMappedError(reply: SessionExportReply, req: { id: string }, error: unknown): void {
+  const requestId = req.id;
   if (isError2(error)) {
     if (error.code === ErrorCodes.SESSION_NOT_FOUND) {
       reply.send(errEnvelope(ErrorCode.SESSION_NOT_FOUND, error.message, requestId));
@@ -201,6 +203,7 @@ function sendMappedError(reply: SessionExportReply, requestId: string, error: un
       return;
     }
   }
+  requestLog(req)?.error({ err: error }, 'session export failed');
   reply.send(
     errEnvelope(
       ErrorCode.INTERNAL_ERROR,
diff --git a/packages/kap-server/src/routes/sessions.ts b/packages/kap-server/src/routes/sessions.ts
index 51326c7db..03e4a3ce8 100644
--- a/packages/kap-server/src/routes/sessions.ts
+++ b/packages/kap-server/src/routes/sessions.ts
@@ -50,16 +50,17 @@
  * from `ISessionIndex` (with `cwd` persisted on the session itself), and now
  * also surfaces `last_prompt` and the merged custom `metadata`.
  *
- * **Status**: v1's `SessionService` overwrites the placeholder `status` with the
- * live value before projecting (`_patchSessionStatus`). v2 does the same:
- * `toWireSession` takes the live `ISessionActivity.status()` resolved from the
- * session's scope (or `'idle'` when the session is cold), so the wire `status`
- * is real on every session-producing endpoint here. `GET /sessions` and
- * `GET /sessions/{id}/children` filter their projected page by the `status`
+ * **Busy / last turn**: v1's `SessionService` overwrites the placeholder
+ * `status` with the live value before projecting (`_patchSessionStatus`). v2
+ * projects the orthogonal facts instead: `toWireSession` takes
+ * `resolveSessionFacts` — `busy` from the session lifecycle's authoritative
+ * drain registry and `last_turn_reason` from the main agent's activity view (a
+ * cold session is not busy and carries no reason) — so both are real on every
+ * session-producing endpoint here. `GET /sessions` and
+ * `GET /sessions/{id}/children` filter their projected page by the `busy`
  * query param (post-page, matching v1 — `has_more` reflects the pre-filter
- * page), except `archived_only` lists filter status before route pagination so
- * they can drain archived pages the same way v1 does. The `aborted` phase is not
- * derived yet (gap G10); v2 never reports it.
+ * page), except `archived_only` lists filter busy before route pagination so
+ * they can drain archived pages the same way v1 does.
  *
  * **cwd resolution (gap G3 closed)**: the session's frozen work dir is
  * persisted on its metadata document (`ISessionMetadata`) and surfaced on the
@@ -76,12 +77,14 @@ import {
   IAgentProfileService,
   IAgentPromptService,
   IAgentFullCompactionService,
+  IAgentLifecycleService,
   IAgentRPCService,
+  IAgentActivityView,
   IAuthSummaryService,
   ISessionBtwService,
-  ISessionActivity,
   ISessionContext,
   ISessionIndex,
+  ISessionInteractionService,
   ISessionLifecycleService,
   ISessionMetadata,
   ISessionLegacyService,
@@ -94,35 +97,38 @@ import {
   type IAgentScopeHandle,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
+import { ErrorCode } from '../protocol/error-codes';
+import { pageResponseSchema } from '../protocol/pagination';
 import {
-  ErrorCode,
   archiveSessionResponseSchema,
   compactSessionRequestSchema,
   compactSessionResponseSchema,
   createSessionChildRequestSchema,
   createSessionRequestSchema,
-  emptySessionUsage,
   forkSessionRequestSchema,
   getSessionGoalResponseSchema,
   listSessionChildrenResponseSchema,
-  pageResponseSchema,
   sessionAbortResponseSchema,
-  sessionSchema,
   sessionStatusResponseSchema,
-  sessionStatusSchema,
   sessionWarningsResponseSchema,
   startBtwSessionResponseSchema,
   undoSessionRequestSchema,
   undoSessionResponseSchema,
   updateSessionProfileRequestSchema,
-  workspaceIdSchema,
-} from '@moonshot-ai/protocol';
-import type { Session, SessionStatus } from '@moonshot-ai/protocol';
+} from '../protocol/rest-session';
+import {
+  emptySessionUsage,
+  sessionSchema,
+  type Session,
+  type SessionPendingInteraction,
+} from '../protocol/session';
+import { workspaceIdSchema } from '../protocol/workspace';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
-import { ensureMainAgent } from '../transport/mainAgent';
+import { ensureMainAgent, MAIN_AGENT_ID } from '../transport/mainAgent';
 import { parseActionSuffix } from './action-suffix';
 
 interface SessionRouteHost {
@@ -164,7 +170,7 @@ const sessionsListQueryCoercion = z
     before_id: z.string().min(1).optional(),
     after_id: z.string().min(1).optional(),
     page_size: z.coerce.number().int().min(1).max(100).optional(),
-    status: sessionStatusSchema.optional(),
+    busy: booleanQueryParam,
     include_archive: booleanQueryParam,
     exclude_empty: booleanQueryParam,
     archived_only: booleanQueryParam,
@@ -193,16 +199,16 @@ const sessionIdParamSchema = z.object({
   session_id: z.string().min(1),
 });
 
-// Mirrors v1's children query: id-cursors + page_size + status. The route
-// projects the live `ISessionActivity.status()` onto each child and filters the
-// page by `status` (post-page, matching v1); the child-marker filtering lives in
-// `ISessionIndex.list({ childOf })`, the status filter stays at the edge.
+// Mirrors v1's children query: id-cursors + page_size + busy. The route
+// projects the live busy fact onto each child and filters the page by it
+// (post-page, matching v1); the child-marker filtering lives in
+// `ISessionIndex.list({ childOf })`, the busy filter stays at the edge.
 const sessionChildrenListQueryCoercion = z
   .object({
     before_id: z.string().min(1).optional(),
     after_id: z.string().min(1).optional(),
     page_size: z.coerce.number().int().min(1).max(100).optional(),
-    status: sessionStatusSchema.optional(),
+    busy: booleanQueryParam,
   })
   .superRefine((value, ctx) => {
     if (value.before_id !== undefined && value.after_id !== undefined) {
@@ -314,7 +320,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         const session = toWireSession(
           { ...meta, workspaceId: touched.id },
           touched.root,
-          handle.accessor.get(ISessionActivity).status(),
+          { busy: false, mainTurnActive: false, pendingInteraction: 'none' },
         );
         core.accessor.get(IEventService).publish({
           type: 'event.session.created',
@@ -322,7 +328,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         });
         reply.send(okEnvelope(session, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -386,7 +392,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
       const eligible: {
         readonly summary: (typeof page.items)[number];
         readonly cwd: string;
-        readonly status?: Session['status'];
+        readonly facts?: SessionFacts;
       }[] = [];
       for (const summary of page.items) {
         const cwd = summary.cwd ?? roots.get(summary.workspaceId);
@@ -416,12 +422,12 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
       let visible = window;
       if (archivedOnly) {
         visible =
-          raw.status === undefined
+          raw.busy === undefined
             ? window.filter((entry) => entry.summary.archived === true)
             : window.flatMap((entry) => {
                 if (entry.summary.archived !== true) return [];
-                const status = resolveSessionStatus(core, entry.summary.id);
-                return status === raw.status ? [{ ...entry, status }] : [];
+                const facts = resolveSessionFacts(core, entry.summary.id);
+                return facts.busy === raw.busy ? [{ ...entry, facts }] : [];
               });
       }
       const limit = archivedOnly
@@ -430,14 +436,14 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
       const hasMore = visible.length > limit;
       const projected: Session[] = visible
         .slice(0, limit)
-        .map(({ summary, cwd, status }) =>
-          toWireSession(summary, cwd, status ?? resolveSessionStatus(core, summary.id)),
+        .map(({ summary, cwd, facts }) =>
+          toWireSession(summary, cwd, facts ?? resolveSessionFacts(core, summary.id)),
         );
-      // v1 filters ordinary lists by `status` post-page; `archived_only` already
-      // applied status before pagination above so it can drain to a full page.
+      // v1 filters ordinary lists by the busy fact post-page; `archived_only`
+      // already applied it before pagination above so it can drain to a full page.
       const items =
-        raw.status !== undefined && !archivedOnly
-          ? projected.filter((session) => session.status === raw.status)
+        raw.busy !== undefined && !archivedOnly
+          ? projected.filter((session) => session.busy === raw.busy)
           : projected;
       reply.send(okEnvelope({ items, has_more: hasMore }, req.id));
     },
@@ -485,7 +491,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         return;
       }
       reply.send(
-        okEnvelope(toWireSession(summary, cwd, resolveSessionStatus(core, session_id)), req.id),
+        okEnvelope(toWireSession(summary, cwd, resolveSessionFacts(core, session_id)), req.id),
       );
     },
   );
@@ -530,7 +536,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         return;
       }
       reply.send(
-        okEnvelope(toWireSession(summary, cwd, resolveSessionStatus(core, session_id)), req.id),
+        okEnvelope(toWireSession(summary, cwd, resolveSessionFacts(core, session_id)), req.id),
       );
     },
   );
@@ -560,7 +566,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         const fields = await core.accessor
           .get(ISessionLegacyService)
           .updateProfile(session_id, req.body);
-        const session = toWireSession(fields, fields.root, resolveSessionStatus(core, fields.id));
+        const session = toWireSession(fields, fields.root, resolveSessionFacts(core, fields.id));
         // Broadcast the title change to every connection (including clients not
         // subscribed to this session, and covering inactive sessions), so session
         // lists stay in sync — mirrors v1's `session.meta.updated` publish.
@@ -577,7 +583,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         }
         reply.send(okEnvelope(session, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -644,12 +650,16 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
           const session = toWireSession(
             { ...meta, workspaceId: ctx.workspaceId },
             ctx.cwd,
-            resolveSessionStatus(core, meta.id),
+            resolveSessionFacts(core, meta.id),
           );
           core.accessor.get(IEventService).publish({
             type: 'event.session.created',
             payload: { agentId: 'main', sessionId: session.id, session },
           });
+          requestLog(req)?.info(
+            { session_id: parsed.id, action: 'fork', new_session_id: session.id },
+            'session action completed',
+          );
           reply.send(okEnvelope(session, req.id));
           return;
         }
@@ -663,6 +673,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
           agent.accessor
             .get(IAgentFullCompactionService)
             .begin({ source: 'manual', instruction: normalizeOptional(body.instruction) });
+          requestLog(req)?.info({ session_id: parsed.id, action: 'compact' }, 'session action completed');
           reply.send(okEnvelope({}, req.id));
           return;
         }
@@ -677,6 +688,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
           // (cross-domain) and is reused here verbatim.
           agent.accessor.get(IAgentPromptService).undo(body.count);
           const history = agent.accessor.get(IAgentContextMemoryService).get();
+          requestLog(req)?.info({ session_id: parsed.id, action: 'undo' }, 'session action completed');
           const [summary, status] = await Promise.all([
             core.accessor.get(ISessionIndex).get(parsed.id),
             legacy.status(parsed.id),
@@ -703,6 +715,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
           // No turnId → cancel whatever turn is active; a safe no-op when idle.
           // v1 always reports success once the session exists.
           await agent.accessor.get(IAgentRPCService).cancel({});
+          requestLog(req)?.info({ session_id: parsed.id, action: 'abort' }, 'session action completed');
           reply.send(okEnvelope({ aborted: true }, req.id));
           return;
         }
@@ -733,8 +746,9 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
           const session = toWireSession(
             { ...meta, workspaceId: ctx.workspaceId },
             ctx.cwd,
-            resolveSessionStatus(core, meta.id),
+            resolveSessionFacts(core, meta.id),
           );
+          requestLog(req)?.info({ session_id: parsed.id, action: 'restore' }, 'session action completed');
           reply.send(okEnvelope(session, req.id));
           return;
         }
@@ -747,9 +761,10 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
           throw new Error2(ErrorCodes.SESSION_NOT_FOUND, `session ${parsed.id} does not exist`);
         }
         await core.accessor.get(ISessionLifecycleService).archive(parsed.id);
+        requestLog(req)?.info({ session_id: parsed.id, action: 'archive' }, 'session action completed');
         reply.send(okEnvelope({ archived: true }, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -821,18 +836,18 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
           toWireSession(
             summary,
             summary.cwd ?? roots.get(summary.workspaceId) ?? '',
-            resolveSessionStatus(core, summary.id),
+            resolveSessionFacts(core, summary.id),
           ),
         );
-        // v1 filters the projected page by `status` (post-page); `has_more`
+        // v1 filters the projected page by the busy fact (post-page); `has_more`
         // reflects the pre-filter page.
         const items =
-          req.query.status !== undefined
-            ? projected.filter((session) => session.status === req.query.status)
+          req.query.busy !== undefined
+            ? projected.filter((session) => session.busy === req.query.busy)
             : projected;
         reply.send(okEnvelope({ items, has_more: slice.length > pageSize }, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -874,7 +889,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         const session = toWireSession(
           { ...meta, workspaceId: ctx.workspaceId },
           ctx.cwd,
-          resolveSessionStatus(core, meta.id),
+          resolveSessionFacts(core, meta.id),
         );
         core.accessor.get(IEventService).publish({
           type: 'event.session.created',
@@ -882,7 +897,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         });
         reply.send(okEnvelope(session, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -911,7 +926,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         const status = await core.accessor.get(ISessionLegacyService).status(session_id);
         reply.send(okEnvelope(status, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -940,7 +955,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
         const goal = await core.accessor.get(ISessionLegacyService).goal(session_id);
         reply.send(okEnvelope(goal, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -993,7 +1008,7 @@ export function registerSessionsRoutes(app: SessionRouteHost, core: Scope): void
               ];
         reply.send(okEnvelope({ warnings }, req.id));
       } catch (error) {
-        sendMappedError(reply, req.id, error);
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -1024,7 +1039,7 @@ export interface SessionWireFields {
 export function toWireSession(
   fields: SessionWireFields,
   cwd: string,
-  status: SessionStatus,
+  facts: SessionFacts,
 ): Session {
   return {
     id: fields.id,
@@ -1032,7 +1047,10 @@ export function toWireSession(
     title: fields.title ?? '',
     created_at: new Date(fields.createdAt).toISOString(),
     updated_at: new Date(fields.updatedAt).toISOString(),
-    status,
+    busy: facts.busy,
+    main_turn_active: facts.mainTurnActive,
+    pending_interaction: facts.pendingInteraction,
+    last_turn_reason: facts.lastTurnReason,
     archived: fields.archived,
     last_prompt: fields.lastPrompt,
     metadata: buildWireMetadata(fields.custom, cwd),
@@ -1044,17 +1062,57 @@ export function toWireSession(
   };
 }
 
+/** Live activity and interaction facts projected onto the wire `Session`. */
+export interface SessionFacts {
+  readonly busy: boolean;
+  readonly mainTurnActive: boolean;
+  readonly pendingInteraction: SessionPendingInteraction;
+  readonly lastTurnReason?: 'completed' | 'cancelled' | 'failed';
+}
+
 /**
- * Resolve a session's live wire `status`. Mirrors v1's
- * `SessionService._patchSessionStatus`: the live `ISessionActivity.status()`
- * wins, and a cold session (no live handle) reports `'idle'` — it carries no
- * pending approval/question and no active turn. The `aborted` phase is not
- * derived in v2 yet (gap G10), so it is never returned here.
+ * Resolve a session's live wire facts, derived on demand from the agents'
+ * activity views: `busy` = any agent with an active turn or background task;
+ * the reason is the main agent's latest turn outcome (`blocked` folds into
+ * `failed`). Nothing is booked at session level — a cold session (no live
+ * handle) is not busy and carries no outcome.
  */
-function resolveSessionStatus(core: Scope, sessionId: string): SessionStatus {
+export function resolveSessionFacts(core: Scope, sessionId: string): SessionFacts {
   const handle = core.accessor.get(ISessionLifecycleService).get(sessionId);
-  if (handle === undefined) return 'idle';
-  return handle.accessor.get(ISessionActivity).status();
+  if (handle === undefined) {
+    return {
+      busy: false,
+      mainTurnActive: false,
+      pendingInteraction: 'none',
+    };
+  }
+  const agents = handle.accessor.get(IAgentLifecycleService);
+  const mainActivity = agents.get(MAIN_AGENT_ID)?.accessor.get(IAgentActivityView).state();
+  const interactions = handle.accessor.get(ISessionInteractionService);
+  let busy = false;
+  for (const agent of agents.list()) {
+    const state = agent.accessor.get(IAgentActivityView).state();
+    if (state.turn !== undefined || state.background.length > 0) {
+      busy = true;
+      break;
+    }
+  }
+  const reason = mainActivity?.lastTurn?.reason;
+  const pendingInteraction = resolvePendingInteraction(interactions);
+  return {
+    busy,
+    mainTurnActive: mainActivity?.turn !== undefined,
+    pendingInteraction,
+    lastTurnReason: reason === 'blocked' ? 'failed' : reason,
+  };
+}
+
+function resolvePendingInteraction(
+  interactions: ISessionInteractionService,
+): SessionPendingInteraction {
+  if (interactions.listPending('approval').length > 0) return 'approval';
+  if (interactions.listPending('question').length > 0) return 'question';
+  return 'none';
 }
 
 /**
@@ -1149,9 +1207,11 @@ function buildValidationEnvelope(
 
 function sendMappedError(
   reply: { send(payload: unknown): unknown },
-  requestId: string,
+  req: { id: string },
   err: unknown,
 ): void {
+  const requestId = req.id;
+  const log = requestLog(req);
   if (isError2(err)) {
     switch (err.code) {
       case 'session.not_found':
@@ -1202,6 +1262,7 @@ function sendMappedError(
         return;
     }
   }
+  log?.error({ err }, 'session request failed');
   reply.send(
     errEnvelope(
       ErrorCode.INTERNAL_ERROR,
diff --git a/packages/kap-server/src/routes/shutdown.ts b/packages/kap-server/src/routes/shutdown.ts
index b63c75016..6eb77a493 100644
--- a/packages/kap-server/src/routes/shutdown.ts
+++ b/packages/kap-server/src/routes/shutdown.ts
@@ -10,6 +10,7 @@
 import { z } from 'zod';
 
 import { okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 
 interface ShutdownRouteHost {
@@ -40,6 +41,10 @@ export function registerShutdownRoutes(
       tags: ['meta'],
     },
     (req, reply) => {
+      requestLog(req)?.info(
+        { remoteAddress: (req as unknown as { ip?: string }).ip },
+        'shutdown requested',
+      );
       reply.send(okEnvelope({ ok: true }, req.id));
       // Let the response flush before tearing the server down.
       setImmediate(() => opts.onShutdown());
diff --git a/packages/kap-server/src/routes/skills.ts b/packages/kap-server/src/routes/skills.ts
index 0f7f85a64..861056a38 100644
--- a/packages/kap-server/src/routes/skills.ts
+++ b/packages/kap-server/src/routes/skills.ts
@@ -42,6 +42,9 @@
  *                    `skill_activation` origin. The returned `Turn` handle is
  *                    discarded; clients follow progress via the `skill.activated`
  *                    + `turn.*` events emitted by the service on the WS stream.
+ *                    The edge then applies the prompt-metadata update
+ *                    (`applyPromptMetadataUpdate`) so a first `/<skill>`
+ *                    message titles the session, matching the native RPC path.
  *
  * **Model projection**: `SkillDefinition` (v2) → protocol `SkillDescriptor`,
  * byte-for-byte with v1's `toProtocolSkill`
@@ -72,9 +75,11 @@ import {
   IAgentSkillService,
   IBootstrapService,
   IConfigService,
+  IEventService,
   IPluginService,
   ISessionIndex,
   ISessionLifecycleService,
+  ISessionMetadata,
   ISessionSkillCatalog,
   ISkillCatalogRuntimeOptions,
   ISkillDiscovery,
@@ -83,8 +88,10 @@ import {
   isError2,
   MERGE_ALL_AVAILABLE_SKILLS_SECTION,
   SKILL_SOURCE_PRIORITY,
+  applyPromptMetadataUpdate,
   configuredRoots,
   projectRoots,
+  promptMetadataTextFromSkill,
   userRoots,
   type ISessionScopeHandle,
   type Scope,
@@ -92,19 +99,20 @@ import {
   type ExtraSkillDirsConfig,
   type MergeAllAvailableSkillsConfig,
 } from '@moonshot-ai/agent-core-v2';
-import {
-  ErrorCode,
-  activateSkillRequestSchema,
-  activateSkillResultSchema,
-  listSkillsResponseSchema,
-  workspaceIdParamSchema,
-  type SkillDescriptor,
-} from '@moonshot-ai/protocol';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 import { ensureMainAgent } from '../transport/mainAgent';
+import { ErrorCode } from '../protocol/error-codes';
+import {
+  activateSkillRequestSchema,
+  activateSkillResultSchema,
+  listSkillsResponseSchema,
+} from '../protocol/rest-skill';
+import { workspaceIdParamSchema } from '../protocol/rest-workspace';
+import type { SkillDescriptor } from '../protocol/skill';
 import { parseActionSuffix } from './action-suffix';
 
 interface SkillsRouteHost {
@@ -283,6 +291,17 @@ export function registerSkillsRoutes(app: SkillsRouteHost, core: Scope): void {
         await agent.accessor
           .get(IAgentSkillService)
           .activate({ name: parsed.id, args: req.body.args });
+        // Keep the easy-title behavior of the native RPC / TUI path: a first
+        // `/<skill>` message titles the session (same as routes/prompts.ts).
+        await applyPromptMetadataUpdate(
+          {
+            metadata: resolved.handle.accessor.get(ISessionMetadata),
+            eventService: core.accessor.get(IEventService),
+            sessionId: session_id,
+          },
+          promptMetadataTextFromSkill({ name: parsed.id, args: req.body.args }),
+        );
+        requestLog(req)?.info({ session_id, skill_name: parsed.id }, 'skill activated');
         reply.send(okEnvelope({ activated: true, skill_name: parsed.id }, req.id));
       } catch (err) {
         sendMappedError(reply, req.id, err);
diff --git a/packages/kap-server/src/routes/snapshot.ts b/packages/kap-server/src/routes/snapshot.ts
index 8bf8c4fc5..c3e7b3eb7 100644
--- a/packages/kap-server/src/routes/snapshot.ts
+++ b/packages/kap-server/src/routes/snapshot.ts
@@ -23,7 +23,6 @@ import {
   IAgentLifecycleService,
   IAgentPromptService,
   ILogService,
-  ISessionActivity,
   ISessionInteractionService,
   ISessionContext,
   ISessionLifecycleService,
@@ -33,13 +32,13 @@ import {
   type IAgentScopeHandle,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
+import type { Message } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+import { ErrorCode } from '../protocol/error-codes';
 import {
-  ErrorCode,
   sessionSnapshotResponseSchema,
   type InFlightTurn,
-  type Message,
   type SessionSnapshotResponse,
-} from '@moonshot-ai/protocol';
+} from '../protocol/rest-snapshot';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
@@ -53,7 +52,7 @@ import type { ISnapshotReader } from '../services/snapshot';
 import { type SessionEventBroadcaster } from '../transport/ws/v1/sessionEventBroadcaster';
 import { toWireApproval } from './approvals';
 import { toWireQuestion } from './questions';
-import { toWireSession } from './sessions';
+import { resolveSessionFacts, toWireSession } from './sessions';
 
 /** Most-recent messages included in the snapshot page. */
 const SNAPSHOT_MESSAGE_PAGE_SIZE = 100;
@@ -168,7 +167,7 @@ async function readViaLegacyAssembly(
   const session = toWireSession(
     { ...meta, workspaceId },
     cwd,
-    handle.accessor.get(ISessionActivity).status(),
+    resolveSessionFacts(core, sessionId),
   );
 
   // Messages — most recent page of the main agent's live history.
@@ -201,6 +200,7 @@ async function readViaLegacyAssembly(
     session,
     messages: { items, has_more: hasMore },
     in_flight_turn: inFlightTurn,
+    subagents: snapState.subagents,
     pending_approvals: pendingApprovals,
     pending_questions: pendingQuestions,
   };
diff --git a/packages/kap-server/src/routes/tasks.ts b/packages/kap-server/src/routes/tasks.ts
index 922367a11..3a664a471 100644
--- a/packages/kap-server/src/routes/tasks.ts
+++ b/packages/kap-server/src/routes/tasks.ts
@@ -45,18 +45,19 @@ import {
   type AgentTaskInfo,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
+import { ErrorCode } from '../protocol/error-codes';
 import {
-  ErrorCode,
   cancelTaskResultSchema,
   getTaskQuerySchema,
   getTaskResponseSchema,
   listTasksQuerySchema,
   listTasksResponseSchema,
-} from '@moonshot-ai/protocol';
-import type { Task, TaskKind, TaskStatus } from '@moonshot-ai/protocol';
+} from '../protocol/rest-task';
+import type { Task, TaskKind, TaskStatus } from '../protocol/task';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 import { ensureMainAgent } from '../transport/mainAgent';
 import { parseActionSuffix } from './action-suffix';
@@ -255,7 +256,8 @@ export function registerTasksRoutes(app: TasksRouteHost, core: Scope): void {
         return;
       }
 
-      await resolved.tasks?.stop(task_id);
+      await resolved.tasks?.stopByUser(task_id);
+      requestLog(req)?.info({ session_id, task_id }, 'task cancelled');
       reply.send(okEnvelope({ cancelled: true as const }, req.id));
     },
   );
diff --git a/packages/kap-server/src/routes/terminals.ts b/packages/kap-server/src/routes/terminals.ts
index 457503c7e..8a0ce8b5c 100644
--- a/packages/kap-server/src/routes/terminals.ts
+++ b/packages/kap-server/src/routes/terminals.ts
@@ -6,7 +6,8 @@
  * Backed by the v2 Session-scoped `ISessionTerminalService`
  * (`agent-core-v2/src/session/terminal`): the route resolves the session from
  * the URL, then dispatches to the matching `ISessionTerminalService` method.
- * The wire schema is reused from `@moonshot-ai/protocol`.
+ * The wire schema comes from the engine's own terminal contract
+ * (`agent-core-v2`).
  *
  * The v2 service is Session-scoped (one instance owns only its own session's
  * terminals), so unlike v1 the methods do not take a `session_id` — the session
@@ -28,17 +29,18 @@ import {
   Error2,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
-import {
-  closeTerminalResponseSchema,
-  createTerminalRequestSchema,
-  ErrorCode,
-  getTerminalResponseSchema,
-  listTerminalsResponseSchema,
-} from '@moonshot-ai/protocol';
+import { createTerminalRequestSchema } from '@moonshot-ai/agent-core-v2/os/interface/terminal';
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
+import {
+  closeTerminalResponseSchema,
+  getTerminalResponseSchema,
+  listTerminalsResponseSchema,
+} from '../protocol/rest-terminal';
 import { parseActionSuffix } from './action-suffix';
 
 interface TerminalsRouteHost {
@@ -139,6 +141,7 @@ export function registerTerminalsRoutes(app: TerminalsRouteHost, core: Scope): v
       try {
         const { session_id } = req.params;
         const terminal = await (await resolveTerminal(core, session_id)).create(req.body);
+        requestLog(req)?.info({ session_id, terminal_id: terminal.id }, 'terminal created');
         reply.send(okEnvelope(terminal, req.id));
       } catch (err) {
         sendMappedError(reply, req.id, err);
@@ -211,6 +214,7 @@ export function registerTerminalsRoutes(app: TerminalsRouteHost, core: Scope): v
           return;
         }
         const result = await (await resolveTerminal(core, session_id)).close(parsed.id);
+        requestLog(req)?.info({ session_id, terminal_id: parsed.id }, 'terminal closed');
         reply.send(okEnvelope(result, req.id));
       } catch (err) {
         sendMappedError(reply, req.id, err);
diff --git a/packages/kap-server/src/routes/tools.ts b/packages/kap-server/src/routes/tools.ts
index 41c1b7b43..231aa94b5 100644
--- a/packages/kap-server/src/routes/tools.ts
+++ b/packages/kap-server/src/routes/tools.ts
@@ -54,19 +54,18 @@ import {
   type ToolInfo,
   type ToolSource,
 } from '@moonshot-ai/agent-core-v2';
-import {
-  ErrorCode,
-  listMcpServersResponseSchema,
-  listToolsQuerySchema,
-  listToolsResponseSchema,
-  restartMcpServerResultSchema,
-  type McpServer,
-  type ToolDescriptor,
-} from '@moonshot-ai/protocol';
 
 import { errEnvelope, okEnvelope } from '../envelope';
 import { defineRoute } from '../middleware/defineRoute';
 import { ensureMainAgent } from '../transport/mainAgent';
+import { ErrorCode } from '../protocol/error-codes';
+import {
+  listMcpServersResponseSchema,
+  listToolsQuerySchema,
+  listToolsResponseSchema,
+  restartMcpServerResultSchema,
+} from '../protocol/rest-tool';
+import type { McpServer, ToolDescriptor } from '../protocol/tool';
 import { parseActionSuffix } from './action-suffix';
 
 /** v2 MCP tool-name prefix / separator (see `mcp/tool-naming.ts`). */
diff --git a/packages/kap-server/src/routes/workspaceFs.ts b/packages/kap-server/src/routes/workspaceFs.ts
index 53667df4a..1116bf86d 100644
--- a/packages/kap-server/src/routes/workspaceFs.ts
+++ b/packages/kap-server/src/routes/workspaceFs.ts
@@ -14,7 +14,7 @@
  *
  * Routes (registered exactly as v1 declares them):
  *
- *   GET /fs::browse?path=<abs-path>   list sub-directories (+ git metadata)
+ *   GET /fs::browse?path=<abs-path>   list sub-directories
  *   GET /fs::home                     $HOME + recent workspace roots
  *
  * **Wire path vs source path.** The source path strings carry a double colon
@@ -36,14 +36,14 @@ import {
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
 import {
-  ErrorCode,
   fsBrowseQuerySchema,
   fsBrowseResponseSchema,
   fsHomeResponseSchema,
-} from '@moonshot-ai/protocol';
+} from '@moonshot-ai/agent-core-v2/app/hostFolderBrowser/hostFolderBrowser';
 
 import { errEnvelope, okEnvelope } from '../envelope';
 import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
 
 interface WorkspaceFsRouteHost {
   get(
diff --git a/packages/kap-server/src/routes/workspaces.ts b/packages/kap-server/src/routes/workspaces.ts
index 4da8de928..27b294a19 100644
--- a/packages/kap-server/src/routes/workspaces.ts
+++ b/packages/kap-server/src/routes/workspaces.ts
@@ -3,7 +3,7 @@
  *
  * Implements the v1 `/api/v1/workspaces` wire contract on top of
  * `agent-core-v2` services. Backed by `IWorkspaceRegistry` (Core scope) for the
- * catalog, `IHostFileSystem` to validate roots and detect git, and
+ * catalog, `IHostFileSystem` to validate roots, and
  * `ISessionIndex` to derive `session_count`.
  *
  *   GET    /workspaces                    list
@@ -14,10 +14,6 @@
  * **Wire fidelity**: the v1 `workspaceSchema` carries more fields than v2's
  * `Workspace` (`{ id, root, name, createdAt, lastOpenedAt }`). The handler
  * projects the v2 record onto the v1 shape, deriving the extra fields:
- *   - `is_git_repo` / `branch` — best-effort `.git` detection; `branch` is
- *     parsed from `.git/HEAD` (`ref: refs/heads/<branch>`), resolving the
- *     real git dir through a `.git` file for worktrees/submodules. Matches the
- *     v1 `agent-core` probe.
  *   - `created_at` / `last_opened_at` — from the registry's in-memory
  *     timestamps (reset on restart; the registry is still a skeleton).
  *   - `session_count` — count of persisted sessions for the workspace.
@@ -30,8 +26,15 @@ import {
   type Scope,
   type Workspace,
 } from '@moonshot-ai/agent-core-v2';
+import { isAbsolute } from 'node:path';
+
+import { z } from 'zod';
+
+import { errEnvelope, okEnvelope } from '../envelope';
+import { requestLog } from '../lib/requestLog';
+import { defineRoute } from '../middleware/defineRoute';
+import { ErrorCode } from '../protocol/error-codes';
 import {
-  ErrorCode,
   createWorkspaceRequestSchema,
   createWorkspaceResponseSchema,
   deleteWorkspaceResponseSchema,
@@ -39,14 +42,8 @@ import {
   updateWorkspaceRequestSchema,
   updateWorkspaceResponseSchema,
   workspaceIdParamSchema,
-} from '@moonshot-ai/protocol';
-import type { Workspace as WorkspaceWire } from '@moonshot-ai/protocol';
-import { isAbsolute, join } from 'node:path';
-
-import { z } from 'zod';
-
-import { errEnvelope, okEnvelope } from '../envelope';
-import { defineRoute } from '../middleware/defineRoute';
+} from '../protocol/rest-workspace';
+import type { Workspace as WorkspaceWire } from '../protocol/workspace';
 
 interface WorkspaceRouteHost {
   get(
@@ -207,6 +204,7 @@ export function registerWorkspacesRoutes(app: WorkspaceRouteHost, core: Scope):
         return;
       }
       await registry.delete(workspace_id);
+      requestLog(req)?.info({ workspace_id }, 'workspace deleted');
       reply.send(okEnvelope({ deleted: true as const }, req.id));
     },
   );
@@ -222,60 +220,17 @@ export function registerWorkspacesRoutes(app: WorkspaceRouteHost, core: Scope):
 // ---------------------------------------------------------------------------
 
 async function toWireWorkspace(core: Scope, ws: Workspace): Promise<WorkspaceWire> {
-  const [git, sessionCount] = await Promise.all([
-    detectGit(core, ws.root),
-    countSessions(core, ws.id),
-  ]);
+  const sessionCount = await countSessions(core, ws.id);
   return {
     id: ws.id,
     root: ws.root,
     name: ws.name,
-    is_git_repo: git.isGitRepo,
-    branch: git.branch,
     created_at: new Date(ws.createdAt).toISOString(),
     last_opened_at: new Date(ws.lastOpenedAt).toISOString(),
     session_count: sessionCount,
   };
 }
 
-async function detectGit(
-  core: Scope,
-  root: string,
-): Promise<{ isGitRepo: boolean; branch: string | null }> {
-  // Mirror the v1 `agent-core` git probe: confirm `.git`, resolve the real git
-  // dir (a `.git` *file* in worktrees/submodules points at it via `gitdir:`),
-  // then read `<gitDir>/HEAD` and peel off `ref: refs/heads/<branch>`. Every
-  // step is best-effort so a missing/unreadable piece degrades to `null`
-  // rather than failing the projection.
-  const hostFs = core.accessor.get(IHostFileSystem);
-
-  const dotGit = await hostFs.stat(join(root, '.git')).catch(() => null);
-  if (dotGit === null) {
-    return { isGitRepo: false, branch: null };
-  }
-
-  let gitDir: string;
-  if (dotGit.isDirectory) {
-    gitDir = join(root, '.git');
-  } else if (dotGit.isFile) {
-    const text = await hostFs.readText(join(root, '.git')).catch(() => null);
-    const ref = (text === null ? '' : /^gitdir:\s*(.+)$/m.exec(text)?.[1] ?? '').trim();
-    if (ref === '') {
-      return { isGitRepo: false, branch: null };
-    }
-    gitDir = ref.startsWith('/') ? ref : join(root, ref);
-  } else {
-    return { isGitRepo: false, branch: null };
-  }
-
-  const head = await hostFs.readText(join(gitDir, 'HEAD')).catch(() => null);
-  if (head === null) {
-    return { isGitRepo: true, branch: null };
-  }
-  const branch = /^ref:\s*refs\/heads\/(.+)$/.exec(head.trim())?.[1] ?? null;
-  return { isGitRepo: true, branch };
-}
-
 async function countSessions(core: Scope, workspaceId: string): Promise<number> {
   const page = await core.accessor
     .get(ISessionIndex)
diff --git a/packages/kap-server/src/services/guiStore/guiStoreService.ts b/packages/kap-server/src/services/guiStore/guiStoreService.ts
index f52a907dd..7d5d9d9e2 100644
--- a/packages/kap-server/src/services/guiStore/guiStoreService.ts
+++ b/packages/kap-server/src/services/guiStore/guiStoreService.ts
@@ -10,6 +10,13 @@ import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
 
 import { IGuiStoreService } from './guiStore';
 
+/** Minimal logger surface — keeps the store decoupled from the server logger. */
+export interface GuiStoreLogger {
+  warn(obj: unknown, msg: string): void;
+}
+
+const noopLogger: GuiStoreLogger = { warn: () => {} };
+
 function emptyStore(): Record<string, string> {
   return Object.create(null) as Record<string, string>;
 }
@@ -18,10 +25,12 @@ export class GuiStoreService implements IGuiStoreService {
   readonly _serviceBrand: undefined;
 
   private readonly filePath: string;
+  private readonly logger: GuiStoreLogger;
   private queue: Promise<void> = Promise.resolve();
 
-  constructor(homeDir: string) {
+  constructor(homeDir: string, logger?: GuiStoreLogger) {
     this.filePath = join(homeDir, 'gui.toml');
+    this.logger = logger ?? noopLogger;
   }
 
   async getItem(key: string): Promise<string | null> {
@@ -82,7 +91,11 @@ export class GuiStoreService implements IGuiStoreService {
         if (typeof v === 'string') out[k] = v;
       }
       return out;
-    } catch {
+    } catch (error) {
+      this.logger.warn(
+        { filePath: this.filePath, err: error },
+        'gui.toml parse failed; using an empty store',
+      );
       return emptyStore();
     }
   }
diff --git a/packages/kap-server/src/services/legacyStatus/legacyStatus.ts b/packages/kap-server/src/services/legacyStatus/legacyStatus.ts
index 4f1f9618a..efcdf2986 100644
--- a/packages/kap-server/src/services/legacyStatus/legacyStatus.ts
+++ b/packages/kap-server/src/services/legacyStatus/legacyStatus.ts
@@ -1,15 +1,14 @@
 /**
- * `LegacyStatus` — kap-server-layer derived model that re-derives the v1-style
+ * `LegacyStatus` — kap-server-layer projection of the v1-style
  * combined `agent.status.updated` payload from the agent's native v2 services.
  *
  * v1 emits a single `agent.status.updated` carrying usage + contextTokens +
  * maxContextTokens + model together. v2 splits those into independent Models /
  * Ops (`usage.record`, `context_size.measured`, `config.update` …), so the
  * partial events reach clients separately and a usage-only event can overwrite
- * a previously-known contextTokens with a stale zero. This derived model
- * watches the status-affecting Ops and, on each, re-reads the authoritative
- * services and emits a fresh combined event so the edge always has a real,
- * consistent context-window value to forward.
+ * a previously-known contextTokens with a stale zero. The v1 edge re-reads the
+ * authoritative services when a native status or context change arrives, so it
+ * always forwards a real, consistent context-window value.
  *
  * Temporary bridge while the v2 wire contract still exposes the slices
  * separately — defined at the kap-server edge rather than in agent-core-v2 so
@@ -20,44 +19,81 @@ import {
   IAgentContextSizeService,
   IAgentProfileService,
   IAgentUsageService,
-  IAgentWireService,
-  defineDerivedModel,
+  IWireService,
   type IAgentScopeHandle,
   type UsageStatus,
 } from '@moonshot-ai/agent-core-v2';
 import { ContextSizeModel } from '@moonshot-ai/agent-core-v2';
-import type {
-  AgentActivitySnapshot,
-  AgentPhase,
-} from '@moonshot-ai/agent-core-v2';
-
-interface LegacyStatusState {
-  /** Monotonic change counter — only used to fan change notifications out. */
-  readonly version: number;
-}
+import type { AgentActivityState } from '@moonshot-ai/agent-core-v2';
+import type { TurnEndReason } from '@moonshot-ai/agent-core-v2/agent/loop/turnEvents';
 
 /**
- * Reacts to the Ops that can change the status line. The state itself carries
- * no business data; the handler re-reads the authoritative services on every
- * bump so the emitted snapshot is always consistent with the live Models.
- *
- * The context-append Ops are watched alongside the usage / measurement Ops
- * because the emitted contextTokens is the live (measured + estimated) size:
- * a freshly appended prompt or step event grows it before any LLM response
- * lands. The derived model's dedupe (in the broadcaster) suppresses appends
- * that don't move the size, so the extra watches cost no extra frames.
+ * The v1 `phase` field of the combined `agent.status.updated` payload — a
+ * v1-only concept with no producer on the v2 side (v2's native status events
+ * never carry it), so it is defined here at the v1 edge that projects it.
  */
-export const LegacyStatusModel = defineDerivedModel<LegacyStatusState>(
-  'legacyStatus',
-  () => ({ version: 0 }),
-  {
-    'usage.record': (s) => ({ version: s.version + 1 }),
-    'context_size.measured': (s) => ({ version: s.version + 1 }),
-    'context.append_message': (s) => ({ version: s.version + 1 }),
-    'context.append_loop_event': (s) => ({ version: s.version + 1 }),
-    'config.update': (s) => ({ version: s.version + 1 }),
-  },
-);
+export type AgentPhase =
+  | { readonly kind: 'idle' }
+  | {
+      readonly kind: 'running';
+      readonly turnId: number;
+      readonly step: number;
+      readonly stepId: string;
+      readonly since: number;
+    }
+  | {
+      readonly kind: 'streaming';
+      readonly turnId: number;
+      readonly step: number;
+      readonly stepId: string;
+      readonly stream: 'assistant' | 'thinking' | 'tool_call';
+      readonly toolCallId?: string;
+      readonly toolName?: string;
+      readonly since: number;
+    }
+  | {
+      readonly kind: 'tool_call';
+      readonly turnId: number;
+      readonly step: number;
+      readonly toolCallId: string;
+      readonly name: string;
+      readonly since: number;
+    }
+  | {
+      readonly kind: 'retrying';
+      readonly turnId: number;
+      readonly step: number;
+      readonly stepId: string;
+      readonly failedAttempt: number;
+      readonly nextAttempt: number;
+      readonly maxAttempts: number;
+      readonly delayMs: number;
+      readonly errorName?: string;
+      readonly statusCode?: number;
+      readonly since: number;
+    }
+  | {
+      readonly kind: 'awaiting_approval';
+      readonly turnId: number;
+      readonly step?: number;
+      readonly approval?: unknown;
+      readonly since: number;
+    }
+  | {
+      readonly kind: 'interrupted';
+      readonly turnId: number;
+      readonly step?: number;
+      readonly reason: 'aborted' | 'max_steps' | 'error';
+      readonly message?: string;
+      readonly at: number;
+    }
+  | {
+      readonly kind: 'ended';
+      readonly turnId: number;
+      readonly reason: TurnEndReason;
+      readonly durationMs?: number;
+      readonly at: number;
+    };
 
 export interface LegacyStatusSnapshot {
   readonly usage?: UsageStatus;
@@ -67,10 +103,27 @@ export interface LegacyStatusSnapshot {
   readonly model: string;
 }
 
-/** Read the current combined status from the agent's authoritative services. */
-export function readLegacyStatus(agent: IAgentScopeHandle): LegacyStatusSnapshot {
-  const profile = agent.accessor.get(IAgentProfileService);
-  const usage = agent.accessor.get(IAgentUsageService).status();
+/** Read the current combined status when the handle exposes a complete agent. */
+export function readLegacyStatus(agent: IAgentScopeHandle): LegacyStatusSnapshot | undefined {
+  const profile = agent.accessor.get(IAgentProfileService) as
+    | IAgentProfileService
+    | undefined;
+  const usageService = agent.accessor.get(IAgentUsageService) as
+    | IAgentUsageService
+    | undefined;
+  const contextSize = agent.accessor.get(IAgentContextSizeService) as
+    | IAgentContextSizeService
+    | undefined;
+  const wire = agent.accessor.get(IWireService) as IWireService | undefined;
+  if (
+    profile === undefined ||
+    usageService === undefined ||
+    contextSize === undefined ||
+    wire === undefined
+  ) {
+    return undefined;
+  }
+  const usage = usageService.status();
   // Live (measured + estimated) context size — mirrors the REST status rollup
   // (`ISessionLegacyService.status`) and v1's `context.tokenCount`, which
   // reflect the context even before the first measured exchange completes.
@@ -79,8 +132,7 @@ export function readLegacyStatus(agent: IAgentScopeHandle): LegacyStatusSnapshot
   // prefix (the estimate then excludes the system prompt); the measured total
   // is the better reading there. Every REAL shrink (undo / clear / compaction)
   // rebases the measured model first, so the max only wins in that window.
-  const contextSize = agent.accessor.get(IAgentContextSizeService);
-  const measured = agent.accessor.get(IAgentWireService).getModel(ContextSizeModel);
+  const measured = wire.getModel(ContextSizeModel);
   const contextTokens = Math.max(contextSize.get().size, measured.tokens);
   // Unfolded twin of contextTokens, floored at the same reading so the wire
   // invariant raw >= projected also holds in the transient window where the
@@ -92,11 +144,11 @@ export function readLegacyStatus(agent: IAgentScopeHandle): LegacyStatusSnapshot
 }
 
 /**
- * Map the native v2 `AgentActivitySnapshot` to the legacy v1 `AgentPhase`
+ * Map the native v2 `AgentActivityState` to the legacy v1 `AgentPhase`
  * (`agent.status.updated` payload). Pure function — kept at the kap-server
  * edge so the core engine stays free of v1 wire-compatibility concerns.
  *
- * Returns `undefined` for `disposing` / `disposed` lanes, which have no v1
+ * Returns `undefined` for `disposing` / `disposed`, which have no v1
  * concept (emitting `idle` would mislead the UI).
  *
  * Three deliberate v1 divergences from the naive mapping (see status-refactor
@@ -104,11 +156,11 @@ export function readLegacyStatus(agent: IAgentScopeHandle): LegacyStatusSnapshot
  * approval is still pending (no premature `running`); `interrupted` carries the
  * `endingReason`; `disposing`/`disposed` emit nothing.
  */
-export function toLegacyPhase(snapshot: AgentActivitySnapshot): AgentPhase | undefined {
-  const { lane, turn, lastTurn } = snapshot;
+export function toLegacyPhase(state: AgentActivityState): AgentPhase | undefined {
+  const { lifecycle, turn, lastTurn } = state;
 
-  if (lane === 'idle' || lane === 'initializing') {
-    if (lastTurn !== undefined && lane === 'idle') {
+  if (turn === undefined && lifecycle === 'ready') {
+    if (lastTurn !== undefined && lifecycle === 'ready') {
       return {
         kind: 'ended',
         turnId: lastTurn.turnId,
@@ -120,7 +172,7 @@ export function toLegacyPhase(snapshot: AgentActivitySnapshot): AgentPhase | und
     return { kind: 'idle' };
   }
 
-  if (lane === 'turn' && turn !== undefined) {
+  if (lifecycle === 'ready' && turn !== undefined) {
     if (turn.pendingApprovals.length > 0) {
       const latest = turn.pendingApprovals[turn.pendingApprovals.length - 1]!;
       return {
diff --git a/packages/kap-server/src/services/snapshot/snapshot.ts b/packages/kap-server/src/services/snapshot/snapshot.ts
index b37eb1561..7f6bdb583 100644
--- a/packages/kap-server/src/services/snapshot/snapshot.ts
+++ b/packages/kap-server/src/services/snapshot/snapshot.ts
@@ -8,7 +8,7 @@
  * (`packages/server/src/services/snapshot/snapshot.ts`).
  */
 
-import type { SessionSnapshotResponse } from '@moonshot-ai/protocol';
+import type { SessionSnapshotResponse } from '../../protocol/rest-snapshot';
 
 export interface ISnapshotReader {
   /** Assemble the atomic snapshot for `sid`. Throws `SnapshotNotFoundError` when the session (or its workspace) is absent on disk. */
diff --git a/packages/kap-server/src/services/snapshot/snapshotReader.ts b/packages/kap-server/src/services/snapshot/snapshotReader.ts
index fc21d6bd6..0b2f14758 100644
--- a/packages/kap-server/src/services/snapshot/snapshotReader.ts
+++ b/packages/kap-server/src/services/snapshot/snapshotReader.ts
@@ -24,7 +24,6 @@ import { join } from 'node:path';
 import {
   IAgentLifecycleService,
   IAgentPromptService,
-  ISessionActivity,
   ISessionIndex,
   ISessionInteractionService,
   ISessionLifecycleService,
@@ -36,16 +35,12 @@ import {
   type Scope,
   type SessionMeta,
 } from '@moonshot-ai/agent-core-v2';
-import type {
-  InFlightTurn,
-  SessionSnapshotResponse,
-  SessionStatus,
-} from '@moonshot-ai/protocol';
 
 import { toWireApproval } from '../../routes/approvals';
 import { toWireQuestion } from '../../routes/questions';
-import { toWireSession } from '../../routes/sessions';
+import { resolveSessionFacts, toWireSession } from '../../routes/sessions';
 import { type SessionEventBroadcaster } from '../../transport/ws/v1/sessionEventBroadcaster';
+import type { InFlightTurn, SessionSnapshotResponse } from '../../protocol/rest-snapshot';
 import { SnapshotNotFoundError } from './snapshot';
 import type { ISnapshotReader } from './snapshot';
 import { type SnapshotConfig } from './snapshotConfig';
@@ -76,6 +71,7 @@ interface TranscriptCacheEntry {
   readonly size: number;
   readonly mtimeMs: number;
   readonly messages: ContextMessage[];
+  readonly times: readonly (number | undefined)[];
 }
 
 interface LocatedSession {
@@ -106,16 +102,24 @@ export class SnapshotReader implements ISnapshotReader {
     const offset = hasMore ? full.length - SNAPSHOT_MESSAGE_PAGE_SIZE : 0;
     const page = hasMore ? full.slice(offset) : full;
     await this.rehydrateBlobRefs(page, join(located.sessionDir, AGENTS_DIR, MAIN_AGENT_ID, BLOBS_DIR));
-    const items = page.map((msg, i) =>
-      toProtocolMessage(sid, offset + i, msg, located.meta.createdAt),
-    );
+    // `created_at` prefers the real per-record time stamped onto wire.jsonl at
+    // dispatch; records predating the stamp (or the `metadata` envelope) fall
+    // back to the synthesized `session.createdAt + index`, clamped so the
+    // page stays strictly increasing (mirrors `MessageLegacyService.list`).
+    let previousMs = Number.NEGATIVE_INFINITY;
+    const items = page.map((msg, i) => {
+      const index = offset + i;
+      const baseMs = transcript.times[index] ?? located.meta.createdAt + index;
+      const createdAtMs = Math.max(previousMs + 1, baseMs);
+      previousMs = createdAtMs;
+      return toProtocolMessage(sid, index, msg, located.meta.createdAt, createdAtMs);
+    });
 
     const live = core.accessor.get(ISessionLifecycleService).get(sid);
-    const status = this.resolveStatus(live);
     const session = toWireSession(
       { ...located.meta, workspaceId: located.workspaceId },
       located.cwd,
-      status,
+      resolveSessionFacts(core, sid),
     );
 
     const inFlightTurn = this.attachCurrentPromptId(sid, live, snapState.inFlightTurn);
@@ -138,6 +142,7 @@ export class SnapshotReader implements ISnapshotReader {
       session,
       messages: { items, has_more: hasMore },
       in_flight_turn: inFlightTurn,
+      subagents: snapState.subagents,
       pending_approvals: approvals,
       pending_questions: questions,
     };
@@ -180,6 +185,7 @@ export class SnapshotReader implements ISnapshotReader {
     sessionDir: string,
   ): Promise<{
     messages: ContextMessage[];
+    times: readonly (number | undefined)[];
     tag: 'hit' | 'miss' | 'shrink_invalidate' | 'enoent';
     wireBytes: number;
   }> {
@@ -192,7 +198,7 @@ export class SnapshotReader implements ISnapshotReader {
     }
     if (info === undefined) {
       this.transcriptCache.delete(sid);
-      return { messages: [], tag: 'enoent', wireBytes: 0 };
+      return { messages: [], times: [], tag: 'enoent', wireBytes: 0 };
     }
 
     const cached = this.transcriptCache.get(sid);
@@ -200,7 +206,7 @@ export class SnapshotReader implements ISnapshotReader {
       // LRU touch.
       this.transcriptCache.delete(sid);
       this.transcriptCache.set(sid, cached);
-      return { messages: cached.messages, tag: 'hit', wireBytes: info.size };
+      return { messages: cached.messages, times: cached.times, tag: 'hit', wireBytes: info.size };
     }
 
     const tag: 'miss' | 'shrink_invalidate' =
@@ -208,21 +214,15 @@ export class SnapshotReader implements ISnapshotReader {
     if (cached !== undefined) this.transcriptCache.delete(sid);
 
     const records = await readWireRecords(wirePath);
-    const messages = [...reduceContextTranscript(records).entries];
-    this.transcriptCache.set(sid, { size: info.size, mtimeMs: info.mtimeMs, messages });
+    const { entries, times } = reduceContextTranscript(records);
+    const messages = [...entries];
+    this.transcriptCache.set(sid, { size: info.size, mtimeMs: info.mtimeMs, messages, times });
     while (this.transcriptCache.size > this.deps.config.cacheLimit) {
       const oldest = this.transcriptCache.keys().next().value;
       if (oldest === undefined) break;
       this.transcriptCache.delete(oldest);
     }
-    return { messages, tag, wireBytes: info.size };
-  }
-
-  private resolveStatus(
-    live: ReturnType<ISessionLifecycleService['get']>,
-  ): SessionStatus {
-    if (live === undefined) return 'idle';
-    return live.accessor.get(ISessionActivity).status();
+    return { messages, times, tag, wireBytes: info.size };
   }
 
   private attachCurrentPromptId(
diff --git a/packages/kap-server/src/start.ts b/packages/kap-server/src/start.ts
index 1284d0fa2..31e3c0b8b 100644
--- a/packages/kap-server/src/start.ts
+++ b/packages/kap-server/src/start.ts
@@ -12,6 +12,7 @@ import {
   hostRequestHeadersSeed,
   IConfigService,
   IModelCatalogService,
+  IWorkspaceRegistry,
   logSeed,
   MULTI_SERVER_FLAG_ENV,
   resolveConfigPath,
@@ -21,7 +22,7 @@ import {
   type Scope,
   type ScopeSeed,
 } from '@moonshot-ai/agent-core-v2';
-import { createAsyncApiDocument } from '@moonshot-ai/protocol';
+import { createAsyncApiDocument } from './protocol/asyncapi';
 import Fastify, { type FastifyInstance } from 'fastify';
 
 import { installErrorHandler } from './error-handler';
@@ -115,6 +116,13 @@ export interface ServerStartOptions {
    * the API server without the web UI.
    */
   readonly webAssetsDir?: string;
+  /**
+   * Host product version, reported as `server_version` (GET /api/v1/meta), in
+   * the OpenAPI document, session exports, the lock / instance registry, and
+   * the default User-Agent. Defaults to kap-server's own package version;
+   * embedding hosts (the CLI) should pass their own version.
+   */
+  readonly version?: string;
 }
 
 export interface RunningServer {
@@ -161,7 +169,7 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
   //     multiple servers can share the homeDir; port conflicts are resolved by
   //     the `port + 1` retry below instead of the lock.
   // Either handle is released on close and on any boot refusal below.
-  const hostVersion = getServerVersion();
+  const hostVersion = opts.version ?? getServerVersion();
   let lockHandle: AcquireLockResult | undefined;
   let registration: InstanceRegistration | undefined;
   if (isMultiServerEnabled(process.env)) {
@@ -195,10 +203,12 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
   const enableShutdown = exposureClass === 'loopback' || opts.allowRemoteShutdown === true;
   const enableTerminals = exposureClass === 'loopback' || opts.allowRemoteTerminals === true;
   const debugEndpoints = exposureClass === 'loopback' && opts.debugEndpoints === true;
-  const authFailureLimiter = exposureClass === 'loopback' ? undefined : createAuthFailureLimiter();
+  const logger = opts.logger ?? createServerLogger({ level: opts.logLevel ?? 'info' });
+  const authFailureLimiter =
+    exposureClass === 'loopback' ? undefined : createAuthFailureLimiter({ logger });
 
   const configPath = resolveConfigPath({ homeDir, configPath: opts.configPath });
-  const guiStore = new GuiStoreService(homeDir);
+  const guiStore = new GuiStoreService(homeDir, logger);
   let authTokenService: IAuthTokenService;
   // Whether a password credential is configured (only meaningful for the real,
   // non-injected auth impl). Drives the token-only warning on a public bind.
@@ -236,7 +246,6 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
     ...(opts.seeds ?? []),
   ]);
 
-  const logger = opts.logger ?? createServerLogger({ level: opts.logLevel ?? 'info' });
   if (exposureClass !== 'loopback') {
     logger.warn(
       { host, exposureClass },
@@ -255,6 +264,20 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
     logger,
   );
 
+  // Sync the workspace catalog from the legacy session index once at startup,
+  // so sessions created by the v1 TUI surface as workspaces on the very first
+  // /workspaces request. Awaited so the write completes before the server
+  // starts accepting traffic (and before embedding hosts tear the homeDir
+  // down); best-effort: a failure re-surfaces on first access.
+  try {
+    await core.accessor.get(IWorkspaceRegistry).list();
+  } catch (error) {
+    logger.warn(
+      { err: error instanceof Error ? error.message : String(error) },
+      'workspace registry startup sync failed',
+    );
+  }
+
   const app = Fastify({
     loggerInstance: logger,
     // Fastify's default access log records `res.statusCode`, but every
@@ -323,7 +346,7 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
     config: loadSnapshotConfig(),
   });
 
-  const serverVersion = getServerVersion();
+  const serverVersion = hostVersion;
 
   async function registerOpenApi(): Promise<void> {
     const { default: swagger } = await import('@fastify/swagger');
@@ -373,7 +396,7 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
     enableTerminals,
     guiStore,
     onShutdown: () => {
-      void close();
+      void close().catch((err: unknown) => logger.error({ err }, 'server close failed'));
     },
     connectionRegistry,
     broadcaster,
@@ -382,7 +405,7 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
   });
 
   registerRpcRoutes(app, core, { token: opts.rpcToken });
-  const wssV2 = registerWs(core, { validateCredential, registry: connectionRegistry });
+  const wssV2 = registerWs(core, { validateCredential, registry: connectionRegistry, logger });
   const wssV1 = registerWsV1(core, {
     validateCredential,
     registry: connectionRegistry,
@@ -410,11 +433,19 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
     // Origin is present-only: a missing Origin is treated as a non-browser
     // client and allowed.
     if (!hostCheck.isAllowed(req.headers.host)) {
+      logger.warn(
+        { remoteAddress: req.socket.remoteAddress, path: url, reason: 'host_not_allowed' },
+        'ws upgrade rejected',
+      );
       (socket as Socket).write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
       (socket as Socket).destroy();
       return;
     }
     if (!isOriginAllowed(req.headers.origin, req.headers.host, allowedOrigins)) {
+      logger.warn(
+        { remoteAddress: req.socket.remoteAddress, path: url, reason: 'origin_not_allowed' },
+        'ws upgrade rejected',
+      );
       (socket as Socket).write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
       (socket as Socket).destroy();
       return;
@@ -431,11 +462,28 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
       if (candidate !== null) {
         try {
           ok = await validateCredential(candidate);
-        } catch {
+        } catch (error) {
+          logger.warn(
+            {
+              err: error,
+              remoteAddress: req.socket.remoteAddress,
+              path: url,
+              reason: 'credential_validation_error',
+            },
+            'ws upgrade rejected',
+          );
           ok = false;
         }
       }
       if (!ok) {
+        logger.warn(
+          {
+            remoteAddress: req.socket.remoteAddress,
+            path: url,
+            reason: candidate === null ? 'missing_credential' : 'invalid_credential',
+          },
+          'ws upgrade rejected',
+        );
         (socket as Socket).write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
         (socket as Socket).destroy();
         return;
@@ -450,7 +498,9 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
     }
   };
   app.server.on('upgrade', (req, socket, head) => {
-    void handleUpgrade(req, socket, head);
+    void handleUpgrade(req, socket, head).catch((error: unknown) =>
+      logger.error({ err: error }, 'ws upgrade handler failed'),
+    );
   });
 
   app.addHook('onClose', async () => {
diff --git a/packages/kap-server/src/transport/channelRegistry.ts b/packages/kap-server/src/transport/channelRegistry.ts
index 106a74f3a..bd43439d2 100644
--- a/packages/kap-server/src/transport/channelRegistry.ts
+++ b/packages/kap-server/src/transport/channelRegistry.ts
@@ -15,6 +15,7 @@
 import {
   Disposable,
   getScopedServiceDescriptors,
+  IAgentActivityView,
   IAgentContextMemoryService,
   IAgentContextSizeService,
   IAgentGoalService,
@@ -35,10 +36,11 @@ import {
   IFaultInjectionService,
   IFlagService,
   IHostFolderBrowser,
+  IModelCatalogService,
+  IModelService,
   IOAuthService,
   IPluginService,
   IProviderService,
-  ISessionActivity,
   ISessionApprovalService,
   ISessionFsService,
   ISessionIndex,
@@ -204,6 +206,8 @@ const EXPOSED_SERVICES: readonly ServiceIdentifier<unknown>[] = [
   IWorkspaceRegistry,
   IConfigService,
   IProviderService,
+  IModelService,
+  IModelCatalogService,
   IOAuthService,
   IAuthSummaryService,
   IFlagService,
@@ -212,7 +216,6 @@ const EXPOSED_SERVICES: readonly ServiceIdentifier<unknown>[] = [
   IBootstrapService,
   // session
   ISessionMetadata,
-  ISessionActivity,
   ISessionLifecycleService,
   ISessionInitService,
   ISessionApprovalService,
@@ -228,6 +231,7 @@ const EXPOSED_SERVICES: readonly ServiceIdentifier<unknown>[] = [
   IAgentUsageService,
   IAgentContextSizeService,
   IAgentSwarmService,
+  IAgentActivityView,
   IAgentPermissionModeService,
   IAgentPermissionRulesService,
   IAgentProfileService,
diff --git a/packages/kap-server/src/transport/dispatcher.ts b/packages/kap-server/src/transport/dispatcher.ts
index 2fcdc568d..568efb278 100644
--- a/packages/kap-server/src/transport/dispatcher.ts
+++ b/packages/kap-server/src/transport/dispatcher.ts
@@ -7,6 +7,7 @@
 
 import {
   ErrorCodes,
+  IAgentGoalService,
   IAgentLifecycleService,
   ISessionLifecycleService,
   Error2,
@@ -85,6 +86,17 @@ export async function resolveService(
   if (id === undefined) {
     throw new Error2(ErrorCodes.REQUEST_INVALID, `unknown service: ${serviceName}`);
   }
+  if (
+    scopeKind === 'agent' &&
+    id === IAgentGoalService &&
+    params['agent_id'] !== MAIN_AGENT_ID
+  ) {
+    throw new Error2(
+      ErrorCodes.GOAL_UNSUPPORTED_AGENT,
+      'Goals are only supported by the main agent',
+      { details: { agentId: params['agent_id'] ?? '' } },
+    );
+  }
   try {
     return scope.accessor.get(id) as object;
   } catch {
diff --git a/packages/kap-server/src/transport/errors.ts b/packages/kap-server/src/transport/errors.ts
index 235f48378..d63e5bd7a 100644
--- a/packages/kap-server/src/transport/errors.ts
+++ b/packages/kap-server/src/transport/errors.ts
@@ -4,7 +4,9 @@
  */
 
 import { ErrorCodes, Error2 } from '@moonshot-ai/agent-core-v2';
-import { ErrorCode, errEnvelope } from '@moonshot-ai/protocol';
+
+import { errEnvelope } from '../protocol/envelope';
+import { ErrorCode } from '../protocol/error-codes';
 
 /** Thrown by {@link withTimeout} when a call exceeds its deadline. */
 export class TimeoutError extends Error {
@@ -44,6 +46,7 @@ const KIMI_TO_PROTOCOL: Record<string, ErrorCode> = {
   [ErrorCodes.GOAL_NOT_RESUMABLE]: ErrorCode.GOAL_NOT_RESUMABLE,
   [ErrorCodes.GOAL_OBJECTIVE_EMPTY]: ErrorCode.GOAL_OBJECTIVE_EMPTY,
   [ErrorCodes.GOAL_OBJECTIVE_TOO_LONG]: ErrorCode.GOAL_OBJECTIVE_TOO_LONG,
+  [ErrorCodes.GOAL_UNSUPPORTED_AGENT]: ErrorCode.GOAL_UNSUPPORTED_AGENT,
   // hostFs / storage codes → closest v1 wire equivalent (ENOTDIR collapses
   // into path-not-found); codes without an equivalent fall back to 50001.
   [ErrorCodes.OS_FS_NOT_FOUND]: ErrorCode.FS_PATH_NOT_FOUND,
diff --git a/packages/kap-server/src/transport/registerRpcRoutes.ts b/packages/kap-server/src/transport/registerRpcRoutes.ts
index bcb89b7a7..c4a161cdc 100644
--- a/packages/kap-server/src/transport/registerRpcRoutes.ts
+++ b/packages/kap-server/src/transport/registerRpcRoutes.ts
@@ -15,8 +15,10 @@
  */
 
 import type { Scope } from '@moonshot-ai/agent-core-v2';
-import { okEnvelope } from '@moonshot-ai/protocol';
 
+import { requestLog } from '../lib/requestLog';
+import { okEnvelope } from '../protocol/envelope';
+import { ErrorCode } from '../protocol/error-codes';
 import type { ScopeKind } from './channel';
 import { describeChannels } from './channelRegistry';
 import { dispatch } from './dispatcher';
@@ -116,7 +118,16 @@ function makeHandler(
       );
       return reply.send(okEnvelope(result, requestId));
     } catch (error) {
-      return reply.send(mapError(error, requestId));
+      const envelope = mapError(error, requestId);
+      // 50001 (including the 30s call timeout) is a server-side failure — log
+      // at error; mapped business codes (4xxxx) are expected client outcomes.
+      const log = requestLog(req);
+      if (envelope.code === ErrorCode.INTERNAL_ERROR) {
+        log?.error({ err: error, service, method }, 'rpc dispatch failed');
+      } else {
+        log?.warn({ err: error, service, method }, 'rpc dispatch failed');
+      }
+      return reply.send(envelope);
     }
   };
 }
diff --git a/packages/kap-server/src/transport/ws/registerWs.ts b/packages/kap-server/src/transport/ws/registerWs.ts
index b460eaea3..1d54d7a74 100644
--- a/packages/kap-server/src/transport/ws/registerWs.ts
+++ b/packages/kap-server/src/transport/ws/registerWs.ts
@@ -15,7 +15,7 @@ import { WebSocketServer } from 'ws';
 
 import type { CredentialValidator } from '../../services/auth/credentials';
 import { type IConnectionRegistry } from './connectionRegistry';
-import { WsConnection } from './wsConnection';
+import { WsConnection, type WsConnectionLogger } from './wsConnection';
 import { selectWsBearerProtocol } from './bearerProtocol';
 
 export interface RegisterWsOptions {
@@ -24,6 +24,8 @@ export interface RegisterWsOptions {
   readonly callTimeoutMs?: number;
   /** Registry that tracks live connections; populated by this module. */
   readonly registry: IConnectionRegistry;
+  /** Per-connection logger forwarded to {@link WsConnection}. */
+  readonly logger?: WsConnectionLogger;
 }
 
 export const WS_PATH = '/api/v2/ws';
@@ -40,6 +42,7 @@ export function registerWs(core: Scope, opts: RegisterWsOptions): WebSocketServe
       callTimeoutMs: opts.callTimeoutMs,
       remoteAddress: req.socket.remoteAddress ?? null,
       userAgent: req.headers['user-agent'] ?? null,
+      logger: opts.logger,
     });
     registry.add(conn);
     socket.on('close', () => registry.remove(conn.id));
diff --git a/packages/kap-server/src/transport/ws/v1/events.ts b/packages/kap-server/src/transport/ws/v1/events.ts
new file mode 100644
index 000000000..0ce5c16b6
--- /dev/null
+++ b/packages/kap-server/src/transport/ws/v1/events.ts
@@ -0,0 +1,197 @@
+/**
+ * The v1 WS `Event` union — the per-agent event stream frame payloads.
+ *
+ * Most frames are the engine's own `DomainEvent`s (turn / tool / subagent /
+ * compaction / mcp / …), re-exported here as the stream's backbone. The
+ * remaining interfaces are the v1-only frames this transport synthesizes
+ * (session/workspace lifecycle, config changes, the merged
+ * legacy status overlay, and the legacy background-task spellings) — they
+ * never had an engine-side producer, so they are defined here, next to the
+ * broadcaster that emits them.
+ */
+
+import type { DomainEvent } from '@moonshot-ai/agent-core-v2/app/event/eventBus';
+import type { MessageContent } from '@moonshot-ai/agent-core-v2/agent/contextMemory/protocolMessage';
+import type { PermissionMode } from '@moonshot-ai/agent-core-v2/agent/permissionPolicy/types';
+import type { UsageStatus } from '@moonshot-ai/agent-core-v2/agent/usage/usage';
+import type { AgentPhase } from '../../../services/legacyStatus/legacyStatus';
+import type { ConfigResponse } from '../../../protocol/rest-config';
+import type { Session, SessionPendingInteraction } from '../../../protocol/session';
+import type { Workspace } from '../../../protocol/workspace';
+
+export interface AgentStatusUpdatedEvent {
+  readonly type: 'agent.status.updated';
+  readonly model?: string;
+  readonly thinkingEffort?: string;
+  readonly contextTokens?: number;
+  readonly maxContextTokens?: number;
+  readonly contextUsage?: number;
+  readonly planMode?: boolean;
+  readonly swarmMode?: boolean;
+  readonly permission?: PermissionMode;
+  readonly usage?: UsageStatus;
+  readonly phase?: AgentPhase;
+}
+
+export interface SessionMetaUpdatedEvent {
+  readonly type: 'session.meta.updated';
+  readonly title?: string;
+  readonly patch?: Record<string, unknown>;
+}
+
+export interface SessionCreatedEvent {
+  readonly type: 'event.session.created';
+  readonly session: Session;
+}
+
+export interface WorkspaceCreatedEvent {
+  readonly type: 'event.workspace.created';
+  readonly workspace: Workspace;
+}
+
+export interface WorkspaceUpdatedEvent {
+  readonly type: 'event.workspace.updated';
+  readonly workspace: Workspace;
+}
+
+export interface WorkspaceDeletedEvent {
+  readonly type: 'event.workspace.deleted';
+  readonly workspace_id: string;
+  readonly root: string;
+}
+
+export interface SessionWorkChangedEvent {
+  readonly type: 'event.session.work_changed';
+  readonly busy: boolean;
+  readonly main_turn_active?: boolean;
+  readonly pending_interaction?: SessionPendingInteraction;
+  readonly last_turn_reason?: 'completed' | 'cancelled' | 'failed';
+}
+
+type LegacySessionStatus =
+  | 'idle'
+  | 'running'
+  | 'awaiting_approval'
+  | 'awaiting_question'
+  | 'aborted';
+
+export interface SessionStatusChangedEvent {
+  readonly type: 'event.session.status_changed';
+  readonly status: LegacySessionStatus;
+  readonly previous_status: LegacySessionStatus;
+  readonly current_prompt_id?: string;
+}
+
+export interface ConfigChangedEvent {
+  readonly type: 'event.config.changed';
+  readonly changedFields: string[];
+  readonly config: ConfigResponse;
+}
+
+export interface PromptSubmittedEvent {
+  readonly type: 'prompt.submitted';
+  readonly promptId: string;
+  readonly userMessageId: string;
+  readonly status: 'running' | 'queued' | 'blocked';
+  readonly content: readonly MessageContent[];
+  readonly createdAt: string;
+}
+
+export type TaskLifecycleStatus =
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'timed_out'
+  | 'killed'
+  | 'lost';
+
+export interface TaskInfoBase {
+  readonly taskId: string;
+  readonly description: string;
+  readonly status: TaskLifecycleStatus;
+  readonly detached?: boolean;
+  readonly startedAt: number;
+  readonly endedAt: number | null;
+  readonly stopReason?: string;
+  readonly terminalNotificationSuppressed?: boolean;
+  readonly timeoutMs?: number;
+}
+
+export interface ProcessTaskInfo extends TaskInfoBase {
+  readonly kind: 'process';
+  readonly command: string;
+  readonly pid: number;
+  readonly exitCode: number | null;
+}
+
+export interface AgentTaskInfo extends TaskInfoBase {
+  readonly kind: 'agent';
+  readonly agentId?: string;
+  readonly subagentType?: string;
+}
+
+export interface QuestionTaskInfo extends TaskInfoBase {
+  readonly kind: 'question';
+  readonly questionCount: number;
+  readonly toolCallId?: string;
+}
+
+export type TaskInfo =
+  | ProcessTaskInfo
+  | AgentTaskInfo
+  | QuestionTaskInfo;
+
+/**
+ * Legacy background-task lifecycle events (`background.task.started` /
+ * `background.task.terminated`). The v2 engine emits `task.started` /
+ * `task.terminated`; the broadcaster re-spells them onto these legacy names so
+ * older clients see a consistent stream.
+ */
+export interface BackgroundTaskStartedEvent {
+  readonly type: 'background.task.started';
+  readonly info: TaskInfo;
+}
+
+export interface BackgroundTaskTerminatedEvent {
+  readonly type: 'background.task.terminated';
+  readonly info: TaskInfo;
+}
+
+export type AgentEvent =
+  | DomainEvent
+  | AgentStatusUpdatedEvent
+  | SessionMetaUpdatedEvent
+  | SessionCreatedEvent
+  | WorkspaceCreatedEvent
+  | WorkspaceUpdatedEvent
+  | WorkspaceDeletedEvent
+  | SessionWorkChangedEvent
+  | SessionStatusChangedEvent
+  | ConfigChangedEvent
+  | PromptSubmittedEvent
+  | BackgroundTaskStartedEvent
+  | BackgroundTaskTerminatedEvent;
+
+export type Event = AgentEvent & { agentId: string; sessionId: string };
+
+export const VOLATILE_EVENT_TYPES = [
+  'assistant.delta',
+  'thinking.delta',
+  'tool.call.delta',
+  'tool.progress',
+  'shell.output',
+  'shell.started',
+  'agent.status.updated',
+] as const;
+
+export type VolatileEventType = (typeof VOLATILE_EVENT_TYPES)[number];
+
+const volatileEventTypeSet: ReadonlySet<string> = new Set(VOLATILE_EVENT_TYPES);
+
+/**
+ * Volatile-vs-durable classification for the global / model event paths (the
+ * agent path uses the local `isVolatileSignal` in the broadcaster instead).
+ */
+export function isVolatileEventType(type: string): type is VolatileEventType {
+  return volatileEventTypeSet.has(type);
+}
diff --git a/packages/kap-server/src/transport/ws/v1/fsWatchBridge.ts b/packages/kap-server/src/transport/ws/v1/fsWatchBridge.ts
index 3db349703..7a0d10090 100644
--- a/packages/kap-server/src/transport/ws/v1/fsWatchBridge.ts
+++ b/packages/kap-server/src/transport/ws/v1/fsWatchBridge.ts
@@ -33,7 +33,7 @@ import {
   ISessionWorkspaceContext,
   type Scope,
 } from '@moonshot-ai/agent-core-v2';
-import type { FsChangeEntry, FsChangeEvent } from '@moonshot-ai/protocol';
+import type { FsChangeEntry, FsChangeEvent } from '@moonshot-ai/agent-core-v2/session/sessionFs/fsWatch';
 
 import type { EventEnvelope, JournalLogger } from './sessionEventJournal';
 
diff --git a/packages/kap-server/src/transport/ws/v1/inFlightTurnTracker.ts b/packages/kap-server/src/transport/ws/v1/inFlightTurnTracker.ts
index 8fadc4bb6..db26579be 100644
--- a/packages/kap-server/src/transport/ws/v1/inFlightTurnTracker.ts
+++ b/packages/kap-server/src/transport/ws/v1/inFlightTurnTracker.ts
@@ -18,7 +18,8 @@
  * describe a different stream and would corrupt the accumulation.
  */
 
-import type { Event, InFlightToolCall, InFlightTurn } from '@moonshot-ai/protocol';
+import type { Event } from './events';
+import type { InFlightToolCall, InFlightTurn } from '../../../protocol/rest-snapshot';
 
 const MAIN_AGENT_ID = 'main';
 
diff --git a/packages/kap-server/src/transport/ws/v1/protocol.ts b/packages/kap-server/src/transport/ws/v1/protocol.ts
index f484eebe3..2363ee892 100644
--- a/packages/kap-server/src/transport/ws/v1/protocol.ts
+++ b/packages/kap-server/src/transport/ws/v1/protocol.ts
@@ -1,6 +1,6 @@
 /**
- * `/api/v1/ws` wire frame builders — thin wrappers around the
- * `@moonshot-ai/protocol` message shapes, ported from v1
+ * `/api/v1/ws` wire frame builders — thin wrappers around the v1 wire message
+ * shapes (see the local `protocol/ws-control` catalog), ported from v1
  * (`packages/server/src/ws/protocol.ts`).
  *
  * Outbound payloads go straight to `JSON.stringify` — no Zod re-validation.
diff --git a/packages/kap-server/src/transport/ws/v1/sessionEventBroadcaster.ts b/packages/kap-server/src/transport/ws/v1/sessionEventBroadcaster.ts
index 6025c4d1f..1fb4ff5e4 100644
--- a/packages/kap-server/src/transport/ws/v1/sessionEventBroadcaster.ts
+++ b/packages/kap-server/src/transport/ws/v1/sessionEventBroadcaster.ts
@@ -30,7 +30,7 @@
  */
 
 import type {
-  AgentActivitySnapshot,
+  AgentActivityState,
   ApprovalResponse,
   DomainEvent,
   GlobalEvent,
@@ -38,40 +38,31 @@ import type {
   IDisposable,
   Interaction,
   InteractionKind,
-  ISessionActivity,
   ISessionScopeHandle,
   Scope,
 } from '@moonshot-ai/agent-core-v2';
 import {
   IAgentLifecycleService,
-  IAgentWireService,
+  IAgentActivityView,
   IEventBus,
   IEventService,
-  ISessionActivity as ISessionActivityService,
   ISessionInteractionService,
   ISessionIndex,
   ISessionLifecycleService,
   MAIN_AGENT_ID,
 } from '@moonshot-ai/agent-core-v2';
-import type {
-  Event,
-  InFlightTurn,
-  ModelCatalogChangedEvent,
-  SessionCreatedEvent,
-  SessionCursor,
-  SessionMetaUpdatedEvent,
-  SessionStatus,
-} from '@moonshot-ai/protocol';
-import { isVolatileEventType } from '@moonshot-ai/protocol';
+import type { TurnEndReason } from '@moonshot-ai/agent-core-v2/agent/loop/turnEvents';
+import type { SessionCreatedEvent, SessionMetaUpdatedEvent, Event } from './events';
+import { isVolatileEventType } from './events';
+import type { SessionCursor } from '../../../protocol/ws-control';
+import type { InFlightTurn, SnapshotSubagent } from '../../../protocol/rest-snapshot';
+import type { SessionPendingInteraction } from '../../../protocol/session';
 
 import { toWireApproval } from '../../../routes/approvals';
 import { toWireQuestion } from '../../../routes/questions';
-import {
-  LegacyStatusModel,
-  readLegacyStatus,
-  toLegacyPhase,
-} from '../../../services/legacyStatus/legacyStatus';
+import { readLegacyStatus, toLegacyPhase } from '../../../services/legacyStatus/legacyStatus';
 import { InFlightTurnTracker } from './inFlightTurnTracker';
+import { SubagentRosterTracker } from './subagentRosterTracker';
 import {
   type EventEnvelope,
   type JournalLogger,
@@ -93,6 +84,7 @@ export interface SessionSnapshotState {
   seq: number;
   epoch: string;
   inFlightTurn: InFlightTurn | null;
+  subagents: SnapshotSubagent[];
 }
 
 /** A connection (or test double) that receives sequenced envelopes. */
@@ -112,9 +104,22 @@ interface SessionState {
   readonly sessionId: string;
   readonly journal: SessionEventJournal;
   readonly tracker: InFlightTurnTracker;
-  readonly activity?: ISessionActivity;
-  /** Last status emitted (initialized from live session activity). */
-  lastStatus?: SessionStatus;
+  readonly roster: SubagentRosterTracker;
+  /**
+   * Per-agent fold of `agent.activity.updated` — the only input to the
+   * session's `work_changed` fact: `busy` = any agent with an active turn or
+   * background task, `last_turn_reason` = the main agent's latest outcome
+   * (`blocked` folds into `failed`). Session level stores nothing of its own;
+   * this map is a pure, discardable aggregate of agent-level state. Seeded
+   * once from the live views at activation.
+   */
+  readonly activityByAgent: Map<string, AgentWorkFold>;
+  /** Last emitted work-fact tuple, for dedup. */
+  emittedBusy: boolean;
+  emittedMainTurnActive: boolean;
+  emittedPendingInteraction: SessionPendingInteraction;
+  emittedTurnOutcome?: 'completed' | 'cancelled' | 'failed';
+  pendingInteraction: SessionPendingInteraction;
   /** Recent durable envelopes for in-memory replay. */
   readonly tail: Array<{ seq: number; envelope: EventEnvelope }>;
   /** Connections subscribed to this session, each with its optional agent allowlist. */
@@ -128,6 +133,13 @@ interface SessionState {
   readonly knownInteractions: Map<string, InteractionKind>;
 }
 
+/** The aggregate-relevant slice of one agent's activity state. */
+interface AgentWorkFold {
+  turnActive: boolean;
+  background: number;
+  lastTurnReason?: 'completed' | 'cancelled' | 'failed';
+}
+
 export const DEFAULT_MAX_BUFFER_SIZE = 1000;
 const GLOBAL_SESSION_ID = '__global__';
 
@@ -139,6 +151,18 @@ async function disposeSessionState(state: SessionState): Promise<void> {
 
 export class SessionEventBroadcaster {
   private readonly sessions = new Map<string, SessionState>();
+  /**
+   * Single-flight guard for session activation: without it, two concurrent
+   * activations (WS subscribe racing a REST snapshot / replay / resync) each
+   * built their own SessionState, bus subscriptions, and journal writer. The
+   * leaked listeners all route through `onAgentEvent`, which looks up the
+   * current state by session id, so they advance the SAME tracker and journal:
+   * one source delta is emitted at consecutive offsets and adjacent durable
+   * events receive distinct consecutive seqs. WS coalescing then folds the
+   * adjacent delta copies into one doubled payload, producing the observed
+   * per-chunk `AABBCC` stream while every seq and offset still looks valid.
+   */
+  private readonly pendingStates = new Map<string, Promise<SessionState | undefined>>();
   private readonly maxBufferSize: number;
   private readonly coreEventSubscription: IDisposable;
   private closed = false;
@@ -238,14 +262,15 @@ export class SessionEventBroadcaster {
     if (state === undefined) {
       const cold = await this.readColdWatermark(sessionId);
       return cold !== undefined
-        ? { ...cold, inFlightTurn: null }
-        : { seq: 0, epoch: '', inFlightTurn: null };
+        ? { ...cold, inFlightTurn: null, subagents: [] }
+        : { seq: 0, epoch: '', inFlightTurn: null, subagents: [] };
     }
     await state.queue;
     return {
       seq: state.journal.seq,
       epoch: state.journal.epoch,
       inFlightTurn: state.tracker.get(sessionId),
+      subagents: state.roster.get(sessionId),
     };
   }
 
@@ -280,10 +305,24 @@ export class SessionEventBroadcaster {
     this.sessions.clear();
   }
 
-  private async ensureState(sessionId: string): Promise<SessionState | undefined> {
+  private ensureState(sessionId: string): Promise<SessionState | undefined> {
+    if (this.closed) return Promise.resolve(undefined);
+    const existing = this.sessions.get(sessionId);
+    if (existing !== undefined) return Promise.resolve(existing);
+    let pending = this.pendingStates.get(sessionId);
+    if (pending === undefined) {
+      pending = this.createSessionState(sessionId).finally(() => {
+        if (this.pendingStates.get(sessionId) === pending) {
+          this.pendingStates.delete(sessionId);
+        }
+      });
+      this.pendingStates.set(sessionId, pending);
+    }
+    return pending;
+  }
+
+  private async createSessionState(sessionId: string): Promise<SessionState | undefined> {
     if (this.closed) return undefined;
-    let state = this.sessions.get(sessionId);
-    if (state !== undefined) return state;
 
     const session = this.opts.core.accessor.get(ISessionLifecycleService).get(sessionId);
     if (session === undefined) return undefined;
@@ -296,13 +335,24 @@ export class SessionEventBroadcaster {
       await journal.close();
       return undefined;
     }
-    const activity = session.accessor.get(ISessionActivityService);
-    state = {
+    const activityByAgent = new Map<string, AgentWorkFold>();
+    for (const handle of session.accessor.get(IAgentLifecycleService).list()) {
+      activityByAgent.set(handle.id, readAgentWorkFold(handle));
+    }
+    const pendingInteraction = resolvePendingInteraction(
+      session.accessor.get(ISessionInteractionService).listPending(),
+    );
+    const state: SessionState = {
       sessionId,
       journal,
       tracker: new InFlightTurnTracker(),
-      activity,
-      lastStatus: activity.status(),
+      roster: new SubagentRosterTracker(),
+      activityByAgent,
+      emittedBusy: aggregateBusy(activityByAgent),
+      emittedMainTurnActive: activityByAgent.get(MAIN_AGENT_ID)?.turnActive ?? false,
+      emittedPendingInteraction: pendingInteraction,
+      emittedTurnOutcome: activityByAgent.get(MAIN_AGENT_ID)?.lastTurnReason,
+      pendingInteraction,
       tail: [],
       targets: new Map(),
       queue: Promise.resolve(),
@@ -323,18 +373,36 @@ export class SessionEventBroadcaster {
     return state;
   }
 
-  private async ensureGlobalState(): Promise<SessionState> {
-    let state = this.sessions.get(GLOBAL_SESSION_ID);
-    if (state !== undefined) return state;
+  private ensureGlobalState(): Promise<SessionState> {
+    const existing = this.sessions.get(GLOBAL_SESSION_ID);
+    if (existing !== undefined) return Promise.resolve(existing);
+    let pending = this.pendingStates.get(GLOBAL_SESSION_ID);
+    if (pending === undefined) {
+      pending = this.createGlobalState().finally(() => {
+        if (this.pendingStates.get(GLOBAL_SESSION_ID) === pending) {
+          this.pendingStates.delete(GLOBAL_SESSION_ID);
+        }
+      });
+      this.pendingStates.set(GLOBAL_SESSION_ID, pending);
+    }
+    return pending as Promise<SessionState>;
+  }
 
+  private async createGlobalState(): Promise<SessionState> {
     const journal = await SessionEventJournal.open(
       sessionJournalPath(this.opts.eventsDir, GLOBAL_SESSION_ID),
       this.opts.logger,
     );
-    state = {
+    const state: SessionState = {
       sessionId: GLOBAL_SESSION_ID,
       journal,
       tracker: new InFlightTurnTracker(),
+      roster: new SubagentRosterTracker(),
+      activityByAgent: new Map(),
+      emittedBusy: false,
+      emittedMainTurnActive: false,
+      emittedPendingInteraction: 'none',
+      pendingInteraction: 'none',
       tail: [],
       targets: new Map(),
       queue: Promise.resolve(),
@@ -347,20 +415,6 @@ export class SessionEventBroadcaster {
   }
 
   private onCoreEvent(event: GlobalEvent): void {
-    if (event.type === 'event.model_catalog.changed') {
-      const payload = modelCatalogChangedPayload(event.payload);
-      if (payload === undefined) return;
-      const modelEvent: ModelCatalogChangedEvent = {
-        type: 'event.model_catalog.changed',
-        ...payload,
-      };
-      void this.dispatchGlobal({
-        ...modelEvent,
-        agentId: 'main',
-        sessionId: GLOBAL_SESSION_ID,
-      });
-      return;
-    }
     if (event.type === 'event.session.created') {
       const payload = sessionCreatedPayload(event.payload);
       if (payload === undefined) return;
@@ -377,7 +431,9 @@ export class SessionEventBroadcaster {
         session: payload.session,
         agentId: 'main',
         sessionId: payload.sessionId,
-      } as Event);
+      } as Event).catch((error: unknown) =>
+        this.logDispatchError(payload.sessionId, 'event.session.created', error),
+      );
       return;
     }
     if (event.type === 'session.meta.updated') {
@@ -398,7 +454,9 @@ export class SessionEventBroadcaster {
         ...payload,
         agentId: 'main',
         sessionId,
-      } as Event);
+      } as Event).catch((error: unknown) =>
+        this.logDispatchError(sessionId, 'session.meta.updated', error),
+      );
     }
   }
 
@@ -406,7 +464,7 @@ export class SessionEventBroadcaster {
     const state = await this.ensureGlobalState();
     state.queue = state.queue
       .then(() => this.dispatch(state, event, isVolatileEventType(event.type)))
-      .catch(() => {});
+      .catch((error: unknown) => this.logDispatchDropped(state.sessionId, event.type, error));
   }
 
   /**
@@ -431,26 +489,18 @@ export class SessionEventBroadcaster {
     if (state === undefined) return;
     state.queue = state.queue
       .then(() => this.dispatch(state, event, isVolatileEventType(event.type)))
-      .catch(() => {});
+      .catch((error: unknown) => this.logDispatchDropped(state.sessionId, event.type, error));
   }
 
   private attachAgents(sessionId: string, session: ISessionScopeHandle, state: SessionState): void {
     const agents = session.accessor.get(IAgentLifecycleService);
     const subscribeAgent = (handle: IAgentScopeHandle): void => {
       if (state.agentDisposables.has(handle.id)) return;
-      // Every domain emits live events via the per-agent `IEventBus`; the bus is
-      // Agent-scoped, so this sees only this agent's events.
-      const eventBus = handle.accessor.get(IEventBus);
-      const busD = eventBus.subscribe((event) =>
-        this.onAgentEvent(sessionId, handle.id, event),
-      );
-      const disposables: IDisposable[] = [busD];
-      if (handle.id === MAIN_AGENT_ID) {
-        disposables.push(this.attachLegacyStatus(sessionId, handle));
+      if (!state.activityByAgent.has(handle.id)) {
+        state.activityByAgent.set(handle.id, readAgentWorkFold(handle));
+        this.enqueueWorkChanged(state);
       }
-      state.agentDisposables.set(handle.id, {
-        dispose: () => disposables.forEach((d) => d.dispose()),
-      });
+      state.agentDisposables.set(handle.id, this.attachAgent(sessionId, handle));
     };
     for (const handle of agents.list()) subscribeAgent(handle);
     state.lifecycleDisposables.push(
@@ -461,59 +511,62 @@ export class SessionEventBroadcaster {
           d.dispose();
           state.agentDisposables.delete(agentId);
         }
+        // A removed agent can no longer contribute work; drop its fold and
+        // re-evaluate the aggregate (its turn.ended normally lands first, but
+        // the delete keeps the map honest either way).
+        if (state.activityByAgent.delete(agentId)) this.enqueueWorkChanged(state);
       }),
     );
   }
 
-  /**
-   * Bridge the v2 split status slices into a single v1-style combined
-   * `agent.status.updated` event. The native v2 domains emit the usage /
-   * context-window / model slices independently, so a usage-only event can
-   * reach clients without the live contextTokens and overwrite it with a stale
-   * zero. Attaching the {@link LegacyStatusModel} to the main agent's wire and
-   * re-emitting a combined snapshot on every status-affecting Op keeps the
-   * context window consistent on the wire.
-   */
-  private attachLegacyStatus(sessionId: string, handle: IAgentScopeHandle): IDisposable {
-    const wire = handle.accessor.get(IAgentWireService);
-    // The wire service is only present on a fully-materialized agent; stub /
-    // test agents and not-yet-restored agents may not expose it, in which case
-    // the native partial events are simply forwarded unchanged.
-    if (wire === undefined) return { dispose: () => {} };
-    const attachD = wire.attach(LegacyStatusModel);
-    let lastEmitted: string | undefined;
-    const subD = wire.subscribe(LegacyStatusModel, () => {
+  private attachAgent(sessionId: string, handle: IAgentScopeHandle): IDisposable {
+    const eventBus = handle.accessor.get(IEventBus);
+    let lastLegacyStatus: string | undefined;
+    const emitLegacyStatus = (): void => {
       const snapshot = readLegacyStatus(handle);
-      // Dedupe: the derived model bumps on every watched Op, but only fan out
-      // when the projected status actually changed.
+      if (snapshot === undefined) return;
       const key = JSON.stringify(snapshot);
-      if (key === lastEmitted) return;
-      lastEmitted = key;
+      if (key === lastLegacyStatus) return;
+      lastLegacyStatus = key;
       this.onAgentEvent(sessionId, MAIN_AGENT_ID, {
         type: 'agent.status.updated',
         ...snapshot,
       });
-    });
-    return {
-      dispose: () => {
-        subD.dispose();
-        attachD.dispose();
-      },
     };
+    const disposables: IDisposable[] = [
+      eventBus.subscribe((event) => {
+        let projected = event;
+        if (handle.id === MAIN_AGENT_ID && event.type === 'agent.status.updated') {
+          const snapshot = readLegacyStatus(handle);
+          if (snapshot !== undefined) {
+            lastLegacyStatus = JSON.stringify(snapshot);
+            projected = { ...event, ...snapshot };
+          }
+        }
+        if (handle.id === MAIN_AGENT_ID && event.type === 'context.spliced') {
+          emitLegacyStatus();
+        }
+        this.onAgentEvent(sessionId, handle.id, projected);
+      }),
+    ];
+
+    return { dispose: () => disposables.forEach((disposable) => disposable.dispose()) };
   }
 
   private onAgentEvent(sessionId: string, agentId: string, event: DomainEvent): void {
     const state = this.sessions.get(sessionId);
     if (state === undefined) return;
 
-    // Map the native v2 activity snapshot to the legacy v1 `agent.status.updated`
+    // Map the native v2 activity state to the legacy v1 `agent.status.updated`
     // phase slice at the edge, so the v1 channel picks up the corrected
     // semantics (approval-set, idle-after-ended) without the core engine
     // carrying v1 compatibility. The core's own `agent.status.updated` phase
     // slice is dropped here to avoid duplicate phase events; other slices
-    // (usage / context / plan / swarm) flow through unchanged.
+    // (usage / context / plan / swarm) flow through unchanged. The same event
+    // also feeds the session's work-fold aggregate (busy / last_turn_reason).
     if (event.type === 'agent.activity.updated') {
-      const phase = toLegacyPhase(event as unknown as AgentActivitySnapshot);
+      const snapshot = event as unknown as AgentActivityState;
+      const phase = toLegacyPhase(snapshot);
       if (phase !== undefined) {
         const wireEvent = {
           type: 'agent.status.updated',
@@ -523,7 +576,30 @@ export class SessionEventBroadcaster {
         } as unknown as Event;
         state.queue = state.queue
           .then(() => this.dispatch(state, wireEvent, true))
-          .catch(() => {});
+          .catch((error: unknown) => this.logDispatchDropped(state.sessionId, wireEvent.type, error));
+      }
+      // Fold into the aggregate. A turnActive flip always rides a
+      // turn.started/turn.ended boundary that fires right after this event
+      // (the view publishes synchronously inside it), so emission is left to
+      // that trigger to keep the busy:true-before / busy:false-after frame
+      // order. Everything else (background tasks, agent teardown) emits here.
+      const previous = state.activityByAgent.get(agentId);
+      const next = {
+        turnActive: snapshot.turn !== undefined,
+        background: snapshot.background?.length ?? 0,
+        lastTurnReason:
+          agentId === MAIN_AGENT_ID
+            ? mapTurnReason(snapshot.lastTurn?.reason)
+            : previous?.lastTurnReason,
+      };
+      state.activityByAgent.set(agentId, next);
+      if (
+        previous !== undefined &&
+        previous.turnActive === next.turnActive &&
+        (previous.background !== next.background ||
+          (agentId === MAIN_AGENT_ID && previous.lastTurnReason !== next.lastTurnReason))
+      ) {
+        this.enqueueWorkChanged(state);
       }
       return;
     }
@@ -539,24 +615,23 @@ export class SessionEventBroadcaster {
     // `DomainEventMap` payload types are deliberately wider than the protocol
     // contract, hence the assertion via `unknown`.
     const wireEvent = { ...event, agentId, sessionId } as unknown as Event;
+    // Turn boundaries are the emission TRIGGERS for `work_changed` (ordering:
+    // busy:true lands before the turn.started frame, busy:false after the
+    // turn.ended frame). The payload is computed from the per-agent fold —
+    // the view's activity update for this same boundary has already been
+    // folded in (it publishes synchronously inside the boundary dispatch,
+    // ahead of this handler). Every agent triggers: busy counts all agents'
+    // turns and background tasks; only the main agent feeds last_turn_reason.
     if (event.type === 'turn.started') {
-      // Status is authoritative protocol state: emit it before the turn event so
-      // clients enter running first. A pending interaction remains higher
-      // priority than running.
-      this.enqueueStatusChanged(state, pendingStatus(state.activity?.status()) ?? 'running');
+      this.enqueueWorkChanged(state);
     }
     const volatile = isVolatileSignal(event.type);
     state.queue = state.queue
       .then(() => this.dispatch(state, wireEvent, volatile))
-      .catch(() => {});
+      .catch((error: unknown) => this.logDispatchDropped(state.sessionId, wireEvent.type, error));
     if (event.type === 'turn.ended') {
-      // Emit completion after the turn event. Pending interactions remain higher
-      // priority; otherwise failed/cancelled/blocked turns abort and all others
-      // become idle.
-      const reason = (event as { reason?: unknown }).reason;
-      const terminalStatus =
-        reason === 'cancelled' || reason === 'failed' || reason === 'blocked' ? 'aborted' : 'idle';
-      this.enqueueStatusChanged(state, pendingStatus(state.activity?.status()) ?? terminalStatus);
+      // Emit completion after the turn event.
+      this.enqueueWorkChanged(state);
     }
     // v1 wire compat: fan the legacy `background.task.*` spelling out next to
     // the native `task.*` event (see `legacyTaskEvent`) so unchanged v1 clients
@@ -566,15 +641,15 @@ export class SessionEventBroadcaster {
     if (legacy !== undefined) {
       state.queue = state.queue
         .then(() => this.dispatch(state, legacy, volatile))
-        .catch(() => {});
+        .catch((error: unknown) => this.logDispatchDropped(state.sessionId, legacy.type, error));
     }
   }
 
   /**
    * Bridge the session's interaction kernel (approvals / questions) onto the
    * v1 event stream. The kernel only emits in-process notifications
-   * (`onDidChangePending` / `onDidResolve`), so the v1 protocol events and their
-   * authoritative session status transitions are synthesized here.
+   * (`onDidChangePending` / `onDidResolve`), so the v1 protocol events are
+   * synthesized here.
    */
   private attachInteractions(
     sessionId: string,
@@ -583,20 +658,21 @@ export class SessionEventBroadcaster {
   ): void {
     const interactions = session.accessor.get(ISessionInteractionService);
     // Seed silently: interactions already pending at activation are surfaced
-    // by the snapshot route (`pending_questions` / `pending_approvals`), and
-    // lastStatus was initialized from the same live activity state.
+    // by the snapshot route (`pending_questions` / `pending_approvals`).
     for (const i of interactions.listPending()) {
       state.knownInteractions.set(i.id, i.kind);
     }
     state.lifecycleDisposables.push(
       interactions.onDidChangePending(() => {
-        for (const i of interactions.listPending()) {
+        const pending = interactions.listPending();
+        state.pendingInteraction = resolvePendingInteraction(pending);
+        this.enqueueWorkChanged(state);
+        for (const i of pending) {
           if (state.knownInteractions.has(i.id)) continue;
           state.knownInteractions.set(i.id, i.kind);
           const event = interactionRequestedEvent(i, sessionId);
           if (event !== undefined) {
             this.enqueueDurable(state, event);
-            this.enqueueStatusChanged(state, state.activity!.status());
           }
         }
       }),
@@ -607,40 +683,90 @@ export class SessionEventBroadcaster {
         const event = interactionResolvedEvent(kind, id, response, sessionId);
         if (event !== undefined) {
           this.enqueueDurable(state, event);
-          this.enqueueStatusChanged(state, state.activity!.status());
         }
       }),
     );
   }
 
   private enqueueDurable(state: SessionState, event: Event): void {
-    state.queue = state.queue.then(() => this.dispatch(state, event, false)).catch(() => {});
+    state.queue = state.queue
+      .then(() => this.dispatch(state, event, false))
+      .catch((error: unknown) => this.logDispatchDropped(state.sessionId, event.type, error));
   }
 
-  private enqueueStatusChanged(state: SessionState, status: SessionStatus): void {
+  /**
+   * Emit `event.session.work_changed` when its orthogonal work-fact tuple
+   * actually changed. Activity facts come from the per-agent fold and pending
+   * interaction facts come from the session interaction kernel.
+   */
+  private enqueueWorkChanged(state: SessionState): void {
     state.queue = state.queue
       .then(async () => {
-        const previousStatus = state.lastStatus;
-        if (previousStatus === undefined || status === previousStatus) return;
-        state.lastStatus = status;
+        const busy = aggregateBusy(state.activityByAgent);
+        const mainTurnActive = state.activityByAgent.get(MAIN_AGENT_ID)?.turnActive ?? false;
+        const outcome = state.activityByAgent.get(MAIN_AGENT_ID)?.lastTurnReason;
+        if (
+          busy === state.emittedBusy &&
+          mainTurnActive === state.emittedMainTurnActive &&
+          state.pendingInteraction === state.emittedPendingInteraction &&
+          outcome === state.emittedTurnOutcome
+        ) {
+          return;
+        }
+        state.emittedBusy = busy;
+        state.emittedMainTurnActive = mainTurnActive;
+        state.emittedPendingInteraction = state.pendingInteraction;
+        state.emittedTurnOutcome = outcome;
         await this.dispatch(
           state,
           {
-            type: 'event.session.status_changed',
-            status,
-            previous_status: previousStatus,
+            type: 'event.session.work_changed',
+            busy,
+            main_turn_active: mainTurnActive,
+            pending_interaction: state.pendingInteraction,
+            last_turn_reason: outcome,
             agentId: 'main',
             sessionId: state.sessionId,
           } as Event,
           false,
         );
       })
-      .catch(() => {});
+      .catch((error: unknown) =>
+        this.logDispatchDropped(state.sessionId, 'event.session.work_changed', error),
+      );
+  }
+
+  /**
+   * Log a rejected `dispatchSessionEvent` promise — the session's scope was
+   * torn down mid-dispatch, or a non-disposed error escaped `ensureState`.
+   */
+  private logDispatchError(sessionId: string, eventType: string, error: unknown): void {
+    const logger = this.opts.logger;
+    if (logger === undefined) return;
+    if (logger.error !== undefined) {
+      logger.error({ sessionId, eventType, err: error }, 'session event dispatch failed');
+    } else {
+      logger.warn({ sessionId, eventType, err: error }, 'session event dispatch failed');
+    }
+  }
+
+  /**
+   * A queued dispatch rejected: the event is permanently lost (and, for durable
+   * events, the seq is skipped). Warn instead of swallowing it silently.
+   */
+  private logDispatchDropped(sessionId: string, eventType: string, error: unknown): void {
+    this.opts.logger?.warn(
+      { sessionId, eventType, err: error },
+      'session event dispatch failed; event dropped',
+    );
   }
 
   private async dispatch(state: SessionState, event: Event, volatile: boolean): Promise<void> {
-    const { journal, tracker, tail, targets, sessionId } = state;
+    const { journal, tracker, roster, tail, targets, sessionId } = state;
     const annotation = tracker.apply(sessionId, event);
+    // Same queue-discipline as the in-flight tracker: snapshot rebuilds must
+    // see exactly the roster as of the durable watermark.
+    roster.apply(sessionId, event);
 
     let envelope: EventEnvelope;
     if (volatile) {
@@ -658,7 +784,7 @@ export class SessionEventBroadcaster {
     }
 
     if (isGlobalEvent(event.type)) {
-      // Global events (session/workspace/config/model-catalog) are not agent
+      // Global events (session/workspace/config) are not agent
       // events — fan out to every subscriber regardless of any agent filter.
       for (const target of this.allTargets()) {
         try {
@@ -726,6 +852,43 @@ function isVolatileSignal(type: string): boolean {
   return volatileSignalTypeSet.has(type);
 }
 
+/**
+ * Fold one agent's live activity view into the aggregate slice. Defensive:
+ * a missing view (never ignited) folds to not-busy.
+ */
+function readAgentWorkFold(handle: IAgentScopeHandle): AgentWorkFold {
+  const view = handle.accessor.get(IAgentActivityView) as IAgentActivityView | undefined;
+  const state = view?.state();
+  return {
+    turnActive: state?.turn !== undefined,
+    background: state?.background.length ?? 0,
+    lastTurnReason: mapTurnReason(state?.lastTurn?.reason),
+  };
+}
+
+function mapTurnReason(
+  reason: TurnEndReason | undefined,
+): 'completed' | 'cancelled' | 'failed' | undefined {
+  if (reason === undefined) return undefined;
+  return reason === 'completed' ? 'completed' : reason === 'cancelled' ? 'cancelled' : 'failed';
+}
+
+/** `busy` = any agent has an active turn or live background tasks. */
+function aggregateBusy(map: ReadonlyMap<string, AgentWorkFold>): boolean {
+  for (const fold of map.values()) {
+    if (fold.turnActive || fold.background > 0) return true;
+  }
+  return false;
+}
+
+function resolvePendingInteraction(
+  pending: readonly Interaction[],
+): SessionPendingInteraction {
+  if (pending.some((interaction) => interaction.kind === 'approval')) return 'approval';
+  if (pending.some((interaction) => interaction.kind === 'question')) return 'question';
+  return 'none';
+}
+
 /**
  * v1 wire compatibility: map a native v2 background-task lifecycle event to its
  * pre-v2 spelling, returning `undefined` for every other event. The pre-v2
@@ -746,18 +909,13 @@ function legacyTaskEvent(event: DomainEvent, agentId: string, sessionId: string)
   return { ...event, type: legacyType, agentId, sessionId } as unknown as Event;
 }
 
-function pendingStatus(status: SessionStatus | undefined): SessionStatus | undefined {
-  return status === 'awaiting_approval' || status === 'awaiting_question' ? status : undefined;
-}
-
-/** Session/workspace/config/model-catalog events are broadcast to every connection. */
+/** Session/workspace/config events are broadcast to every connection. */
 function isGlobalEvent(type: string): boolean {
   return (
     type === 'session.meta.updated' ||
     type.startsWith('event.session.') ||
     type.startsWith('event.workspace.') ||
-    type.startsWith('event.config.') ||
-    type.startsWith('event.model_catalog.')
+    type.startsWith('event.config.')
   );
 }
 
@@ -767,7 +925,7 @@ function isGlobalEvent(type: string): boolean {
  * `filter`:
  *   - `filter === undefined` → receive every agent (legacy session-grained
  *     behavior);
- *   - global events (session/workspace/config/model-catalog) are not agent
+ *   - global events (session/workspace/config) are not agent
  *     events and always pass;
  *   - events without a string `agentId` (should not happen on the v1 wire,
  *     where the broadcaster stamps every event) pass defensively rather than
@@ -865,25 +1023,6 @@ function interactionResolvedEvent(
   }
 }
 
-function modelCatalogChangedPayload(
-  payload: unknown,
-): Pick<ModelCatalogChangedEvent, 'changed' | 'unchanged' | 'failed'> | undefined {
-  if (typeof payload !== 'object' || payload === null) return undefined;
-  const candidate = payload as Partial<ModelCatalogChangedEvent>;
-  if (
-    !Array.isArray(candidate.changed) ||
-    !Array.isArray(candidate.unchanged) ||
-    !Array.isArray(candidate.failed)
-  ) {
-    return undefined;
-  }
-  return {
-    changed: candidate.changed,
-    unchanged: candidate.unchanged,
-    failed: candidate.failed,
-  };
-}
-
 /**
  * Validate the `session.meta.updated` payload published on the core
  * `IEventService`. Both the first-prompt auto-title path
diff --git a/packages/kap-server/src/transport/ws/v1/sessionEventJournal.ts b/packages/kap-server/src/transport/ws/v1/sessionEventJournal.ts
index d07099e2e..a2a29ef5b 100644
--- a/packages/kap-server/src/transport/ws/v1/sessionEventJournal.ts
+++ b/packages/kap-server/src/transport/ws/v1/sessionEventJournal.ts
@@ -15,7 +15,7 @@
  *     file is unreadable/corrupt at open (we start a fresh journal) — clients
  *     holding cursors from the old epoch get `resync_required(epoch_changed)`.
  *   - Only durable events are written (volatile frames never touch the journal;
- *     see `VOLATILE_EVENT_TYPES` in `@moonshot-ai/protocol`).
+ *     see `VOLATILE_EVENT_TYPES` in `./events`).
  *
  * Durability model: `append()` is synchronous (callers need the seq immediately
  * for fan-out); bytes are flushed on a microtask-scheduled async batch.
@@ -32,8 +32,8 @@ const JOURNAL_VERSION = 1;
 
 /**
  * Wire event envelope — matches `wsEventEnvelopeSchema` /
- * `sessionEventMessageSchema` in `@moonshot-ai/protocol`. Defined locally so
- * the journal does not depend on the zod schema at runtime.
+ * `sessionEventMessageSchema` in the local `protocol/ws-control` catalog. Defined
+ * structurally so the journal does not depend on the zod schema at runtime.
  */
 export interface EventEnvelope {
   readonly type: string;
@@ -67,6 +67,7 @@ export interface JournalEntry {
 /** Minimal logger surface — keeps the journal decoupled from the server logger. */
 export interface JournalLogger {
   warn(obj: unknown, msg: string): void;
+  error?(obj: unknown, msg: string): void;
 }
 
 const noopLogger: JournalLogger = { warn: () => {} };
@@ -186,6 +187,10 @@ export class SessionEventJournal {
     if (this.flushPromise !== undefined) return;
     this.flushPromise = this.flushOnce().finally(() => {
       this.flushPromise = undefined;
+      // Appends that arrived while this flush was in flight are still pending:
+      // chain the next round instead of parking them until a later append (or
+      // `close()`) happens to trigger one.
+      if (this.pendingLines.length > 0) this.scheduleFlush();
     });
   }
 
diff --git a/packages/kap-server/src/transport/ws/v1/subagentRosterTracker.ts b/packages/kap-server/src/transport/ws/v1/subagentRosterTracker.ts
new file mode 100644
index 000000000..756ad8ab2
--- /dev/null
+++ b/packages/kap-server/src/transport/ws/v1/subagentRosterTracker.ts
@@ -0,0 +1,174 @@
+/**
+ * `SubagentRosterTracker` — accumulates the per-session roster of live
+ * subagent tasks so a reconnecting client can rebuild swarm cards from the
+ * session snapshot. The refresh flow subscribes at the snapshot watermark, so
+ * earlier `subagent.spawned` events — the only carriers of the swarm identity
+ * metadata — are never replayed to it.
+ *
+ * Ported from v1 (`packages/server/src/services/gateway/subagentRosterTracker.ts`),
+ * with two adaptations: a swarm member's own `turn.ended` never clears the
+ * roster (every agent's events flow through the same per-session dispatch
+ * queue here, unlike v1's firehose), and the main agent's `turn.ended` does
+ * not clear it either — the swarm result is only queued for the async wire
+ * append at that point, so clearing there would open a window where a
+ * reconnecting client sees neither the roster nor the transcript result.
+ *
+ * Without this roster a mid-swarm page refresh loses the swarm card's member
+ * list: REST `/tasks` only serves the main agent's background-task store
+ * (foreground swarm subagents never persist there), and later `subagent.*`
+ * events carry only the `subagentId`, so the identity metadata
+ * (`parentToolCallId` / `swarmIndex` / `description`) is unrecoverable until
+ * the swarm's `<agent_swarm_result>` tool output lands.
+ *
+ * Owned by the `SessionEventBroadcaster` and updated INSIDE its per-session
+ * dispatch queue — same pattern as `InFlightTurnTracker`, keeping the roster,
+ * the journal watermark, and the fan-out order mutually consistent.
+ *
+ * Lifetime: the roster is dropped when the main agent starts its NEXT turn —
+ * the previous turn's result record was queued for the async wire append
+ * before `turn.ended`, so by then it is durable in practice and the
+ * transcript takes over as the restore source (a queued/cron follow-up turn
+ * can still start inside the ms-scale flush gap; that window self-heals on
+ * the next refresh). If the main turn
+ * aborts (cancelled / failed / blocked), still-live entries are finalized as
+ * failed at `turn.ended` instead: the swarm dies with the turn and the abort
+ * path suppresses the members' own `subagent.failed` events. Background
+ * subagents (`run_in_background`) are excluded by design: they persist in the
+ * background-task store and are served by REST `/tasks`, so listing them here
+ * would duplicate the row after a refresh.
+ */
+
+import type { Event } from './events';
+import type { SnapshotSubagent } from '../../../protocol/rest-snapshot';
+
+const MAIN_AGENT_ID = 'main';
+
+export class SubagentRosterTracker {
+  private readonly bySession = new Map<string, Map<string, SnapshotSubagent>>();
+
+  apply(sessionId: string, event: Event): void {
+    switch (event.type) {
+      case 'subagent.spawned': {
+        // Background subagents persist in the main agent's background-task
+        // store and come back through REST `/tasks` after a refresh (keyed by
+        // task id) — tracking them here too would duplicate the row (keyed by
+        // agent id) and mis-target cancel/detail actions. The roster exists
+        // for the foreground/live-only subagents REST cannot serve.
+        if (event.runInBackground === true) return;
+        let roster = this.bySession.get(sessionId);
+        if (!roster) {
+          roster = new Map();
+          this.bySession.set(sessionId, roster);
+        }
+        roster.set(event.subagentId, {
+          id: event.subagentId,
+          session_id: sessionId,
+          kind: 'subagent',
+          description: event.description ?? event.subagentName ?? 'Sub Agent',
+          status: 'running',
+          subagent_phase: 'queued',
+          subagent_type: event.subagentName,
+          parent_tool_call_id: event.parentToolCallId === '' ? undefined : event.parentToolCallId,
+          swarm_index: event.swarmIndex,
+          run_in_background: event.runInBackground,
+          created_at: new Date().toISOString(),
+        });
+        return;
+      }
+      case 'subagent.started': {
+        const entry = this.bySession.get(sessionId)?.get(event.subagentId);
+        if (!entry) return;
+        entry.subagent_phase = 'working';
+        entry.suspended_reason = undefined;
+        // Keep an existing started_at: a resumed (previously suspended)
+        // subagent re-fires `subagent.started`.
+        entry.started_at ??= new Date().toISOString();
+        return;
+      }
+      case 'subagent.suspended': {
+        const entry = this.bySession.get(sessionId)?.get(event.subagentId);
+        if (!entry) return;
+        entry.subagent_phase = 'suspended';
+        entry.suspended_reason = event.reason;
+        return;
+      }
+      case 'subagent.completed': {
+        const entry = this.bySession.get(sessionId)?.get(event.subagentId);
+        if (!entry) return;
+        entry.subagent_phase = 'completed';
+        entry.status = 'completed';
+        entry.completed_at = new Date().toISOString();
+        entry.output_preview = event.resultSummary;
+        return;
+      }
+      case 'subagent.failed': {
+        const entry = this.bySession.get(sessionId)?.get(event.subagentId);
+        if (!entry) return;
+        entry.subagent_phase = 'failed';
+        entry.status = 'failed';
+        entry.completed_at = new Date().toISOString();
+        entry.output_preview = event.error;
+        return;
+      }
+      case 'task.started': {
+        // A foreground subagent that detaches (Ctrl+B / timeout) re-enters as
+        // a detached background task served by REST `/tasks` under a new task
+        // id — drop its roster entry so a refresh doesn't seed both the roster
+        // row (agent id) and the REST row (task id). Registration of a
+        // background spawn emits the same event, but those were never tracked
+        // here, so the delete is a no-op for them.
+        const info = event.info;
+        if (info.kind === 'agent' && info.detached === true && info.agentId !== undefined) {
+          this.bySession.get(sessionId)?.delete(info.agentId);
+        }
+        return;
+      }
+      case 'turn.ended': {
+        if (event.agentId !== MAIN_AGENT_ID) return;
+        const roster = this.bySession.get(sessionId);
+        if (roster === undefined || event.reason === 'completed') return;
+        // Aborted main turn (cancelled / failed / blocked): the swarm dies
+        // with it, and the abort path suppresses the members' own
+        // `subagent.failed` events — finalize any still-live entries here so a
+        // refresh doesn't seed phantom `running` subagents that no later
+        // lifecycle event would correct. The roster itself stays until the
+        // next main `turn.started`, same as the completed path.
+        for (const entry of roster.values()) {
+          if (entry.status !== 'running') continue;
+          entry.status = 'failed';
+          entry.subagent_phase = 'failed';
+          entry.completed_at = new Date().toISOString();
+          entry.output_preview ??= `Main turn ${event.reason}`;
+        }
+        return;
+      }
+      case 'turn.started': {
+        // Settle the roster when the main agent starts a NEW turn. The result
+        // record is queued for the async wire append before `turn.ended`, so
+        // by the next turn it is durable in practice; a queued/cron follow-up
+        // can still start inside the flush gap, but that window is ms-scale
+        // and self-heals on the next refresh once the flush lands. (Fully
+        // closing it needs the snapshot reader to read through the agent
+        // append log — deliberately left out of this change.) A subagent's
+        // own turn boundaries must never drop the roster mid-swarm.
+        if (event.agentId === MAIN_AGENT_ID) {
+          this.bySession.delete(sessionId);
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+
+  /** Fresh copies — callers must not mutate the tracked entries. */
+  get(sessionId: string): SnapshotSubagent[] {
+    const roster = this.bySession.get(sessionId);
+    if (!roster) return [];
+    return Array.from(roster.values(), (entry) => ({ ...entry }));
+  }
+
+  clear(sessionId: string): void {
+    this.bySession.delete(sessionId);
+  }
+}
diff --git a/packages/kap-server/src/transport/ws/v1/wsConnectionV1.ts b/packages/kap-server/src/transport/ws/v1/wsConnectionV1.ts
index 784d29503..8953acc0c 100644
--- a/packages/kap-server/src/transport/ws/v1/wsConnectionV1.ts
+++ b/packages/kap-server/src/transport/ws/v1/wsConnectionV1.ts
@@ -15,7 +15,7 @@
  * down.
  */
 
-import { WS_PROTOCOL_VERSION, type SessionCursor } from '@moonshot-ai/protocol';
+import { WS_PROTOCOL_VERSION, type SessionCursor } from '../../../protocol/ws-control';
 import { ulid } from 'ulid';
 import type { RawData, WebSocket } from 'ws';
 
diff --git a/packages/kap-server/src/transport/ws/wsConnection.ts b/packages/kap-server/src/transport/ws/wsConnection.ts
index 941b4251e..445508c74 100644
--- a/packages/kap-server/src/transport/ws/wsConnection.ts
+++ b/packages/kap-server/src/transport/ws/wsConnection.ts
@@ -26,12 +26,21 @@ import type { ScopeKind } from '../channel';
 import { dispatch, resolveScope, resolveService } from '../dispatcher';
 import { assertSerializable, mapError } from '../errors';
 import type { CredentialValidator } from '../../services/auth/credentials';
+import { ErrorCode } from '../../protocol/error-codes';
 import { resolveEventSource } from './eventMap';
 import type { CallMessage, ListenMessage, ServerMessage } from './wsProtocol';
 import { clientMessageSchema } from './wsProtocol';
 
 const DEFAULT_CALL_TIMEOUT_MS = 30_000;
 
+/** Minimal logger surface — keeps the connection decoupled from the server logger. */
+export interface WsConnectionLogger {
+  warn(obj: unknown, msg: string): void;
+  error(obj: unknown, msg: string): void;
+}
+
+const noopLogger: WsConnectionLogger = { warn: () => {}, error: () => {} };
+
 interface PendingEntry {
   /** Dispose the listener / drop the call result. */
   readonly cancel: () => void;
@@ -54,6 +63,8 @@ export interface WsConnectionOptions {
   readonly remoteAddress: string | null;
   /** `User-Agent` header from the upgrade request. Null when absent. */
   readonly userAgent: string | null;
+  /** Server-side logger for dispatch / serialization / socket failures. */
+  readonly logger?: WsConnectionLogger;
 }
 
 export class WsConnection {
@@ -65,6 +76,7 @@ export class WsConnection {
   private readonly core: Scope;
   private readonly validateCredential?: CredentialValidator;
   private readonly callTimeoutMs: number;
+  private readonly logger: WsConnectionLogger;
 
   private closed = false;
   private gotHello = false;
@@ -82,10 +94,14 @@ export class WsConnection {
     this.core = opts.core;
     this.validateCredential = opts.validateCredential;
     this.callTimeoutMs = opts.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+    this.logger = opts.logger ?? noopLogger;
 
     this.socket.on('message', (data: RawData) => this.onMessage(data));
     this.socket.on('close', () => this.onClose());
-    this.socket.on('error', () => this.onClose());
+    this.socket.on('error', (err) => {
+      this.logger.warn({ err, connId: this.id }, 'ws socket error');
+      this.onClose();
+    });
 
     this.send({ type: 'ready' });
   }
@@ -203,6 +219,14 @@ export class WsConnection {
       if (settled || this.closed) return;
       this.pending.delete(msg.id);
       const env = mapError(error, msg.id);
+      // 50001 (incl. call timeout) is a server-side failure; mapped business
+      // codes are expected client outcomes — mirror the REST RPC route.
+      const ctx = { err: error, connId: this.id, service: msg.service, method: msg.method };
+      if (env.code === ErrorCode.INTERNAL_ERROR) {
+        this.logger.error(ctx, 'ws rpc call failed');
+      } else {
+        this.logger.warn(ctx, 'ws rpc call failed');
+      }
       this.send({ type: 'error', id: msg.id, code: env.code, msg: env.msg });
     }
   }
@@ -253,6 +277,12 @@ export class WsConnection {
       }
     } catch (error) {
       const env = mapError(error, msg.id);
+      const ctx = { err: error, connId: this.id, service: msg.service, event: msg.event };
+      if (env.code === ErrorCode.INTERNAL_ERROR) {
+        this.logger.error(ctx, 'ws listen failed');
+      } else {
+        this.logger.warn(ctx, 'ws listen failed');
+      }
       this.send({ type: 'error', id: msg.id, code: env.code, msg: env.msg });
       return;
     }
@@ -329,6 +359,12 @@ export class WsConnection {
       this.send({ type: 'event', id, eventId, data: wire });
     } catch (error) {
       const env = mapError(error, id);
+      // Serialization failures cancel the whole listen subscription below —
+      // log so the dropped event stream is diagnosable.
+      this.logger.warn(
+        { err: error, connId: this.id, event },
+        'ws event send failed; subscription cancelled',
+      );
       this.send({ type: 'error', id, code: env.code, msg: env.msg });
       this.cancel(id);
     }
diff --git a/packages/kap-server/test/auth.test.ts b/packages/kap-server/test/auth.test.ts
index 0a89af609..fcb92e213 100644
--- a/packages/kap-server/test/auth.test.ts
+++ b/packages/kap-server/test/auth.test.ts
@@ -2,7 +2,7 @@ import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { authSummarySchema, type AuthSummary } from '@moonshot-ai/protocol';
+import { authSummarySchema, type AuthSummary } from '@moonshot-ai/agent-core-v2/app/authLegacy/authLegacy';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
@@ -30,7 +30,7 @@ describe('server-v2 GET /api/v1/auth', () => {
       server = undefined;
     }
     if (home !== undefined) {
-      await rm(home, { recursive: true, force: true });
+      await rm(home, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
       home = undefined;
     }
   });
diff --git a/packages/kap-server/test/boot.test.ts b/packages/kap-server/test/boot.test.ts
index 3db723cab..f2a65b433 100644
--- a/packages/kap-server/test/boot.test.ts
+++ b/packages/kap-server/test/boot.test.ts
@@ -80,6 +80,35 @@ describe('server-v2 boot', () => {
     expect(oauthBody.data).toBeNull();
   });
 
+  it('reports opts.version as server_version instead of the package version', async () => {
+    home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-version-'));
+    server = await startServer({
+      host: '127.0.0.1',
+      port: 0,
+      homeDir: home,
+      logLevel: 'silent',
+      version: '9.9.9-host',
+    });
+
+    const base = `http://127.0.0.1:${server.port}`;
+    const meta = await authedFetch(server, base, '/api/v1/meta');
+    const metaBody = await meta.json() as {
+      code: number;
+      data: { server_version: string };
+    };
+    expect(metaBody.data.server_version).toBe('9.9.9-host');
+
+    // The host version is also what the lock advertises to status/ps clients.
+    const stored = JSON.parse(
+      await readFile(join(home, 'server', 'lock'), 'utf8'),
+    ) as LockContents;
+    expect(stored.host_version).toBe('9.9.9-host');
+
+    // ... and it backs the default product User-Agent.
+    const defaults = server.core.accessor.get(IHostRequestHeaders);
+    expect(defaults.headers['User-Agent']).toBe('kimi-code-cli/9.9.9-host');
+  });
+
   it('seeds a default product User-Agent that opts.seeds can override', async () => {
     home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-ua-'));
     server = await startServer({
diff --git a/packages/kap-server/test/config.test.ts b/packages/kap-server/test/config.test.ts
index 977cedea5..2ccced183 100644
--- a/packages/kap-server/test/config.test.ts
+++ b/packages/kap-server/test/config.test.ts
@@ -2,7 +2,7 @@ import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { configResponseSchema, type ConfigResponse } from '@moonshot-ai/protocol';
+import { configResponseSchema, type ConfigResponse } from '../src/protocol/rest-config';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
diff --git a/packages/kap-server/test/connections.test.ts b/packages/kap-server/test/connections.test.ts
index bcb4e9723..3b2f67b88 100644
--- a/packages/kap-server/test/connections.test.ts
+++ b/packages/kap-server/test/connections.test.ts
@@ -12,7 +12,7 @@ import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { connectionsListResponseSchema } from '@moonshot-ai/protocol';
+import { connectionsListResponseSchema } from '../src/protocol/rest-connection';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { WebSocket } from 'ws';
 
diff --git a/packages/kap-server/test/fs.test.ts b/packages/kap-server/test/fs.test.ts
index 25764d5b2..1fc7bc71b 100644
--- a/packages/kap-server/test/fs.test.ts
+++ b/packages/kap-server/test/fs.test.ts
@@ -1,9 +1,9 @@
-import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { chmod, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { IModelResolver } from '@moonshot-ai/agent-core-v2';
-import { ErrorCode } from '@moonshot-ai/protocol';
+import { ErrorCode } from '../src/protocol/error-codes';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
@@ -225,6 +225,49 @@ describe('server-v2 /api/v1/sessions/{sid}/fs:*', () => {
     expect(body.code).toBe(ErrorCode.FS_PATH_ESCAPES_SESSION);
   });
 
+  it('rejects reads and downloads that escape the workspace through a symlink', async () => {
+    const outside = await mkdtemp(join(tmpdir(), 'kimi-server-v2-fs-outside-'));
+    try {
+      await writeFile(join(outside, 'secret.txt'), 'top-secret');
+      await symlink(outside, join(work!, 'docs'), 'dir');
+      const id = await createSession();
+
+      const body = await postFs<null>(id, 'read', { path: 'docs/secret.txt' });
+      expect(body.code).toBe(ErrorCode.FS_PATH_ESCAPES_SESSION);
+
+      const res = await fetch(`${base}/api/v1/sessions/${id}/fs/docs/secret.txt:download`, {
+        headers: authHeaders(server as RunningServer),
+      } as never);
+      const downloadBody = (await res.json()) as Envelope<null>;
+      expect(downloadBody.code).toBe(ErrorCode.FS_PATH_ESCAPES_SESSION);
+    } finally {
+      await rm(outside, { recursive: true, force: true });
+    }
+  });
+
+  it('serves fs actions when the session cwd itself goes through a symlink', async () => {
+    const link = join(tmpdir(), `kimi-server-v2-fs-cwd-link-${process.pid}`);
+    await symlink(work!, link, 'dir');
+    try {
+      const res = await fetch(`${base}/api/v1/sessions`, {
+        method: 'POST',
+        headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
+        body: JSON.stringify({ metadata: { cwd: link } }),
+      } as never);
+      const body = (await res.json()) as Envelope<{ id: string }>;
+      expect(body.code).toBe(0);
+
+      await writeFile(join(work!, 'via-link.txt'), 'through-link');
+      const read = await postFs<{ content: string }>(body.data.id, 'read', {
+        path: 'via-link.txt',
+      });
+      expect(read.code).toBe(0);
+      expect(read.data.content).toBe('through-link');
+    } finally {
+      await rm(link, { force: true });
+    }
+  });
+
   it('GET fs/{path}:download streams the file and honors If-None-Match', async () => {
     await writeFile(join(work!, 'a.txt'), 'download-me');
     const id = await createSession();
diff --git a/packages/kap-server/test/hostExposure.e2e.test.ts b/packages/kap-server/test/hostExposure.e2e.test.ts
index da03e9a78..bdf6e7d2e 100644
--- a/packages/kap-server/test/hostExposure.e2e.test.ts
+++ b/packages/kap-server/test/hostExposure.e2e.test.ts
@@ -116,7 +116,7 @@ describe('real password path (verifyPassword)', () => {
     expect(res.status).toBe(200);
     expect(res.headers.get('x-content-type-options')).toBe('nosniff');
     expect(res.headers.get('content-security-policy')).toBe(
-      "default-src 'self'; img-src 'self' data: blob:",
+      "default-src 'self'; img-src 'self' data: blob:; font-src 'self' data:; form-action 'self'; base-uri 'none'; frame-ancestors 'self'",
     );
   });
 
diff --git a/packages/kap-server/test/inFlightTurnTracker.test.ts b/packages/kap-server/test/inFlightTurnTracker.test.ts
index d361d4047..1a6455333 100644
--- a/packages/kap-server/test/inFlightTurnTracker.test.ts
+++ b/packages/kap-server/test/inFlightTurnTracker.test.ts
@@ -2,7 +2,7 @@
  * `InFlightTurnTracker` — volatile accumulation + delta offsets.
  */
 
-import type { Event } from '@moonshot-ai/protocol';
+import type { Event } from '../src/transport/ws/v1/events';
 import { describe, expect, it } from 'vitest';
 
 import { InFlightTurnTracker } from '../src/transport/ws/v1/inFlightTurnTracker';
diff --git a/packages/kap-server/test/messages.test.ts b/packages/kap-server/test/messages.test.ts
index c5309e796..771bb7933 100644
--- a/packages/kap-server/test/messages.test.ts
+++ b/packages/kap-server/test/messages.test.ts
@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import {
   IAgentContextMemoryService,
   IAgentLifecycleService,
-  IAgentWireRecordService,
+  IWireService,
   ISessionLifecycleService,
   IModelResolver,
   type ContextMessage,
@@ -118,7 +118,7 @@ describe('server-v2 /api/v1/sessions/{sid}/messages', () => {
       agent.accessor.get(IAgentContextMemoryService).append(...messages);
       // Flush the wire log so the temp home is quiescent before afterEach rm's
       // it (macOS can ENOTEMPTY an rmdir while an append is still in flight).
-      await agent.accessor.get(IAgentWireRecordService).flush();
+      await agent.accessor.get(IWireService).flush();
     }
   }
 
@@ -299,7 +299,7 @@ describe('server-v2 /api/v1/sessions/{sid}/messages', () => {
       compactedCount: 3,
       tokensBefore: 100,
     });
-    await agent.accessor.get(IAgentWireRecordService).flush();
+    await agent.accessor.get(IWireService).flush();
 
     // The live read already serves the full transcript (pre-compaction prefix
     // + summary), matching v1's `/messages`. Capture the summary id so we can
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index ab49cd794..ac471db21 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -1,6 +1,6 @@
 import { mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { deflateSync } from 'node:zlib';
 
 import {
@@ -408,6 +408,145 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(notice.text).toContain('https://example.com/pic.avif');
   });
 
+  async function uploadFile(
+    bytes: Buffer,
+    mediaType: string,
+    name: string,
+  ): Promise<{ id: string; size: number }> {
+    const form = new FormData();
+    form.set('file', new Blob([bytes], { type: mediaType }), name);
+    const uploadRes = await fetch(`${base}/api/v1/files`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer),
+      body: form,
+    } as never);
+    const uploaded = (await uploadRes.json()) as Envelope<{ id: string; size: number }>;
+    expect(uploaded.code).toBe(0);
+    return uploaded.data;
+  }
+
+  // The path-reference notice for a materialized attachment ends with the
+  // absolute path: `Attached file "<name>" (<mime>, <n> bytes): <path> — open
+  // it with the Read tool`.
+  function attachedPathFrom(notice: string): string {
+    const match = /bytes\): (.+) — open it with the Read tool$/.exec(notice);
+    expect(match).not.toBeNull();
+    return match![1]!;
+  }
+
+  it('materializes an arbitrary file attachment into the session attachments dir', async () => {
+    const id = await createSession(home as string);
+    await createMainAgent(id);
+    const pdfBytes = Buffer.from('%PDF-1.4 fake pdf bytes');
+    const uploaded = await uploadFile(pdfBytes, 'application/pdf', 'report.pdf');
+
+    const submitted = await call<PromptItemWire>('POST', `/api/v1/sessions/${id}/prompts`, {
+      content: [
+        { type: 'text', text: 'summarize this' },
+        { type: 'file', file_id: uploaded.id, name: 'report.pdf', media_type: 'application/pdf', size: pdfBytes.length },
+      ],
+    });
+    expect(submitted.body.code).toBe(0);
+
+    const content = submitted.body.data.content as Array<{ type: string; text?: string }>;
+    expect(content).toHaveLength(2);
+    expect(content[0]).toEqual({ type: 'text', text: 'summarize this' });
+    const notice = content[1];
+    expect(notice?.type).toBe('text');
+    expect(notice?.text).toContain('Attached file "report.pdf"');
+    expect(notice?.text).toContain('application/pdf');
+    expect(notice?.text).toContain(`${pdfBytes.length} bytes`);
+    const attachedPath = attachedPathFrom(notice?.text ?? '');
+    expect(attachedPath).toContain('/attachments/');
+    expect(attachedPath.endsWith(`${uploaded.id}-report.pdf`)).toBe(true);
+    expect((await realpath(attachedPath)).startsWith(await realpath(home as string))).toBe(true);
+    expect(await readFile(attachedPath)).toEqual(pdfBytes);
+  });
+
+  it('materializes an uploaded SVG image as a path-referenced attachment', async () => {
+    // SVG is not a provider-accepted image format, but the bytes are still the
+    // user's content: keep them as a file the model can open by path instead
+    // of dropping them with an "[Image omitted]" notice.
+    const id = await createSession(home as string);
+    await createMainAgent(id);
+    const svgBytes = Buffer.from('<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"></svg>');
+    const uploaded = await uploadFile(svgBytes, 'image/svg+xml', 'vector.svg');
+
+    const submitted = await call<PromptItemWire>('POST', `/api/v1/sessions/${id}/prompts`, {
+      content: [{ type: 'image', source: { kind: 'file', file_id: uploaded.id } }],
+    });
+    expect(submitted.body.code).toBe(0);
+
+    const content = submitted.body.data.content as Array<{ type: string; text?: string }>;
+    expect(content).toHaveLength(1);
+    const notice = content[0];
+    expect(notice?.type).toBe('text');
+    expect(notice?.text).not.toContain('[Image omitted');
+    expect(notice?.text).toContain('"vector.svg"');
+    expect(notice?.text).toContain('image/svg+xml');
+    const attachedPath = attachedPathFrom(notice?.text ?? '');
+    expect(attachedPath).toContain('/attachments/');
+    expect(attachedPath.endsWith(`${uploaded.id}-vector.svg`)).toBe(true);
+    expect(await readFile(attachedPath)).toEqual(svgBytes);
+  });
+
+  it('persists an inline base64 image in an unsupported format as a path-referenced attachment', async () => {
+    const id = await createSession(home as string);
+    await createMainAgent(id);
+    const data = avifBytes();
+
+    const submitted = await call<PromptItemWire>('POST', `/api/v1/sessions/${id}/prompts`, {
+      content: [
+        {
+          type: 'image',
+          source: {
+            kind: 'base64',
+            media_type: 'image/avif',
+            data: data.toString('base64'),
+          },
+        },
+      ],
+    });
+    expect(submitted.body.code).toBe(0);
+
+    const content = submitted.body.data.content as Array<{ type: string; text?: string }>;
+    expect(content).toHaveLength(1);
+    const notice = content[0];
+    expect(notice?.type).toBe('text');
+    expect(notice?.text).not.toContain('[Image omitted');
+    // No original name exists for inline base64 — it is derived from the
+    // sniffed format and the file is addressed by content hash.
+    expect(notice?.text).toContain('"image.avif"');
+    expect(notice?.text).toContain('image/avif');
+    const attachedPath = attachedPathFrom(notice?.text ?? '');
+    expect(attachedPath).toContain('/attachments/');
+    expect(attachedPath.endsWith('-image.avif')).toBe(true);
+    expect(await readFile(attachedPath)).toEqual(data);
+  });
+
+  it('sanitizes an attachment file name before materializing it', async () => {
+    const id = await createSession(home as string);
+    await createMainAgent(id);
+    const scriptBytes = Buffer.from('#!/bin/sh\necho hi');
+    const uploaded = await uploadFile(scriptBytes, 'text/plain', '../../etc/evil.sh');
+
+    const submitted = await call<PromptItemWire>('POST', `/api/v1/sessions/${id}/prompts`, {
+      content: [
+        { type: 'file', file_id: uploaded.id, name: '../../etc/evil.sh', media_type: 'text/plain', size: scriptBytes.length },
+      ],
+    });
+    expect(submitted.body.code).toBe(0);
+
+    const content = submitted.body.data.content as Array<{ type: string; text?: string }>;
+    expect(content).toHaveLength(1);
+    const attachedPath = attachedPathFrom(content[0]?.text ?? '');
+    // The materialized file must stay inside the session's attachments dir —
+    // the `../` segments in the original name can never escape it.
+    expect(dirname(attachedPath).endsWith('/attachments')).toBe(true);
+    expect((await realpath(attachedPath)).startsWith(await realpath(home as string))).toBe(true);
+    expect(await readFile(attachedPath)).toEqual(scriptBytes);
+  });
+
   it('returns 40402 when aborting a prompt that already settled', async () => {
     const id = await createSession(home as string);
     await createMainAgent(id);
diff --git a/packages/kap-server/test/rateLimit.test.ts b/packages/kap-server/test/rateLimit.test.ts
index bdb932bc1..c668fa70c 100644
--- a/packages/kap-server/test/rateLimit.test.ts
+++ b/packages/kap-server/test/rateLimit.test.ts
@@ -97,6 +97,54 @@ describe('createAuthHook rate limiting', () => {
   });
 });
 
+describe('createAuthHook bypass policy (URL encoding)', () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    app = buildApp(undefined);
+    await app.ready();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  it('requires a token for percent-encoded /api/ paths', async () => {
+    // The router matches these against /api/v1/sessions; the auth hook must
+    // see the same decoded path instead of bypassing on the raw URL.
+    for (const url of ['/%61pi/v1/sessions', '/%61%70%69/v1/sessions']) {
+      const res = await app.inject({ method: 'GET', url });
+      expect(res.statusCode).toBe(401);
+    }
+  });
+
+  it('serves percent-encoded /api/ paths with a valid token', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: '/%61pi/v1/sessions',
+      headers: { authorization: `Bearer ${TOKEN}` },
+    });
+    expect(res.statusCode).toBe(200);
+  });
+
+  it('requires a token for percent-encoded meta documents', async () => {
+    const res = await app.inject({ method: 'GET', url: '/%6fpenapi.json' });
+    expect(res.statusCode).toBe(401);
+  });
+
+  it('still bypasses non-API paths without a token', async () => {
+    // No static route is registered, so a bypassed request falls through to
+    // the router's 404 instead of being rejected with 401.
+    const res = await app.inject({ method: 'GET', url: '/index.html' });
+    expect(res.statusCode).toBe(404);
+  });
+
+  it('still bypasses the healthz probe when percent-encoded', async () => {
+    const res = await app.inject({ method: 'GET', url: '/%61pi/v1/healthz' });
+    expect(res.statusCode).toBe(404);
+  });
+});
+
 describe('createAuthFailureLimiter (unit)', () => {
   afterEach(() => {
     vi.useRealTimers();
diff --git a/packages/kap-server/test/rpc.test.ts b/packages/kap-server/test/rpc.test.ts
index a46ad02d2..f91197a36 100644
--- a/packages/kap-server/test/rpc.test.ts
+++ b/packages/kap-server/test/rpc.test.ts
@@ -3,12 +3,12 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import {
+  IAgentActivityView,
   IAgentGoalService,
   IAgentLifecycleService,
   IAgentRPCService,
   IEventService,
   IPluginService,
-  ISessionActivity,
   ISessionIndex,
   ISessionLifecycleService,
   ISessionMetadata,
@@ -134,6 +134,12 @@ describe('server-v2 /api/v2 RPC', () => {
     await session.accessor.get(IAgentLifecycleService).create({ agentId: 'main' });
   }
 
+  async function createSubagent(sessionId: string, agentId: string): Promise<void> {
+    const session = server!.core.accessor.get(ISessionLifecycleService).get(sessionId);
+    if (session === undefined) throw new Error(`session ${sessionId} not found`);
+    await session.accessor.get(IAgentLifecycleService).create({ agentId });
+  }
+
   // --- Core scope -----------------------------------------------------------
 
   it('describes all channels via GET /api/v2/channels', async () => {
@@ -268,11 +274,15 @@ describe('server-v2 /api/v2 RPC', () => {
     expect(read2.body.data.title).toBe('renamed');
   });
 
-  it('returns session status', async () => {
+  it('reads agent activity state', async () => {
     const id = await createSession(home as string);
-    const { body } = await call<string>('POST', rpc('session', ISessionActivity, 'status', { sid: id }));
+    await createMainAgent(id);
+    const { body } = await call<{ lifecycle: string }>(
+      'POST',
+      rpc('agent', IAgentActivityView, 'state', { sid: id, aid: 'main' }),
+    );
     expect(body.code).toBe(0);
-    expect(['idle', 'running', 'awaiting_approval', 'awaiting_question']).toContain(body.data);
+    expect(body.data.lifecycle).toBe('ready');
   });
 
   it('archives a session', async () => {
@@ -433,6 +443,20 @@ describe('server-v2 /api/v2 RPC', () => {
     expect(duplicate.body.code).toBe(40913);
   });
 
+  it('rejects reflected goal helper access for subagents', async () => {
+    const id = await createSession(home as string);
+    await createSubagent(id, 'sub-1');
+
+    const { body } = await call<null>(
+      'POST',
+      rpc('agent', IAgentGoalService, 'clearInternal', { sid: id, aid: 'sub-1' }),
+      'user',
+    );
+
+    expect(body.code).toBe(40920);
+    expect(body.msg).toBe('Goals are only supported by the main agent');
+  });
+
   it('lists and installs plugins through RPC', async () => {
     const pluginRoot = await mkdtemp(join(tmpdir(), 'server-v2-plugin-source-'));
     try {
diff --git a/packages/kap-server/test/securityExposure.test.ts b/packages/kap-server/test/securityExposure.test.ts
index 4d4fdc06c..acef7b23a 100644
--- a/packages/kap-server/test/securityExposure.test.ts
+++ b/packages/kap-server/test/securityExposure.test.ts
@@ -73,7 +73,7 @@ describe('server-v2 exposure hardening hooks', () => {
     expect(res.headers['x-content-type-options']).toBe('nosniff');
     expect(res.headers['referrer-policy']).toBe('no-referrer');
     expect(res.headers['content-security-policy']).toBe(
-      "default-src 'self'; img-src 'self' data: blob:",
+      "default-src 'self'; img-src 'self' data: blob:; font-src 'self' data:; form-action 'self'; base-uri 'none'; frame-ancestors 'self'",
     );
     expect(res.headers['strict-transport-security']).toBeUndefined();
   });
diff --git a/packages/kap-server/test/sessionEventBroadcaster.test.ts b/packages/kap-server/test/sessionEventBroadcaster.test.ts
index e96e9c133..18df37e33 100644
--- a/packages/kap-server/test/sessionEventBroadcaster.test.ts
+++ b/packages/kap-server/test/sessionEventBroadcaster.test.ts
@@ -8,15 +8,20 @@ import { join } from 'node:path';
 
 import type { IScopeHandle, Scope } from '@moonshot-ai/agent-core-v2';
 import {
+  ContextSizeModel,
+  IAgentActivityView,
+  IAgentContextSizeService,
   IAgentLifecycleService,
+  IAgentProfileService,
+  IAgentUsageService,
   IEventBus,
   IEventService,
-  ISessionActivity,
   ISessionInteractionService,
   ISessionLifecycleService,
+  IWireService,
   SessionInteractionService,
 } from '@moonshot-ai/agent-core-v2';
-import type { AgentEvent } from '@moonshot-ai/protocol';
+import type { AgentEvent } from '../src/transport/ws/v1/events';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
@@ -29,9 +34,12 @@ import type { EventEnvelope } from '../src/transport/ws/v1/sessionEventJournal';
 // Fakes
 // ---------------------------------------------------------------------------
 
+/** The fake bus carries wire agent events and v2-internal ones alike. */
+type FakeBusEvent = { type: string };
+
 class FakeAgentBus {
-  private handlers: Array<(e: AgentEvent) => void> = [];
-  subscribe(handler: (e: AgentEvent) => void) {
+  private handlers: Array<(e: FakeBusEvent) => void> = [];
+  subscribe(handler: (e: FakeBusEvent) => void) {
     this.handlers.push(handler);
     return {
       dispose: () => {
@@ -40,7 +48,7 @@ class FakeAgentBus {
       },
     };
   }
-  emit(e: AgentEvent): void {
+  emit(e: FakeBusEvent): void {
     for (const h of [...this.handlers]) h(e);
   }
 }
@@ -65,11 +73,16 @@ class FakeAgentHandle {
   readonly kind = 2;
   readonly bus = new FakeAgentBus();
   readonly accessor;
+  private readonly services = new Map<unknown, unknown>();
   constructor(readonly id: string) {
+    this.services.set(IEventBus, this.bus);
     this.accessor = {
-      get: (t: unknown) => (t === IEventBus ? this.bus : undefined),
+      get: (token: unknown) => this.services.get(token),
     };
   }
+  set(token: unknown, service: unknown): void {
+    this.services.set(token, service);
+  }
   dispose(): void {}
 }
 
@@ -77,15 +90,14 @@ class FakeLifecycle {
   readonly handles: FakeAgentHandle[] = [];
   /** Real interaction kernel — served at the session accessor. */
   readonly interactions = new SessionInteractionService();
-  baseStatus: 'idle' | 'running' = 'idle';
-  readonly activity = {
-    status: () => {
-      if (this.interactions.listPending('approval').length > 0) return 'awaiting_approval';
-      if (this.interactions.listPending('question').length > 0) return 'awaiting_question';
-      return this.baseStatus;
-    },
-    isIdle: () => this.activity.status() === 'idle',
-  };
+  /**
+   * Mirrors the activity view's publication: every turn boundary re-emits an
+   * `agent.activity.updated` on the same bus, nested inside the boundary
+   * dispatch and ahead of the broadcaster's own subscription (registered
+   * later at attach time) — exactly the production ordering the fold relies
+   * on.
+   */
+  private readonly turnCounters = new Map<string, { dispose(): void }>();
   private createHandlers: Array<(h: IScopeHandle) => void> = [];
   private disposeHandlers: Array<(id: string) => void> = [];
   list(): readonly FakeAgentHandle[] {
@@ -104,6 +116,41 @@ class FakeLifecycle {
   }
   addAgent(id: string): FakeAgentHandle {
     const handle = new FakeAgentHandle(id);
+    handle.set(IAgentActivityView, {
+      state: () => ({ lifecycle: 'ready', background: [] }),
+    });
+    this.turnCounters.set(
+      id,
+      handle.bus.subscribe((e) => {
+        if (e.type === 'turn.started') {
+          handle.bus.emit(
+            agentEvent('agent.activity.updated', {
+              lifecycle: 'ready',
+              turn: {
+                turnId: (e as { turnId?: number }).turnId,
+                phase: 'running',
+                step: 0,
+                ending: false,
+                pendingApprovals: [],
+                activeToolCalls: [],
+                since: 0,
+              },
+              background: [],
+            }),
+          );
+        }
+        if (e.type === 'turn.ended') {
+          const ended = e as { turnId?: number; reason?: string };
+          handle.bus.emit(
+            agentEvent('agent.activity.updated', {
+              lifecycle: 'ready',
+              lastTurn: { turnId: ended.turnId, reason: ended.reason },
+              background: [],
+            }),
+          );
+        }
+      }),
+    );
     this.handles.push(handle);
     for (const cb of this.createHandlers) cb(handle as unknown as IScopeHandle);
     return handle;
@@ -111,6 +158,8 @@ class FakeLifecycle {
   removeAgent(id: string): void {
     const idx = this.handles.findIndex((h) => h.id === id);
     if (idx >= 0) this.handles.splice(idx, 1);
+    this.turnCounters.get(id)?.dispose();
+    this.turnCounters.delete(id);
     for (const cb of this.disposeHandlers) cb(id);
   }
 }
@@ -127,7 +176,6 @@ function makeCore(sessions: Map<string, FakeLifecycle>, eventBus = new FakeEvent
             const sessionAccessor = {
               get: (t: unknown) => {
                 if (t === IAgentLifecycleService) return lifecycle;
-                if (t === ISessionActivity) return lifecycle.activity;
                 if (t === ISessionInteractionService) return lifecycle.interactions;
                 return undefined;
               },
@@ -151,6 +199,13 @@ function collectingTarget(): { target: BroadcastTarget; envelopes: EventEnvelope
   return { target: { send: (e) => envelopes.push(e) }, envelopes };
 }
 
+// A real turn yields the event loop between `turn.started` and `turn.ended`,
+// and the broadcaster aggregates the fold when each queued work_changed task
+// runs. Back-to-back synchronous `bus.emit` calls never let the queue drain,
+// so every aggregate read would observe the final state. Tests therefore
+// `await bc.getCursor(...)` between turn boundaries to reproduce the
+// production interleaving (book → publish → drain → release → publish).
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -186,16 +241,28 @@ describe('SessionEventBroadcaster', () => {
     expect(await bc.subscribe('s1', target)).toBe(true);
 
     main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
-    main.bus.emit(agentEvent('turn.ended', { turnId: 1 }));
+    await bc.getCursor('s1'); // drain between the turn boundaries (see note above)
+    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
     await bc.getCursor('s1'); // drain
 
-    // `turn.started` emits a durable `event.session.status_changed(running)`
-    // ahead of it and `turn.ended` emits a durable
-    // `event.session.status_changed(idle)` after it, hence four durable events:
-    // status_changed, turn.started, turn.ended, status_changed.
-    expect(envelopes.map((e) => e.seq)).toEqual([1, 2, 3, 4]);
+    // `turn.started` emits a durable `event.session.work_changed(busy:true)`
+    // ahead of it and `turn.ended` emits a durable `work_changed(busy:false)`
+    // carrying the main turn outcome after it, hence four durable events:
+    // work_changed, turn.started, turn.ended, work_changed. (The volatile
+    // `agent.status.updated` phase frames projected from the activity fold
+    // ride alongside and are excluded here.)
+    const durable = envelopes.filter((e) => e.volatile !== true);
+    expect(durable.map((e) => e.seq)).toEqual([1, 2, 3, 4]);
+    expect(durable[0]).toMatchObject({
+      type: 'event.session.work_changed',
+      payload: { busy: true, last_turn_reason: undefined, agentId: 'main', sessionId: 's1' },
+    });
+    expect(durable[3]).toMatchObject({
+      type: 'event.session.work_changed',
+      payload: { busy: false, last_turn_reason: 'completed' },
+    });
     expect(envelopes.every((e) => e.epoch === envelopes[0]!.epoch)).toBe(true);
-    expect(envelopes[0]!.volatile).toBeUndefined();
+    expect(durable[0]!.volatile).toBeUndefined();
   });
 
   it('fans out volatile events with the current watermark + offset, not journaled', async () => {
@@ -205,20 +272,110 @@ describe('SessionEventBroadcaster', () => {
     const { target, envelopes } = collectingTarget();
     await bc.subscribe('s1', target);
 
-    main.bus.emit(agentEvent('turn.started', { turnId: 1 })); // durable seq 1
+    main.bus.emit(agentEvent('turn.started', { turnId: 1 })); // durable seq 2
     main.bus.emit(agentEvent('assistant.delta', { turnId: 1, delta: 'Hi' })); // volatile
     main.bus.emit(agentEvent('assistant.delta', { turnId: 1, delta: ' there' })); // volatile
     await bc.getCursor('s1');
 
-    const vol = envelopes.filter((e) => e.volatile === true);
+    const vol = envelopes.filter((e) => e.volatile === true && e.type === 'assistant.delta');
     expect(vol).toHaveLength(2);
-    // `turn.started` is now seq 2 (a durable status_changed takes seq 1), so
-    // the volatile deltas ride the watermark at 2.
+    // `turn.started` is now seq 2 (a durable work_changed takes seq 1), so
+    // the volatile deltas ride the watermark at 2. (The volatile
+    // agent.status.updated phase frame from the activity fold rides 0.)
     expect(vol.every((e) => e.seq === 2)).toBe(true); // rides the durable watermark
     expect(vol.map((e) => e.offset)).toEqual([0, 2]);
     expect((await bc.getCursor('s1')).seq).toBe(2); // seq did not advance
   });
 
+  it('projects main-agent status and context changes into complete v1 status events', async () => {
+    const lc = new FakeLifecycle();
+    const main = lc.addAgent('main');
+    let contextSize = 10;
+    const usage = {
+      total: { inputOther: 1, output: 2, inputCacheRead: 0, inputCacheCreation: 0 },
+    };
+    main.set(IAgentContextSizeService, {
+      get: () => ({ size: contextSize }),
+      rawSize: () => contextSize,
+    });
+    main.set(IAgentProfileService, {
+      getModel: () => 'example-model',
+      getModelCapabilities: () => ({ max_context_tokens: 128_000 }),
+    });
+    main.set(IAgentUsageService, { status: () => usage });
+    main.set(IWireService, {
+      getModel: (model: unknown) => {
+        expect(model).toBe(ContextSizeModel);
+        return { length: 0, tokens: 8 };
+      },
+    });
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+    await bc.subscribe('s1', target);
+
+    main.bus.emit(agentEvent('agent.status.updated', { usage }));
+    contextSize = 20;
+    main.bus.emit(agentEvent('context.spliced', { start: 0, deleteCount: 0, messages: [] }));
+    main.bus.emit(agentEvent('context.spliced', { start: 0, deleteCount: 0, messages: [] }));
+    await bc.getCursor('s1');
+
+    const statuses = envelopes.filter((envelope) => envelope.type === 'agent.status.updated');
+    expect(statuses).toHaveLength(2);
+    expect(statuses.map((envelope) => envelope.payload)).toMatchObject([
+      {
+        type: 'agent.status.updated',
+        usage,
+        contextTokens: 10,
+        maxContextTokens: 128_000,
+        model: 'example-model',
+      },
+      {
+        type: 'agent.status.updated',
+        usage,
+        contextTokens: 20,
+        maxContextTokens: 128_000,
+        model: 'example-model',
+      },
+    ]);
+  });
+
+  it('projects agent activity state into legacy running and ended phases', async () => {
+    const lc = new FakeLifecycle();
+    const main = lc.addAgent('main');
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+    await bc.subscribe('s1', target);
+
+    main.bus.emit(
+      agentEvent('agent.activity.updated', {
+        lifecycle: 'ready',
+        turn: {
+          turnId: 1,
+          origin: { kind: 'user' },
+          phase: 'running',
+          step: 1,
+          ending: false,
+          pendingApprovals: [],
+          activeToolCalls: [],
+          since: 100,
+        },
+      }),
+    );
+    main.bus.emit(
+      agentEvent('agent.activity.updated', {
+        lifecycle: 'ready',
+        lastTurn: { turnId: 1, reason: 'completed', at: 200 },
+      }),
+    );
+    await bc.getCursor('s1');
+
+    const statuses = envelopes.filter((envelope) => envelope.type === 'agent.status.updated');
+    expect(statuses.map((envelope) => envelope.payload)).toMatchObject([
+      { phase: { kind: 'running', turnId: 1, step: 1 } },
+      { phase: { kind: 'ended', turnId: 1, reason: 'completed' } },
+    ]);
+  });
+
   it('replays durable events since a cursor from the journal', async () => {
     const lc = new FakeLifecycle();
     const main = lc.addAgent('main');
@@ -227,14 +384,15 @@ describe('SessionEventBroadcaster', () => {
     await bc.subscribe('s1', target);
 
     main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
-    main.bus.emit(agentEvent('turn.ended', { turnId: 1 }));
+    await bc.getCursor('s1'); // drain between the turn boundaries
+    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
     await bc.getCursor('s1');
 
     const result = await bc.getBufferedSince('s1', { seq: 1 });
     expect(result.resyncRequired).toBe(false);
-    // seq 1 is the durable status_changed(running) (emitted ahead of
-    // turn.started); events after it are turn.started (2), turn.ended (3) and
-    // the durable status_changed(idle) (4) emitted on turn end.
+    // seq 1 is the durable work_changed(busy) emitted ahead of turn.started;
+    // events after it are turn.started (2), turn.ended (3) and the durable
+    // work_changed(busy:false + outcome) (4) emitted on turn end.
     expect(result.events.map((e) => e.seq)).toEqual([2, 3, 4]);
     expect(result.currentSeq).toBe(4);
   });
@@ -247,7 +405,7 @@ describe('SessionEventBroadcaster', () => {
     await bc.subscribe('s1', target);
 
     for (let i = 0; i < 5; i++) main.bus.emit(agentEvent('turn.started', { turnId: i }));
-    await bc.getCursor('s1'); // seq = 6 (one deduplicated running status + five turns), maxBufferSize = 3
+    await bc.getCursor('s1'); // seq = 6 (one deduplicated busy work_changed + five turns), maxBufferSize = 3
 
     const result = await bc.getBufferedSince('s1', { seq: 0 });
     expect(result.resyncRequired).toBe('buffer_overflow');
@@ -275,8 +433,9 @@ describe('SessionEventBroadcaster', () => {
     late.bus.emit(agentEvent('turn.started', { turnId: 7 }));
     await bc.getCursor('s1');
 
-    // status_changed (seq 1) is emitted ahead of turn.started (seq 2).
-    expect(envelopes.map((e) => e.seq)).toEqual([1, 2]);
+    // work_changed(busy) (seq 1) is emitted ahead of turn.started (seq 2);
+    // the volatile agent.status.updated phase frame rides alongside.
+    expect(envelopes.filter((e) => e.volatile !== true).map((e) => e.seq)).toEqual([1, 2]);
   });
 
   it('getSnapshotState returns the in-flight turn', async () => {
@@ -289,37 +448,58 @@ describe('SessionEventBroadcaster', () => {
     main.bus.emit(agentEvent('assistant.delta', { turnId: 1, delta: 'Hello' }));
     const snap = await bc.getSnapshotState('s1');
 
-    expect(snap.seq).toBe(2); // durable status_changed + turn.started advanced seq; the delta is volatile
+    expect(snap.seq).toBe(2); // durable work_changed + turn.started advanced seq; the delta is volatile
     expect(snap.inFlightTurn).toMatchObject({ turn_id: 1, assistant_text: 'Hello' });
   });
 
-  it('fans core model-catalog changes out to every session subscriber', async () => {
+  it('getSnapshotState returns the live subagent roster until the next main turn starts', async () => {
     const lc = new FakeLifecycle();
-    lc.addAgent('main');
+    const main = lc.addAgent('main');
+    const sub = lc.addAgent('agent-1');
     sessions.set('s1', lc);
-    const { target, envelopes } = collectingTarget();
-    await bc.subscribe('s1', target);
+    await bc.subscribe('s1', collectingTarget().target);
 
-    eventBus.emit({
-      type: 'event.model_catalog.changed',
-      payload: {
-        changed: [{ provider_id: 'managed:kimi-code', provider_name: 'Kimi Code', added: 1, removed: 0 }],
-        unchanged: [],
-        failed: [],
-      },
-    });
+    main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
+    main.bus.emit(
+      agentEvent('subagent.spawned', {
+        subagentId: 'agent-1',
+        subagentName: 'kimi-subagent',
+        parentToolCallId: 'tc_swarm_1',
+        description: 'task agent-1',
+        swarmIndex: 0,
+        runInBackground: false,
+      }),
+    );
+    main.bus.emit(agentEvent('subagent.started', { subagentId: 'agent-1' }));
 
-    await vi.waitFor(() => expect(envelopes).toHaveLength(1));
-    expect(envelopes[0]).toMatchObject({
-      type: 'event.model_catalog.changed',
-      seq: 1,
-      session_id: '__global__',
-      payload: {
-        type: 'event.model_catalog.changed',
-        agentId: 'main',
-        sessionId: '__global__',
-      },
-    });
+    const mid = await bc.getSnapshotState('s1');
+    expect(mid.subagents).toEqual([
+      expect.objectContaining({
+        id: 'agent-1',
+        kind: 'subagent',
+        description: 'task agent-1',
+        subagent_phase: 'working',
+        parent_tool_call_id: 'tc_swarm_1',
+        swarm_index: 0,
+        run_in_background: false,
+      }),
+    ]);
+
+    // A subagent's own turn.ended must not wipe the roster mid-swarm.
+    sub.bus.emit(agentEvent('turn.ended', { turnId: 2 }));
+    const still = await bc.getSnapshotState('s1');
+    expect(still.subagents).toHaveLength(1);
+
+    // The main turn.ended keeps the roster too: the swarm result may not be
+    // durable in the wire transcript yet (async append).
+    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
+    const ended = await bc.getSnapshotState('s1');
+    expect(ended.subagents).toHaveLength(1);
+
+    // The next main turn.started settles the transcript — the roster is dropped.
+    main.bus.emit(agentEvent('turn.started', { turnId: 2 }));
+    const next = await bc.getSnapshotState('s1');
+    expect(next.subagents).toEqual([]);
   });
 
   it('subscribe returns false for an unknown session', async () => {
@@ -415,12 +595,13 @@ describe('SessionEventBroadcaster', () => {
     expect(s1View.envelopes[0]!.volatile).toBeUndefined();
   });
 
-  it('emits a durable event.session.status_changed(running) ahead of turn.started', async () => {
-    // Regression: v2 derives the session status via ISessionActivity (a pure
-    // pull) and publishes nothing, so the WS stream never carried the running
-    // transition and kimi-web's Stop button never rendered. The broadcaster
-    // now re-emits the authoritative running status on turn.started, ahead of
-    // the turn event so the web projector's prompt_id binding applies after.
+  it('emits a durable event.session.work_changed(busy) ahead of turn.started', async () => {
+    // Regression: the session's busy fact exists only as the agents' activity
+    // state (nothing is published session-wide), so the WS stream never
+    // carried the busy transition and kimi-web's Stop button never rendered.
+    // The broadcaster aggregates the per-agent fold and re-emits it on
+    // turn.started, queued ahead of the turn event so clients enter the
+    // working state first.
     const lc = new FakeLifecycle();
     const main = lc.addAgent('main');
     sessions.set('s1', lc);
@@ -430,34 +611,31 @@ describe('SessionEventBroadcaster', () => {
     main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
     await bc.getCursor('s1');
 
-    expect(envelopes).toHaveLength(2);
-    expect(envelopes[0]).toMatchObject({
-      type: 'event.session.status_changed',
+    const durable = envelopes.filter((e) => e.volatile !== true);
+    expect(durable).toHaveLength(2);
+    expect(durable[0]).toMatchObject({
+      type: 'event.session.work_changed',
       seq: 1,
       session_id: 's1',
       payload: {
-        type: 'event.session.status_changed',
-        status: 'running',
-        previous_status: 'idle',
+        type: 'event.session.work_changed',
+        busy: true,
+        last_turn_reason: undefined,
         agentId: 'main',
         sessionId: 's1',
       },
     });
-    expect(envelopes[0]!.volatile).toBeUndefined();
-    expect(envelopes[1]).toMatchObject({ type: 'turn.started', seq: 2 });
+    expect(durable[0]!.volatile).toBeUndefined();
+    expect(durable[1]).toMatchObject({ type: 'turn.started', seq: 2 });
   });
 
-  it('emits a durable event.session.status_changed(idle) after turn.ended', async () => {
-    // Regression: v2 derives session status via ISessionActivity (a pure pull)
-    // and publishes nothing, and kimi-web's turn.ended projector deliberately
-    // does NOT synthesize a status flip — the daemon's
-    // `event.session.status_changed` is its only turn-end signal (it drives
-    // onSessionIdle queue flush and clears the Stop/loading state). Without
-    // this the session stayed `running` forever once a turn ended; most
-    // visibly for background tasks, where ISessionActivity keeps reporting
-    // non-idle while the detached task lives, so even a REST pull never
-    // corrected it. Emitted after turn.ended (same queue) so the web finishes
-    // the assistant message before flipping status.
+  it('emits a durable event.session.work_changed after turn.ended with the main turn outcome', async () => {
+    // Regression: kimi-web's turn.ended projector deliberately does NOT
+    // synthesize a busy flip — the daemon's `event.session.work_changed` is
+    // its only turn-end signal (it drives onSessionIdle queue flush and
+    // clears the Stop/loading state). Without it the session stayed busy
+    // forever once a turn ended. Emitted after turn.ended (same queue) so
+    // the web finishes the assistant message before flipping busy off.
     const lc = new FakeLifecycle();
     const main = lc.addAgent('main');
     sessions.set('s1', lc);
@@ -465,42 +643,194 @@ describe('SessionEventBroadcaster', () => {
     await bc.subscribe('s1', target);
 
     main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
+    await bc.getCursor('s1'); // drain between the turn boundaries
     main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
     await bc.getCursor('s1');
 
-    expect(envelopes).toHaveLength(4);
-    expect(envelopes[2]).toMatchObject({ type: 'turn.ended', seq: 3 });
-    expect(envelopes[3]).toMatchObject({
-      type: 'event.session.status_changed',
+    const durable = envelopes.filter((e) => e.volatile !== true);
+    expect(durable).toHaveLength(4);
+    expect(durable[2]).toMatchObject({ type: 'turn.ended', seq: 3 });
+    expect(durable[3]).toMatchObject({
+      type: 'event.session.work_changed',
       seq: 4,
       session_id: 's1',
       payload: {
-        type: 'event.session.status_changed',
-        status: 'idle',
-        previous_status: 'running',
+        type: 'event.session.work_changed',
+        busy: false,
+        last_turn_reason: 'completed',
         agentId: 'main',
         sessionId: 's1',
       },
     });
-    expect(envelopes[3]!.volatile).toBeUndefined();
+    expect(durable[3]!.volatile).toBeUndefined();
   });
 
-  it('emits event.session.status_changed(aborted) when a turn ends cancelled/failed/blocked', async () => {
+  it('maps the main turn outcome into last_turn_reason on the post-turn work_changed', async () => {
     const lc = new FakeLifecycle();
     const main = lc.addAgent('main');
     sessions.set('s1', lc);
     const { target, envelopes } = collectingTarget();
     await bc.subscribe('s1', target);
 
-    main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
-    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'cancelled' }));
+    for (const [turnId, reason] of [
+      [1, 'cancelled'],
+      [2, 'failed'],
+      [3, 'blocked'],
+    ] as const) {
+      main.bus.emit(agentEvent('turn.started', { turnId }));
+      await bc.getCursor('s1'); // drain between the turn boundaries
+      main.bus.emit(agentEvent('turn.ended', { turnId, reason }));
+      await bc.getCursor('s1');
+    }
+
+    const durable = envelopes.filter((e) => e.volatile !== true);
+    expect(durable).toHaveLength(12); // 3 × (work_changed + turn.started + turn.ended + work_changed)
+    const workChanged = durable.filter((e) => e.type === 'event.session.work_changed');
+    expect(workChanged.map((e) => e.payload)).toMatchObject([
+      { busy: true, last_turn_reason: undefined }, // a main turn.started clears the outcome
+      { busy: false, last_turn_reason: 'cancelled' },
+      { busy: true, last_turn_reason: undefined },
+      { busy: false, last_turn_reason: 'failed' },
+      { busy: true, last_turn_reason: undefined },
+      { busy: false, last_turn_reason: 'failed' }, // 'blocked' folds into 'failed'
+    ]);
+  });
+
+  it('flips busy from background tasks alone (no turn involved)', async () => {
+    // The second busy layer: an agent with a live background task (e.g. a
+    // detached Bash process) is busy even with no active turn. No turn
+    // boundaries fire here — the fold emits work_changed straight off the
+    // activity update.
+    const lc = new FakeLifecycle();
+    const main = lc.addAgent('main');
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+    await bc.subscribe('s1', target);
+
+    main.bus.emit(
+      agentEvent('agent.activity.updated', {
+        lifecycle: 'ready',
+        background: [{ kind: 'process', id: 'bash-1', since: 100 }],
+      }),
+    );
+    await bc.getCursor('s1');
+    main.bus.emit(agentEvent('agent.activity.updated', { lifecycle: 'ready', background: [] }));
     await bc.getCursor('s1');
 
-    const statuses = envelopes.filter((e) => e.type === 'event.session.status_changed');
-    expect(statuses.map((e) => e.payload)).toMatchObject([
-      { status: 'running', previous_status: 'idle' },
-      { status: 'aborted', previous_status: 'running' },
+    const workChanged = envelopes.filter((e) => e.type === 'event.session.work_changed');
+    expect(workChanged.map((e) => e.payload)).toMatchObject([
+      { busy: true, last_turn_reason: undefined },
+      { busy: false, last_turn_reason: undefined },
     ]);
+    // No turn, so the phase projection is `idle` — orthogonal to the busy
+    // fact (idle phase + busy session is exactly "background work only").
+    expect(envelopes.filter((e) => e.type === 'agent.status.updated').map((e) => e.payload))
+      .toMatchObject([{ phase: { kind: 'idle' } }, { phase: { kind: 'idle' } }]);
+  });
+
+  it('emits the first background-work change from an agent created after activation', async () => {
+    const lc = new FakeLifecycle();
+    lc.addAgent('main');
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+    await bc.subscribe('s1', target);
+
+    const late = lc.addAgent('agent-0');
+    late.bus.emit(
+      agentEvent('agent.activity.updated', {
+        lifecycle: 'ready',
+        background: [{ kind: 'process', id: 'bash-1', since: 100 }],
+      }),
+    );
+    await bc.getCursor('s1');
+
+    const workChanged = envelopes.filter((event) => event.type === 'event.session.work_changed');
+    expect(workChanged).toHaveLength(1);
+    expect(workChanged[0]?.payload).toMatchObject({ busy: true });
+  });
+
+  it('reports the main turn ending while sub-agent background work keeps busy true', async () => {
+    const lc = new FakeLifecycle();
+    const main = lc.addAgent('main');
+    const sub = lc.addAgent('agent-0');
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+    await bc.subscribe('s1', target);
+
+    sub.bus.emit(
+      agentEvent('agent.activity.updated', {
+        lifecycle: 'ready',
+        background: [{ kind: 'process', id: 'bash-1', since: 100 }],
+      }),
+    );
+    await bc.getCursor('s1');
+    main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
+    await bc.getCursor('s1');
+    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
+    await bc.getCursor('s1');
+
+    const workChanged = envelopes.filter((event) => event.type === 'event.session.work_changed');
+    expect(workChanged.map((event) => event.payload)).toMatchObject([
+      { busy: true, main_turn_active: false },
+      { busy: true, main_turn_active: true },
+      { busy: true, main_turn_active: false, last_turn_reason: 'completed' },
+    ]);
+  });
+
+  it('flips busy but never touches last_turn_reason from sub-agent turn boundaries', async () => {
+    // A sub-agent's turn.started/turn.ended stream over the same session
+    // channel with their own agentId. They DO drive `busy` (the drain registry
+    // counts every agent), but only the MAIN agent feeds `last_turn_reason`:
+    // a sub-agent's cancelled turn must not mark the session aborted, and its
+    // work does not clear a pending outcome. While the main turn is in flight
+    // the sub-agent's boundaries dedup to no-ops (busy stays true), so kimi-web
+    // never reads them as "the turn finished" (browser notification,
+    // completion sound, unread dot, queued message drain).
+    const lc = new FakeLifecycle();
+    const main = lc.addAgent('main');
+    const sub = lc.addAgent('agent-0');
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+    await bc.subscribe('s1', target);
+
+    main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
+    await bc.getCursor('s1'); // drain between the turn boundaries
+    // A foreground sub-agent runs and completes while the main turn is in flight.
+    sub.bus.emit(agentEvent('turn.started', { turnId: 10 }));
+    await bc.getCursor('s1');
+    sub.bus.emit(agentEvent('turn.ended', { turnId: 10, reason: 'completed' }));
+    await bc.getCursor('s1');
+    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
+    await bc.getCursor('s1');
+    // A sub-agent-only turn after the main one: busy flips emit work_changed,
+    // but the sub's cancelled outcome never lands in last_turn_reason.
+    sub.bus.emit(agentEvent('turn.started', { turnId: 11 }));
+    await bc.getCursor('s1');
+    sub.bus.emit(agentEvent('turn.ended', { turnId: 11, reason: 'cancelled' }));
+    await bc.getCursor('s1');
+
+    // The sub-agent's turn events are still fanned out (clients render them in
+    // the task view).
+    expect(
+      envelopes
+        .filter((e) => e.type === 'turn.started' || e.type === 'turn.ended')
+        .map((e) => (e.payload as { agentId: string }).agentId),
+    ).toEqual(['main', 'agent-0', 'agent-0', 'main', 'agent-0', 'agent-0']);
+    const workChanged = envelopes.filter((e) => e.type === 'event.session.work_changed');
+    expect(workChanged.map((e) => e.payload)).toMatchObject([
+      { busy: true, last_turn_reason: undefined },
+      { busy: false, last_turn_reason: 'completed' },
+      { busy: true, last_turn_reason: 'completed' },
+      { busy: false, last_turn_reason: 'completed' },
+    ]);
+    // The sub-agent's 'cancelled' never surfaces as the session outcome, and
+    // the final busy flip fires exactly once, after the sub-agent's turn end.
+    expect(
+      workChanged.every(
+        (e) => (e.payload as { last_turn_reason?: string }).last_turn_reason !== 'cancelled',
+      ),
+    ).toBe(true);
+    expect(envelopes.at(-1)!.type).toBe('event.session.work_changed');
   });
 
   it('broadcasts question requested / answered as durable v1 events', async () => {
@@ -522,8 +852,13 @@ describe('SessionEventBroadcaster', () => {
 
     expect(envelopes).toHaveLength(2);
     expect(envelopes[0]).toMatchObject({
-      type: 'event.question.requested',
+      type: 'event.session.work_changed',
       seq: 1,
+      payload: { pending_interaction: 'question' },
+    });
+    expect(envelopes[1]).toMatchObject({
+      type: 'event.question.requested',
+      seq: 2,
       session_id: 's1',
       payload: {
         type: 'event.question.requested',
@@ -535,30 +870,27 @@ describe('SessionEventBroadcaster', () => {
         questions: [{ id: 'q_0', question: 'Pick one', options: [{ id: 'opt_0_0', label: 'A' }, { id: 'opt_0_1', label: 'B' }] }],
       },
     });
-    expect(envelopes[1]).toMatchObject({
-      type: 'event.session.status_changed',
-      payload: { status: 'awaiting_question', previous_status: 'idle' },
-    });
-    expect(envelopes[0]!.volatile).toBeUndefined();
+    expect(envelopes[1]!.volatile).toBeUndefined();
 
     lc.interactions.respond('q1', { answers: { q_0: 'opt_0_0' }, method: 'enter' });
     await bc.getCursor('s1');
 
     expect(envelopes).toHaveLength(4);
     expect(envelopes[2]).toMatchObject({
-      type: 'event.question.answered',
+      type: 'event.session.work_changed',
       seq: 3,
+      payload: { pending_interaction: 'none' },
+    });
+    expect(envelopes[3]).toMatchObject({
+      type: 'event.question.answered',
+      seq: 4,
       session_id: 's1',
       payload: {
         question_id: 'q1',
         answers: { q_0: 'opt_0_0' },
       },
     });
-    expect((envelopes[2]!.payload as { resolved_at?: string }).resolved_at).toBeTypeOf('string');
-    expect(envelopes[3]).toMatchObject({
-      type: 'event.session.status_changed',
-      payload: { status: 'idle', previous_status: 'awaiting_question' },
-    });
+    expect((envelopes[3]!.payload as { resolved_at?: string }).resolved_at).toBeTypeOf('string');
   });
 
   it('broadcasts question dismissed when resolved with null', async () => {
@@ -578,12 +910,10 @@ describe('SessionEventBroadcaster', () => {
 
     expect(envelopes.map((e) => e.type)).toEqual([
       'event.question.requested',
-      'event.session.status_changed',
       'event.question.dismissed',
-      'event.session.status_changed',
     ]);
-    expect(envelopes[2]!.payload).toMatchObject({ question_id: 'q1' });
-    expect((envelopes[2]!.payload as { dismissed_at?: string }).dismissed_at).toBeTypeOf('string');
+    expect(envelopes[1]!.payload).toMatchObject({ question_id: 'q1' });
+    expect((envelopes[1]!.payload as { dismissed_at?: string }).dismissed_at).toBeTypeOf('string');
   });
 
   it('broadcasts approval requested / resolved as durable v1 events', async () => {
@@ -608,8 +938,13 @@ describe('SessionEventBroadcaster', () => {
 
     expect(envelopes).toHaveLength(2);
     expect(envelopes[0]).toMatchObject({
-      type: 'event.approval.requested',
+      type: 'event.session.work_changed',
       seq: 1,
+      payload: { pending_interaction: 'approval' },
+    });
+    expect(envelopes[1]).toMatchObject({
+      type: 'event.approval.requested',
+      seq: 2,
       session_id: 's1',
       payload: {
         approval_id: 'a1',
@@ -621,18 +956,20 @@ describe('SessionEventBroadcaster', () => {
         tool_input_display: { kind: 'command', command: 'ls' },
       },
     });
-    expect(envelopes[1]).toMatchObject({
-      type: 'event.session.status_changed',
-      payload: { status: 'awaiting_approval', previous_status: 'idle' },
-    });
+    expect(envelopes[1]!.volatile).toBeUndefined();
 
     lc.interactions.respond('a1', { decision: 'approved', scope: 'session' });
     await bc.getCursor('s1');
 
     expect(envelopes).toHaveLength(4);
     expect(envelopes[2]).toMatchObject({
-      type: 'event.approval.resolved',
+      type: 'event.session.work_changed',
       seq: 3,
+      payload: { pending_interaction: 'none' },
+    });
+    expect(envelopes[3]).toMatchObject({
+      type: 'event.approval.resolved',
+      seq: 4,
       session_id: 's1',
       payload: {
         approval_id: 'a1',
@@ -640,65 +977,42 @@ describe('SessionEventBroadcaster', () => {
         scope: 'session',
       },
     });
-    expect((envelopes[2]!.payload as { resolved_at?: string }).resolved_at).toBeTypeOf('string');
-    expect(envelopes[3]).toMatchObject({
-      type: 'event.session.status_changed',
-      payload: { status: 'idle', previous_status: 'awaiting_approval' },
-    });
+    expect((envelopes[3]!.payload as { resolved_at?: string }).resolved_at).toBeTypeOf('string');
   });
 
-  it('keeps parallel interaction priority, dedupes status, and globally fans status out', async () => {
+  it('fans event.session.work_changed out to every connection, bypassing agent filters', async () => {
+    // `event.session.*` is a global event class: a work_changed journaled on
+    // s1 reaches subscribers of other sessions, and subscribers whose agent
+    // allowlist excludes 'main' (the work_changed payload is main-stamped but
+    // is not an agent event) — same bypass as the retired status_changed.
     const lc = new FakeLifecycle();
-    lc.baseStatus = 'running';
-    lc.addAgent('main');
+    const main = lc.addAgent('main');
     sessions.set('s1', lc);
     sessions.set('s2', new FakeLifecycle());
 
     const s1View = collectingTarget();
     const s2View = collectingTarget();
-    await bc.subscribe('s1', s1View.target);
+    await bc.subscribe('s1', s1View.target, new Set(['agent-0']));
     await bc.subscribe('s2', s2View.target);
 
-    lc.interactions.enqueue({
-      id: 'q1',
-      kind: 'question',
-      payload: { questions: [{ question: 'Pick', options: [{ label: 'A' }] }] },
-    });
-    lc.interactions.enqueue({
-      id: 'a1',
-      kind: 'approval',
-      payload: { toolName: 'Bash', action: 'run' },
-    });
-    lc.interactions.respond('q1', { answers: { q_0: 'opt_0_0' } });
+    main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
+    await bc.getCursor('s1'); // drain between the turn boundaries
+    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
     await bc.getCursor('s1');
 
-    expect(
-      s1View.envelopes
-        .filter((e) => e.type === 'event.session.status_changed')
-        .map((e) => e.payload),
-    ).toMatchObject([
-      { status: 'awaiting_question', previous_status: 'running' },
-      { status: 'awaiting_approval', previous_status: 'awaiting_question' },
-    ]);
-    // Resolving the question does not restore running while approval remains.
-    expect(s1View.envelopes.at(-1)!.type).toBe('event.question.answered');
-    expect(s2View.envelopes.map((e) => e.type)).toEqual([
-      'event.session.status_changed',
-      'event.session.status_changed',
-    ]);
-
-    lc.interactions.respond('a1', { decision: 'approved' });
-    await bc.getCursor('s1');
-
-    expect(s1View.envelopes.at(-1)).toMatchObject({
-      type: 'event.session.status_changed',
-      payload: { status: 'running', previous_status: 'awaiting_approval' },
-    });
-    expect(s2View.envelopes.at(-1)).toMatchObject({
-      type: 'event.session.status_changed',
-      session_id: 's1',
-      payload: { status: 'running', previous_status: 'awaiting_approval' },
-    });
+    for (const view of [s1View, s2View]) {
+      expect(view.envelopes.map((e) => e.type)).toEqual([
+        'event.session.work_changed',
+        'event.session.work_changed',
+      ]);
+      expect(view.envelopes.every((e) => e.session_id === 's1')).toBe(true);
+      expect(view.envelopes.map((e) => e.payload)).toMatchObject([
+        { busy: true, last_turn_reason: undefined },
+        { busy: false, last_turn_reason: 'completed' },
+      ]);
+    }
+    // The filter still crops main's own turn events from the filtered view.
+    expect(s1View.envelopes.some((e) => e.type === 'turn.started')).toBe(false);
   });
 
   it('does not re-announce interactions already pending at activation, but still broadcasts their resolution', async () => {
@@ -720,13 +1034,11 @@ describe('SessionEventBroadcaster', () => {
     lc.interactions.respond('q0', { answers: { q_0: 'opt_0_0' } });
     await bc.getCursor('s1');
     expect(envelopes.map((e) => e.type)).toEqual([
+      'event.session.work_changed',
       'event.question.answered',
-      'event.session.status_changed',
     ]);
-    expect(envelopes[1]!.payload).toMatchObject({
-      status: 'idle',
-      previous_status: 'awaiting_question',
-    });
+    expect(envelopes[0]!.payload).toMatchObject({ pending_interaction: 'none' });
+    expect(envelopes[1]!.payload).toMatchObject({ question_id: 'q0' });
   });
 
   it('fans out the legacy background.task.* alias alongside native task.* for v1 clients', async () => {
@@ -784,7 +1096,9 @@ describe('SessionEventBroadcaster', () => {
     await bc.subscribe('s1', target, new Set(['main']));
 
     main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
-    main.bus.emit(agentEvent('turn.ended', { turnId: 1 }));
+    await bc.getCursor('s1'); // drain between the turn boundaries
+    main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
+    await bc.getCursor('s1');
     sub.bus.emit(agentEvent('turn.ended', { turnId: 1 }));
     await bc.getCursor('s1');
 
@@ -794,10 +1108,12 @@ describe('SessionEventBroadcaster', () => {
     expect(
       agentEnvs.every((e) => (e.payload as { agentId: string }).agentId === 'main'),
     ).toBe(true);
-    // `event.session.status_changed` is global (`event.session.*`) and bypasses
-    // the agent filter. The redundant idle transition from the sub-agent is deduped.
-    const statusEnvs = envelopes.filter((e) => e.type === 'event.session.status_changed');
-    expect(statusEnvs).toHaveLength(2);
+    // `event.session.work_changed` is global (`event.session.*`) and bypasses
+    // the agent filter. The sub-agent's turn.ended flips no busy bit (main's
+    // turn already ended, dedup keeps the pair) and never sets the outcome, so
+    // only the main agent's two transitions are delivered.
+    const workChanged = envelopes.filter((e) => e.type === 'event.session.work_changed');
+    expect(workChanged).toHaveLength(2);
   });
 
   it('delivers every agent event when no filter is set', async () => {
@@ -813,6 +1129,9 @@ describe('SessionEventBroadcaster', () => {
     sub.bus.emit(agentEvent('turn.ended', { turnId: 1 }));
     await bc.getCursor('s1');
 
+    // Main's turn.ended also journals a work_changed carrying its outcome
+    // (busy was already false, but the reason pair changed); the sub-agent's
+    // turn.ended touches neither.
     const agentIds = envelopes
       .filter((e) => e.type === 'turn.ended')
       .map((e) => (e.payload as { agentId: string }).agentId);
@@ -849,7 +1168,7 @@ describe('SessionEventBroadcaster', () => {
     sessions.set('s1', lc);
 
     // Dedicated broadcaster with a cap large enough to hold the full mixed
-    // turn/status sequence before the filter crop is exercised.
+    // turn/work_changed sequence before the filter crop is exercised.
     const dir2 = await mkdtemp(join(tmpdir(), 'kimi-broadcaster-test-'));
     const bc2 = new SessionEventBroadcaster({
       eventsDir: dir2,
@@ -861,17 +1180,23 @@ describe('SessionEventBroadcaster', () => {
       const warm = collectingTarget();
       await bc2.subscribe('s1', warm.target);
       main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
-      main.bus.emit(agentEvent('turn.ended', { turnId: 1 }));
+      await bc2.getCursor('s1'); // drain between the turn boundaries
+      main.bus.emit(agentEvent('turn.ended', { turnId: 1, reason: 'completed' }));
+      await bc2.getCursor('s1');
       sub.bus.emit(agentEvent('turn.started', { turnId: 1 }));
+      await bc2.getCursor('s1');
       sub.bus.emit(agentEvent('turn.ended', { turnId: 1 }));
+      await bc2.getCursor('s1');
       main.bus.emit(agentEvent('turn.started', { turnId: 2 }));
-      main.bus.emit(agentEvent('turn.ended', { turnId: 2 }));
+      await bc2.getCursor('s1');
+      main.bus.emit(agentEvent('turn.ended', { turnId: 2, reason: 'completed' }));
       await bc2.getCursor('s1');
 
       const result = await bc2.getBufferedSince('s1', { seq: 0 }, new Set(['main']));
       expect(result.resyncRequired).toBe(false);
-      // The sub-agent's turn events are cropped, while global status transitions
-      // retain their original positions in the session sequence.
+      // The sub-agent's turn events are cropped (seq 6/7); its busy flips still
+      // journal work_changed (global, main-stamped — seq 5/8), which survives
+      // the crop alongside the main agent's turns and transitions.
       expect(result.events.map((e) => e.seq)).toEqual([1, 2, 3, 4, 5, 8, 9, 10, 11, 12]);
       expect(
         result.events.every((e) => (e.envelope.payload as { agentId: string }).agentId === 'main'),
@@ -881,4 +1206,36 @@ describe('SessionEventBroadcaster', () => {
       await rm(dir2, { recursive: true, force: true });
     }
   });
+
+  it('fans each agent event out once when session activation calls race', async () => {
+    const lc = new FakeLifecycle();
+    const main = lc.addAgent('main');
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+
+    await Promise.all([
+      bc.subscribe('s1', target),
+      bc.getSnapshotState('s1'),
+      bc.getBufferedSince('s1', { seq: 0 }),
+      bc.getCursor('s1'),
+      bc.getSnapshotState('s1'),
+    ]);
+    // Make the target observable from whichever state won the activation race.
+    // Before the single-flight fix, every losing state's leaked bus listener
+    // still routed through that winning state and advanced its tracker again.
+    await bc.subscribe('s1', target);
+
+    main.bus.emit(agentEvent('turn.started', { turnId: 1 }));
+    main.bus.emit(agentEvent('assistant.delta', { turnId: 1, delta: 'abc' }));
+    await bc.getCursor('s1');
+
+    expect(
+      envelopes
+        .filter((envelope) => envelope.type === 'assistant.delta')
+        .map((envelope) => ({
+          offset: envelope.offset,
+          delta: (envelope.payload as { delta: string }).delta,
+        })),
+    ).toEqual([{ offset: 0, delta: 'abc' }]);
+  });
 });
diff --git a/packages/kap-server/test/sessionEventJournal.test.ts b/packages/kap-server/test/sessionEventJournal.test.ts
index 0dc3e3a5f..33a62e099 100644
--- a/packages/kap-server/test/sessionEventJournal.test.ts
+++ b/packages/kap-server/test/sessionEventJournal.test.ts
@@ -2,7 +2,7 @@
  * `SessionEventJournal` — seq assignment, durability, recovery, epoch rotation.
  */
 
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -95,4 +95,27 @@ describe('SessionEventJournal', () => {
     expect(out).toEqual([]);
     await j.close();
   });
+
+  it('flushes appends that arrive while a flush is in flight', async () => {
+    const j = await SessionEventJournal.open(filePath);
+    // The first append starts an in-flight flush; the rest land in the same
+    // synchronous burst (while it runs) and must be chained into a follow-up
+    // round — not parked until a later append or `close()`.
+    for (let i = 1; i <= 12; i++) j.append(j.nextSeq(), envelope(i));
+    // Poll the raw file: `readSince`/`close` force a flush themselves and
+    // would mask a missing chained round.
+    const deadline = Date.now() + 2000;
+    let lines = 0;
+    while (Date.now() < deadline) {
+      try {
+        lines = (await readFile(filePath, 'utf8')).trim().split('\n').length;
+      } catch {
+        lines = 0;
+      }
+      if (lines >= 13) break; // header + 12 events
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    expect(lines).toBe(13);
+    await j.close();
+  });
 });
diff --git a/packages/kap-server/test/sessions.test.ts b/packages/kap-server/test/sessions.test.ts
index 375d822e7..f2ab43bdd 100644
--- a/packages/kap-server/test/sessions.test.ts
+++ b/packages/kap-server/test/sessions.test.ts
@@ -23,7 +23,7 @@ import {
   MAIN_AGENT_ID,
   type ServiceIdentifier,
 } from '@moonshot-ai/agent-core-v2';
-import { sessionWarningsResponseSchema } from '@moonshot-ai/protocol';
+import { sessionWarningsResponseSchema } from '@moonshot-ai/agent-core-v2/app/sessionLegacy/sessionProtocol';
 
 import { type RunningServer, startServer } from '../src/start';
 import { authHeaders } from './helpers/auth';
@@ -43,7 +43,10 @@ interface SessionWire {
   title: string;
   created_at: string;
   updated_at: string;
-  status: string;
+  busy: boolean;
+  main_turn_active: boolean;
+  pending_interaction: 'none' | 'approval' | 'question';
+  last_turn_reason?: 'completed' | 'cancelled' | 'failed';
   archived?: boolean;
   metadata: { cwd: string } & Record<string, unknown>;
   agent_config: { model: string };
@@ -219,7 +222,7 @@ describe('server-v2 /api/v1/sessions', () => {
     expect(body.details?.[0]?.path).toBe('web_log');
   });
 
-  async function createBlockedGoalRig() {
+  async function createStoppedGoalRig(status: 'paused' | 'blocked') {
     const cwd = home as string;
     const created = await postJson<SessionWire>('/api/v1/sessions', { metadata: { cwd } });
     const id = created.body.data.id;
@@ -237,10 +240,11 @@ describe('server-v2 /api/v1/sessions', () => {
     const events: DomainEvent[] = [];
     const subscription = eventBus.subscribe((event) => events.push(event));
 
-    const blocked = await postJson<{ status: string }>(agentRpc(IAgentGoalService, 'markBlocked', id), {
-      reason: 'need credentials',
-    });
-    if (blocked.body.data.status !== 'blocked') throw new Error('expected a blocked goal');
+    const stopped = await postJson<{ status: string }>(
+      agentRpc(IAgentGoalService, status === 'blocked' ? 'markBlocked' : 'pauseGoal', id),
+      status === 'blocked' ? { reason: 'need credentials' } : {},
+    );
+    if (stopped.body.data.status !== status) throw new Error(`expected a ${status} goal`);
 
     return {
       id,
@@ -255,6 +259,10 @@ describe('server-v2 /api/v1/sessions', () => {
     };
   }
 
+  async function createBlockedGoalRig() {
+    return createStoppedGoalRig('blocked');
+  }
+
   it('creates a session from metadata.cwd', async () => {
     const cwd = home as string;
     const { status, body } = await postJson<SessionWire>('/api/v1/sessions', {
@@ -267,7 +275,9 @@ describe('server-v2 /api/v1/sessions', () => {
     expect(typeof body.data.workspace_id).toBe('string');
     expect(body.data.title).toBe('hello');
     expect(body.data.metadata.cwd).toBe(cwd);
-    expect(body.data.status).toBe('idle');
+    expect(body.data.busy).toBe(false);
+    expect(body.data.main_turn_active).toBe(false);
+    expect(body.data.pending_interaction).toBe('none');
     expect(body.data.agent_config).toEqual({ model: '' });
     expect(body.data.permission_rules).toEqual([]);
     expect(body.data.message_count).toBe(0);
@@ -445,15 +455,13 @@ describe('server-v2 /api/v1/sessions', () => {
     const cwd = home as string;
     const created = await postJson<SessionWire>('/api/v1/sessions', { metadata: { cwd } });
     const { body } = await getJson<{
-      status: string;
+      busy: boolean;
       thinking_level: string;
       plan_mode: boolean;
       context_tokens: number;
     }>(`/api/v1/sessions/${created.body.data.id}/status`);
     expect(body.code).toBe(0);
-    expect(['idle', 'running', 'awaiting_approval', 'awaiting_question']).toContain(
-      body.data.status,
-    );
+    expect(body.data.busy).toBe(false);
     expect(typeof body.data.thinking_level).toBe('string');
     expect(typeof body.data.plan_mode).toBe('boolean');
     expect(body.data.context_tokens).toBe(0);
@@ -519,6 +527,20 @@ describe('server-v2 /api/v1/sessions', () => {
     }
   });
 
+  it('starts one continuation when the Web profile resumes a paused goal', async () => {
+    const rig = await createStoppedGoalRig('paused');
+    try {
+      const resumed = await postJson<SessionWire>(`/api/v1/sessions/${rig.id}/profile`, {
+        agent_config: { goal_control: 'resume' },
+      });
+
+      expect(resumed.body.code).toBe(0);
+      expect(goalContinuationStarts(rig.events)).toHaveLength(1);
+    } finally {
+      await rig.cancel();
+    }
+  });
+
   it('returns the active goal when the Web refreshes after blocked-goal resume', async () => {
     const rig = await createBlockedGoalRig();
     try {
@@ -774,7 +796,7 @@ describe('server-v2 /api/v1/sessions', () => {
     expect(body.code).toBe(40001);
   });
 
-  it('returns a terminal empty page when archived_only status filtering finds no match', async () => {
+  it('returns a terminal empty page when archived_only busy filtering finds no match', async () => {
     const cwd = home as string;
     const first = await postJson<SessionWire>('/api/v1/sessions', { metadata: { cwd } });
     const second = await postJson<SessionWire>('/api/v1/sessions', { metadata: { cwd } });
@@ -783,7 +805,7 @@ describe('server-v2 /api/v1/sessions', () => {
     await postJson<{ archived: boolean }>(`/api/v1/sessions/${second.body.data.id}:archive`);
 
     const page = await getJson<PageWire>(
-      '/api/v1/sessions?archived_only=true&status=running&page_size=1',
+      '/api/v1/sessions?archived_only=true&busy=true&page_size=1',
     );
     expect(page.body.code).toBe(0);
     expect(page.body.data).toEqual({ items: [], has_more: false });
@@ -799,36 +821,36 @@ describe('server-v2 /api/v1/sessions', () => {
     expect(body.code).toBe(40410);
   });
 
-  it('filters listed sessions by the status query (post-page, like v1)', async () => {
+  it('filters listed sessions by the busy query (post-page, like v1)', async () => {
     const cwd = home as string;
     const created = await postJson<SessionWire>('/api/v1/sessions', { metadata: { cwd } });
     const id = created.body.data.id;
-    // A freshly-created session has no turn, so the live activity is `idle` —
-    // the wire status is the resolved activity, not a constant placeholder.
-    expect(created.body.data.status).toBe('idle');
+    // A freshly-created session has no work, so it is not busy — the wire
+    // fact is the resolved drain-registry read, not a constant placeholder.
+    expect(created.body.data.busy).toBe(false);
 
-    const idle = await getJson<PageWire>('/api/v1/sessions?status=idle');
+    const idle = await getJson<PageWire>('/api/v1/sessions?busy=false');
     expect(idle.body.code).toBe(0);
     expect(idle.body.data.items.some((s) => s.id === id)).toBe(true);
 
-    const running = await getJson<PageWire>('/api/v1/sessions?status=running');
+    const running = await getJson<PageWire>('/api/v1/sessions?busy=true');
     expect(running.body.code).toBe(0);
     expect(running.body.data.items.some((s) => s.id === id)).toBe(false);
   });
 
-  it('filters child sessions by the status query', async () => {
+  it('filters child sessions by the busy query', async () => {
     const cwd = home as string;
     const parent = await postJson<SessionWire>('/api/v1/sessions', { metadata: { cwd } });
     const parentId = parent.body.data.id;
     const child = await postJson<SessionWire>(`/api/v1/sessions/${parentId}/children`, {});
     const childId = child.body.data.id;
-    expect(child.body.data.status).toBe('idle');
+    expect(child.body.data.busy).toBe(false);
 
-    const idle = await getJson<PageWire>(`/api/v1/sessions/${parentId}/children?status=idle`);
+    const idle = await getJson<PageWire>(`/api/v1/sessions/${parentId}/children?busy=false`);
     expect(idle.body.code).toBe(0);
     expect(idle.body.data.items.some((s) => s.id === childId)).toBe(true);
 
-    const running = await getJson<PageWire>(`/api/v1/sessions/${parentId}/children?status=running`);
+    const running = await getJson<PageWire>(`/api/v1/sessions/${parentId}/children?busy=true`);
     expect(running.body.code).toBe(0);
     expect(running.body.data.items.some((s) => s.id === childId)).toBe(false);
   });
diff --git a/packages/kap-server/test/skills.test.ts b/packages/kap-server/test/skills.test.ts
index 146ec8ec0..6a0286297 100644
--- a/packages/kap-server/test/skills.test.ts
+++ b/packages/kap-server/test/skills.test.ts
@@ -33,7 +33,7 @@ import {
 import {
   activateSkillResultSchema,
   listSkillsResponseSchema,
-} from '@moonshot-ai/protocol';
+} from '../src/protocol/rest-skill';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
@@ -185,6 +185,20 @@ describe('server-v2 /api/v1 skills', () => {
       expect(updateConfig).not.toHaveProperty('is_sub_skill');
       expect(updateConfig).not.toHaveProperty('isSubSkill');
     });
+
+    it('lists the check-kimi-code-docs builtin skill', async () => {
+      const id = await createSession();
+      const { body } = await getJson<{ skills: SkillWire[] }>(
+        `/api/v1/sessions/${id}/skills`,
+      );
+      expect(body.code).toBe(0);
+      const skills = listSkillsResponseSchema.parse(body.data).skills;
+
+      const docsSkill = skills.find((s) => s.name === 'check-kimi-code-docs');
+      expect(docsSkill).toBeDefined();
+      expect(docsSkill).toMatchObject({ source: 'builtin' });
+      expect(docsSkill?.description.length).toBeGreaterThan(0);
+    });
   });
 
   describe('POST /api/v1/sessions/{sid}/skills/{name}:activate', () => {
@@ -203,6 +217,21 @@ describe('server-v2 /api/v1 skills', () => {
       });
     });
 
+    it('derives the session title from the first skill activation', async () => {
+      const id = await createSession();
+      await createMainAgent(id);
+
+      const activated = await postJson<{ activated: boolean; skill_name: string }>(
+        `/api/v1/sessions/${id}/skills/update-config:activate`,
+        { args: '--help' },
+      );
+      expect(activated.body.code).toBe(0);
+
+      const got = await getJson<{ title: string }>(`/api/v1/sessions/${id}`);
+      expect(got.body.code).toBe(0);
+      expect(got.body.data.title).toBe('/update-config --help');
+    });
+
     it('returns 40415 for an unknown skill', async () => {
       const id = await createSession();
       await createMainAgent(id);
diff --git a/packages/kap-server/test/snapshot.test.ts b/packages/kap-server/test/snapshot.test.ts
index ad21a322e..2eb72beb7 100644
--- a/packages/kap-server/test/snapshot.test.ts
+++ b/packages/kap-server/test/snapshot.test.ts
@@ -14,14 +14,13 @@ import {
   IAgentLifecycleService,
   IAgentPromptService,
   ILogService,
-  ISessionActivity,
   ISessionInteractionService,
   ISessionContext,
   ISessionLifecycleService,
   ISessionMetadata,
   IWorkspaceRegistry,
 } from '@moonshot-ai/agent-core-v2';
-import { sessionSnapshotResponseSchema } from '@moonshot-ai/protocol';
+import { sessionSnapshotResponseSchema } from '../src/protocol/rest-snapshot';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { registerSnapshotRoutes } from '../src/routes/snapshot';
@@ -73,12 +72,14 @@ describe('server-v2 snapshot route enrichment', () => {
         ],
         [IAgentLifecycleService, { get: () => main }],
         [ISessionInteractionService, { listPending: () => [] }],
-        [ISessionActivity, { status: () => 'idle' }],
       ]),
     };
     const core = {
       accessor: fakeAccessor([
-        [ISessionLifecycleService, { resume: async () => session }],
+        [
+          ISessionLifecycleService,
+          { resume: async () => session, get: () => undefined },
+        ],
         [IWorkspaceRegistry, { get: async () => ({ root: '/workspace' }) }],
       ]),
     };
@@ -92,6 +93,20 @@ describe('server-v2 snapshot route enrichment', () => {
           thinking_text: '',
           running_tools: [],
         },
+        subagents: [
+          {
+            id: 'agent-1',
+            session_id: sessionId,
+            kind: 'subagent',
+            description: 'task agent-1',
+            status: 'running',
+            subagent_phase: 'working',
+            parent_tool_call_id: 'tc_swarm_1',
+            swarm_index: 0,
+            run_in_background: false,
+            created_at: new Date(now).toISOString(),
+          },
+        ],
       }),
     };
 
@@ -142,6 +157,16 @@ describe('server-v2 snapshot route enrichment', () => {
       assistant_text: 'Hello',
       current_prompt_id: promptId,
     });
+    expect(snap.subagents).toEqual([
+      expect.objectContaining({
+        id: 'agent-1',
+        kind: 'subagent',
+        subagent_phase: 'working',
+        parent_tool_call_id: 'tc_swarm_1',
+        swarm_index: 0,
+        run_in_background: false,
+      }),
+    ]);
   });
 });
 
diff --git a/packages/kap-server/test/snapshotReader.unit.test.ts b/packages/kap-server/test/snapshotReader.unit.test.ts
index c357bb3f7..c297e41ef 100644
--- a/packages/kap-server/test/snapshotReader.unit.test.ts
+++ b/packages/kap-server/test/snapshotReader.unit.test.ts
@@ -79,6 +79,7 @@ async function makeFixtureAsync(opts?: { cacheLimit?: number }): Promise<Fixture
         seq: broadcaster.seq,
         epoch: broadcaster.epoch,
         inFlightTurn: broadcaster.inFlightTurn as never,
+        subagents: [],
       }),
     } as never,
     logger: noopLogger,
@@ -160,10 +161,11 @@ describe('SnapshotReader.read', () => {
     await seedSession(f, 'sess_empty');
     const snap = await f.reader.read('sess_empty');
     expect(snap.session.id).toBe('sess_empty');
-    expect(snap.session.status).toBe('idle');
+    expect(snap.session.busy).toBe(false);
     expect(snap.messages.items).toEqual([]);
     expect(snap.messages.has_more).toBe(false);
     expect(snap.in_flight_turn).toBeNull();
+    expect(snap.subagents).toEqual([]);
     expect(snap.pending_approvals).toEqual([]);
     expect(snap.as_of_seq).toBe(0);
     expect(snap.epoch).toBe('ep_unit');
@@ -382,6 +384,58 @@ describe('SnapshotReader.read', () => {
     expect((snap.messages.items.at(-1)!.content[0] as { text: string }).text).toBe('m149');
   });
 
+  it('uses the wire record time as created_at, falling back and clamping to stay increasing', async () => {
+    const f = await makeFixtureAsync();
+    const createdAt = 1700000000000;
+    const t0 = 1700001000000;
+    await seedSession(f, 'sess_times', { createdAt });
+    await writeWire(f.sessionDir('sess_times'), [
+      { type: 'context.append_message', message: userMessage('one'), time: t0 },
+      // No time stamp → falls back to createdAt + index, which is earlier than
+      // the previous real time and gets clamped to previous + 1.
+      { type: 'context.append_message', message: userMessage('two') },
+      // A time stamp EARLIER than the previous entry → clamped to previous + 1.
+      { type: 'context.append_message', message: userMessage('three'), time: t0 - 5000 },
+    ]);
+    const snap = await f.reader.read('sess_times');
+    expect(snap.messages.items.map((m) => Date.parse(m.created_at))).toEqual([t0, t0 + 1, t0 + 2]);
+  });
+
+  it('synthesizes created_at from session createdAt + index when no record carries a time', async () => {
+    const f = await makeFixtureAsync();
+    const createdAt = 1700000000000;
+    await seedSession(f, 'sess_no_times', { createdAt });
+    await writeWire(f.sessionDir('sess_no_times'), [
+      { type: 'context.append_message', message: userMessage('a') },
+      { type: 'context.append_message', message: userMessage('b') },
+    ]);
+    const snap = await f.reader.read('sess_no_times');
+    expect(snap.messages.items.map((m) => Date.parse(m.created_at))).toEqual([
+      createdAt,
+      createdAt + 1,
+    ]);
+  });
+
+  it('maps record times by global index across the page offset', async () => {
+    const f = await makeFixtureAsync();
+    const createdAt = 1700000000000;
+    const base = 1700002000000;
+    await seedSession(f, 'sess_times_paged', { createdAt });
+    await writeWire(
+      f.sessionDir('sess_times_paged'),
+      Array.from({ length: 102 }, (_, i) => ({
+        type: 'context.append_message' as const,
+        message: userMessage(`m${i}`),
+        time: base + i * 1000,
+      })),
+    );
+    const snap = await f.reader.read('sess_times_paged');
+    expect(snap.messages.items).toHaveLength(100);
+    // The page starts at global index 2, so the first item carries record[2]'s time.
+    expect(Date.parse(snap.messages.items[0]!.created_at)).toBe(base + 2000);
+    expect(Date.parse(snap.messages.items.at(-1)!.created_at)).toBe(base + 101 * 1000);
+  });
+
   it('normalizes a v1-layout state.json (ISO timestamps, no id)', async () => {
     const f = await makeFixtureAsync();
     await seedSession(f, 'sess_v1', {
diff --git a/packages/kap-server/test/subagentRosterTracker.test.ts b/packages/kap-server/test/subagentRosterTracker.test.ts
new file mode 100644
index 000000000..dbfb0ec01
--- /dev/null
+++ b/packages/kap-server/test/subagentRosterTracker.test.ts
@@ -0,0 +1,191 @@
+/**
+ * `SubagentRosterTracker` — live subagent roster for snapshot rebuilds.
+ */
+
+import type { Event } from '../src/transport/ws/v1/events';
+import { describe, expect, it } from 'vitest';
+
+import { SubagentRosterTracker } from '../src/transport/ws/v1/subagentRosterTracker';
+
+const SID = 'sess_1';
+
+function ev(partial: Record<string, unknown>): Event {
+  return { agentId: 'main', sessionId: SID, ...partial } as unknown as Event;
+}
+
+function spawn(subagentId: string, extra: Record<string, unknown> = {}): Event {
+  return ev({
+    type: 'subagent.spawned',
+    subagentId,
+    subagentName: 'kimi-subagent',
+    parentToolCallId: 'tc_swarm_1',
+    description: `task ${subagentId}`,
+    swarmIndex: 0,
+    runInBackground: false,
+    ...extra,
+  });
+}
+
+describe('SubagentRosterTracker', () => {
+  it('seeds a roster entry from subagent.spawned with the swarm identity metadata', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1', { swarmIndex: 2 }));
+
+    expect(t.get(SID)).toEqual([
+      expect.objectContaining({
+        id: 'agent-1',
+        session_id: SID,
+        kind: 'subagent',
+        description: 'task agent-1',
+        status: 'running',
+        subagent_phase: 'queued',
+        subagent_type: 'kimi-subagent',
+        parent_tool_call_id: 'tc_swarm_1',
+        swarm_index: 2,
+        run_in_background: false,
+      }),
+    ]);
+  });
+
+  it('treats an empty parentToolCallId as absent', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1', { parentToolCallId: '' }));
+    expect(t.get(SID)[0]?.parent_tool_call_id).toBeUndefined();
+  });
+
+  it('skips background subagents — REST /tasks already serves them after a refresh', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1', { runInBackground: true }));
+    expect(t.get(SID)).toEqual([]);
+  });
+
+  it('drops the entry when a foreground subagent detaches into a background task', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1'));
+
+    const taskStarted = (detached: boolean): Event =>
+      ev({
+        type: 'task.started',
+        info: {
+          taskId: 'task_1',
+          kind: 'agent',
+          agentId: 'agent-1',
+          detached,
+          description: 'task agent-1',
+          status: 'running',
+          startedAt: 1,
+          endedAt: null,
+        },
+      });
+
+    // A still-foreground registration (not detached) must keep the entry.
+    t.apply(SID, taskStarted(false));
+    expect(t.get(SID)).toHaveLength(1);
+
+    // The detach transition hands the subagent to REST /tasks — drop the row.
+    t.apply(SID, taskStarted(true));
+    expect(t.get(SID)).toEqual([]);
+  });
+
+  it('follows the subagent phase transitions', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1'));
+    t.apply(SID, ev({ type: 'subagent.started', subagentId: 'agent-1' }));
+    expect(t.get(SID)[0]).toMatchObject({ subagent_phase: 'working' });
+    expect(t.get(SID)[0]?.started_at).toBeDefined();
+
+    t.apply(
+      SID,
+      ev({ type: 'subagent.suspended', subagentId: 'agent-1', reason: 'rate limit' }),
+    );
+    expect(t.get(SID)[0]).toMatchObject({
+      subagent_phase: 'suspended',
+      suspended_reason: 'rate limit',
+    });
+
+    // A resumed subagent re-fires started; the original started_at is kept.
+    const startedAt = t.get(SID)[0]?.started_at;
+    t.apply(SID, ev({ type: 'subagent.started', subagentId: 'agent-1' }));
+    expect(t.get(SID)[0]).toMatchObject({ subagent_phase: 'working', started_at: startedAt });
+    expect(t.get(SID)[0]?.suspended_reason).toBeUndefined();
+
+    t.apply(
+      SID,
+      ev({ type: 'subagent.completed', subagentId: 'agent-1', resultSummary: 'done' }),
+    );
+    expect(t.get(SID)[0]).toMatchObject({
+      subagent_phase: 'completed',
+      status: 'completed',
+      output_preview: 'done',
+    });
+    expect(t.get(SID)[0]?.completed_at).toBeDefined();
+  });
+
+  it('marks failures with the error preview', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1'));
+    t.apply(SID, ev({ type: 'subagent.failed', subagentId: 'agent-1', error: 'boom' }));
+    expect(t.get(SID)[0]).toMatchObject({
+      subagent_phase: 'failed',
+      status: 'failed',
+      output_preview: 'boom',
+    });
+  });
+
+  it('clears the roster on the next MAIN turn.started, not on any turn.ended', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1'));
+
+    // A swarm member's own turn.ended flows through the same session queue and
+    // must not drop the roster mid-swarm.
+    t.apply(SID, ev({ type: 'turn.ended', agentId: 'agent-1', turnId: 1 }));
+    expect(t.get(SID)).toHaveLength(1);
+
+    // The main turn.ended must not drop the roster either: the swarm result
+    // may still be queued behind the async wire append, and a refresh in that
+    // window would otherwise lose the member list.
+    t.apply(SID, ev({ type: 'turn.ended', agentId: 'main', turnId: 1, reason: 'completed' }));
+    expect(t.get(SID)).toHaveLength(1);
+
+    // The next main turn.started settles the previous transcript — safe to drop.
+    t.apply(SID, ev({ type: 'turn.started', agentId: 'main', turnId: 2 }));
+    expect(t.get(SID)).toEqual([]);
+  });
+
+  it('finalizes still-live entries when the main turn aborts', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1'));
+    t.apply(SID, spawn('agent-2'));
+    t.apply(SID, ev({ type: 'subagent.completed', subagentId: 'agent-2', resultSummary: 'done' }));
+
+    // The abort path suppresses the members' own subagent.failed events, so
+    // the tracker must settle them itself.
+    t.apply(SID, ev({ type: 'turn.ended', agentId: 'main', turnId: 1, reason: 'cancelled' }));
+
+    const entries = t.get(SID);
+    expect(entries[0]).toMatchObject({
+      id: 'agent-1',
+      status: 'failed',
+      subagent_phase: 'failed',
+      output_preview: 'Main turn cancelled',
+    });
+    expect(entries[0]?.completed_at).toBeDefined();
+    // Already-terminal entries are left untouched.
+    expect(entries[1]).toMatchObject({ id: 'agent-2', status: 'completed', output_preview: 'done' });
+  });
+
+  it('ignores lifecycle events for unknown subagents', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, ev({ type: 'subagent.started', subagentId: 'ghost' }));
+    t.apply(SID, ev({ type: 'subagent.completed', subagentId: 'ghost', resultSummary: 'x' }));
+    expect(t.get(SID)).toEqual([]);
+  });
+
+  it('returns fresh copies that callers cannot mutate back into the tracker', () => {
+    const t = new SubagentRosterTracker();
+    t.apply(SID, spawn('agent-1'));
+    const first = t.get(SID);
+    first[0]!.description = 'mutated';
+    expect(t.get(SID)[0]?.description).toBe('task agent-1');
+  });
+});
diff --git a/packages/kap-server/test/tasks.test.ts b/packages/kap-server/test/tasks.test.ts
index c617a4b45..c7a77c79d 100644
--- a/packages/kap-server/test/tasks.test.ts
+++ b/packages/kap-server/test/tasks.test.ts
@@ -258,6 +258,7 @@ describe('server-v2 /api/v1/sessions/{sid}/tasks', () => {
     );
     expect(cancelled.body.code).toBe(0);
     expect(cancelled.body.data).toEqual({ cancelled: true });
+    expect(tasks.getTask(taskId)?.stopReason).toBe('Aborted by the user');
 
     // The task is now terminal (killed → cancelled); a second cancel is a
     // conflict with the idempotent envelope shape.
diff --git a/packages/kap-server/test/terminals.test.ts b/packages/kap-server/test/terminals.test.ts
index 9d30dd320..872272df9 100644
--- a/packages/kap-server/test/terminals.test.ts
+++ b/packages/kap-server/test/terminals.test.ts
@@ -10,7 +10,8 @@ import {
   type TerminalProcess,
   type TerminalSpawnOptions,
 } from '@moonshot-ai/agent-core-v2';
-import { ErrorCode, type Terminal } from '@moonshot-ai/protocol';
+import { ErrorCode } from '../src/protocol/error-codes';
+import type { Terminal } from '@moonshot-ai/agent-core-v2/os/interface/terminal';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
diff --git a/packages/kap-server/test/tools.test.ts b/packages/kap-server/test/tools.test.ts
index 21a743273..d22ae9930 100644
--- a/packages/kap-server/test/tools.test.ts
+++ b/packages/kap-server/test/tools.test.ts
@@ -27,7 +27,7 @@ import {
 import {
   listMcpServersResponseSchema,
   listToolsResponseSchema,
-} from '@moonshot-ai/protocol';
+} from '../src/protocol/rest-tool';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
diff --git a/packages/kap-server/test/transport-errors.test.ts b/packages/kap-server/test/transport-errors.test.ts
index 3df290919..07d46e497 100644
--- a/packages/kap-server/test/transport-errors.test.ts
+++ b/packages/kap-server/test/transport-errors.test.ts
@@ -1,5 +1,11 @@
+/**
+ * Scenario: `/api/v2` transport error translation.
+ * Responsibilities: verify stable domain-to-wire mappings and the internal-error fallback.
+ * Wiring: real error mapper with in-process coded errors; no external boundaries.
+ * Run: `pnpm --filter @moonshot-ai/kap-server exec vitest run test/transport-errors.test.ts`.
+ */
 import { Error2, ErrorCodes } from '@moonshot-ai/agent-core-v2';
-import { ErrorCode } from '@moonshot-ai/protocol';
+import { ErrorCode } from '../src/protocol/error-codes';
 import { describe, expect, it } from 'vitest';
 
 import { mapError } from '../src/transport/errors';
@@ -13,6 +19,7 @@ describe('/api/v2 transport mapError', () => {
     [ErrorCodes.OS_FS_PERMISSION_DENIED, ErrorCode.FS_PERMISSION_DENIED],
     [ErrorCodes.STORAGE_IO_FAILED, ErrorCode.PERSISTENCE_FAILURE],
     [ErrorCodes.STORAGE_LOCKED, ErrorCode.PERSISTENCE_FAILURE],
+    [ErrorCodes.GOAL_UNSUPPORTED_AGENT, ErrorCode.GOAL_UNSUPPORTED_AGENT],
   ])('maps domain code %s to its wire equivalent', (code, wire) => {
     const env = mapError(new Error2(code, 'boom'), 'req-1');
     expect(env.code).toBe(wire);
diff --git a/packages/kap-server/test/workspaceFs.test.ts b/packages/kap-server/test/workspaceFs.test.ts
index 830a8fa9d..7665c57a6 100644
--- a/packages/kap-server/test/workspaceFs.test.ts
+++ b/packages/kap-server/test/workspaceFs.test.ts
@@ -19,8 +19,6 @@ interface BrowseEntryWire {
   name: string;
   path: string;
   is_dir: true;
-  is_git_repo: boolean;
-  branch?: string;
 }
 
 interface BrowseWire {
@@ -129,28 +127,9 @@ describe('server-v2 /api/v1 fs folder picker', () => {
     for (const entry of body.data.entries) {
       expect(entry.is_dir).toBe(true);
       expect(entry.path).toBe(join(await realpath(root), entry.name));
-      expect(typeof entry.is_git_repo).toBe('boolean');
     }
   });
 
-  it('annotates git repositories with the current branch', async () => {
-    const root = home as string;
-    const repo = join(root, 'repo');
-    await mkdir(join(repo, '.git'), { recursive: true });
-    await writeFile(join(repo, '.git', 'HEAD'), 'ref: refs/heads/main\n');
-    await mkdir(join(root, 'plain'));
-
-    const { body } = await getJson<BrowseWire>(
-      `/api/v1/fs:browse?path=${encodeURIComponent(root)}`,
-    );
-    expect(body.code).toBe(0);
-    const byName = new Map(body.data.entries.map((e) => [e.name, e]));
-    expect(byName.get('repo')?.is_git_repo).toBe(true);
-    expect(byName.get('repo')?.branch).toBe('main');
-    expect(byName.get('plain')?.is_git_repo).toBe(false);
-    expect(byName.get('plain')?.branch).toBeUndefined();
-  });
-
   it('sorts dot-directories after regular ones', async () => {
     const root = home as string;
     await mkdir(join(root, '.zeta'));
diff --git a/packages/kap-server/test/workspaces.test.ts b/packages/kap-server/test/workspaces.test.ts
index ad565e81e..5cc6026fb 100644
--- a/packages/kap-server/test/workspaces.test.ts
+++ b/packages/kap-server/test/workspaces.test.ts
@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -19,8 +19,6 @@ interface WorkspaceWire {
   id: string;
   root: string;
   name: string;
-  is_git_repo: boolean;
-  branch: string | null;
   created_at: string;
   last_opened_at: string;
   session_count: number;
@@ -100,12 +98,6 @@ describe('server-v2 /api/v1/workspaces', () => {
     return { status: res.status, body: (await res.json()) as Envelope<T> };
   }
 
-  /** Lay down a minimal git fixture: `.git/HEAD` referring to a branch. */
-  async function makeGitRepo(root: string, branch: string): Promise<void> {
-    await mkdir(join(root, '.git'), { recursive: true });
-    await writeFile(join(root, '.git', 'HEAD'), `ref: refs/heads/${branch}\n`, 'utf8');
-  }
-
   it('creates a workspace with the full wire shape', async () => {
     const root = home as string;
     const { status, body } = await postJson<WorkspaceWire>('/api/v1/workspaces', {
@@ -117,45 +109,11 @@ describe('server-v2 /api/v1/workspaces', () => {
     expect(body.data.root).toBe(root);
     expect(body.data.name).toBe('proj');
     expect(body.data.id).toMatch(/^wd_[a-z0-9._-]+_[0-9a-f]{12}$/);
-    expect(typeof body.data.is_git_repo).toBe('boolean');
-    expect(body.data.branch).toBeNull();
     expect(typeof body.data.session_count).toBe('number');
     expect(Number.isNaN(Date.parse(body.data.created_at))).toBe(false);
     expect(Number.isNaN(Date.parse(body.data.last_opened_at))).toBe(false);
   });
 
-  it('resolves branch from .git/HEAD (and null when detached)', async () => {
-    const repo = join(home as string, 'repo');
-    await makeGitRepo(repo, 'feature/x');
-    const created = await postJson<WorkspaceWire>('/api/v1/workspaces', { root: repo });
-    expect(created.body.data.is_git_repo).toBe(true);
-    expect(created.body.data.branch).toBe('feature/x');
-
-    const detached = join(home as string, 'detached');
-    await mkdir(join(detached, '.git'), { recursive: true });
-    await writeFile(
-      join(detached, '.git', 'HEAD'),
-      '0123456789abcdef0123456789abcdef01234567\n',
-      'utf8',
-    );
-    const det = await postJson<WorkspaceWire>('/api/v1/workspaces', { root: detached });
-    expect(det.body.data.is_git_repo).toBe(true);
-    expect(det.body.data.branch).toBeNull();
-  });
-
-  it('resolves branch through a .git worktree file', async () => {
-    const root = join(home as string, 'worktree');
-    const realGitDir = join(home as string, 'real-git');
-    await mkdir(realGitDir, { recursive: true });
-    await writeFile(join(realGitDir, 'HEAD'), 'ref: refs/heads/wt-branch\n', 'utf8');
-    await mkdir(root, { recursive: true });
-    await writeFile(join(root, '.git'), `gitdir: ${realGitDir}\n`, 'utf8');
-
-    const { body } = await postJson<WorkspaceWire>('/api/v1/workspaces', { root });
-    expect(body.data.is_git_repo).toBe(true);
-    expect(body.data.branch).toBe('wt-branch');
-  });
-
   it('derives the default name from the root when name is omitted', async () => {
     const root = home as string;
     const { body } = await postJson<WorkspaceWire>('/api/v1/workspaces', { root });
diff --git a/packages/klient/AGENTS.md b/packages/klient/AGENTS.md
new file mode 100644
index 000000000..3dff543f4
--- /dev/null
+++ b/packages/klient/AGENTS.md
@@ -0,0 +1,83 @@
+# klient Agent Guide
+
+Package-local rules for `packages/klient`.
+
+## Architecture
+
+The package is layered; keep the layers strict when changing code:
+
+- **Facade** (`src/core/facade/`, `src/core/klient.ts`) — the only public API:
+  aggregated `global.*` / `session(id).*` / `session(id).agent(id).*` methods
+  and their `events.*` hubs. No engine service tokens, no `onDid*`/`onWill*`
+  names, and **no escape hatch to raw services** — do not reintroduce a
+  service locator (`core()`/`service()`/`makeProxy`).
+- **Contract** (`src/contract/`) — zod input/output schemas for every wire
+  method plus event payload schemas. Schemas are hand-mirrored from
+  agent-core-v2 types and pinned by the compile-time parity assertions in
+  `test/contract-parity.ts`; when the engine types change, tsc fails here
+  first. `maybe()`/`noResult()` in `src/contract/helpers.ts` encode the HTTP
+  wire's `null`-vs-`undefined` semantics — use them for every
+  `X | undefined` / `void` result.
+- **Transports** (`src/transports/{http,ipc,memory}`) — each implements the
+  `KlientChannel` SPI (`src/core/channel.ts`) and nothing else. http carries
+  events over a lazily opened WS; ipc reuses the WS frame shapes over a unix
+  socket and shares the in-process dispatcher with memory; memory JSON
+  round-trips every value so all three transports return byte-identical data.
+
+The facade only covers services kap-server exposes over `/api/v2` **and** that
+behave identically on all three transports (the in-process dispatcher mirrors
+the server's scope resolution, including `main`-agent materialization via
+`ensureMainAgent`). onWill/hook-style interception is not wire-exposable
+(engine hooks are in-process `OrderedHookSlot`s); file upload and the
+terminal surface are v1-only and live in the legacy suites.
+
+## Testing
+
+- One shared conformance suite (`test/helpers/conformance.ts`) runs unchanged
+  against every transport — one test file per transport under `test/`; the
+  http leg boots an in-process kap-server. Add new **global** facade coverage
+  there, not per-transport.
+- Session/agent coverage lives in `test/e2e/dual/` (`test/helpers/dual.ts`):
+  every suite runs the exact same body against an in-memory engine AND an
+  in-process kap-server. Model-requiring suites declare
+  `{ requiresModel: true }` and skip unless `KIMI_E2E_MODEL` +
+  `KIMI_E2E_API_KEY` (optional `KIMI_E2E_BASE_URL` / `KIMI_E2E_PROTOCOL`)
+  are set; the model is seeded into each backend's temp home via
+  `klient.global.models.set` and agents bind it with
+  `agent.setModel(DUAL_MODEL_ID)`.
+- `test/e2e/v2/` — `/api/v2` wire tests booting kap-server in-process.
+- `test/e2e/legacy/` + `test/e2e/harness/` — the legacy `/api/v1` live
+  suites (moved from server-e2e). They skip unless `KIMI_SERVER_URL` points
+  at a running server and **must keep running unchanged**; the v1 surface
+  has no in-memory equivalent, so these stay http-only — do not try to
+  dual-run them.
+- The retired `scenarios/` scripts were rewritten as suites: prompt /
+  approval / workspace / catalog / children / pending flows live in
+  `test/e2e/dual/`; image-upload and terminal (v1-only surfaces) live in
+  `test/e2e/legacy/`; refresh-replay was dropped as redundant with the
+  legacy test of the same name.
+
+## Observability (inherited from server-e2e)
+
+- Keep observability inside each e2e case; every live case prints structured,
+  case-scoped details (requests, envelopes, WS handshakes, terminal frames,
+  error envelopes) through the shared logger in `test/e2e/legacy/log.ts`,
+  not ad hoc `console.log`.
+- Logs must stay visible for passing Vitest cases — write through stdout.
+- When adding or changing an e2e case, update its observability at the same
+  time; do not add a scenario solely to print data an existing case should
+  already expose.
+
+## Command reference
+
+- `pnpm --filter @moonshot-ai/klient test` — all Vitest suites (unit +
+  conformance + e2e; live and model cases skip without their env).
+- `KIMI_SERVER_URL=http://127.0.0.1:58627 pnpm --filter @moonshot-ai/klient test`
+  — include the live legacy/v2 cases against a running server.
+- `KIMI_E2E_MODEL=... KIMI_E2E_API_KEY=... [KIMI_E2E_BASE_URL=...] pnpm --filter @moonshot-ai/klient exec vitest run test/e2e/dual`
+  — run the model-requiring dual suites against both backends.
+- `pnpm --filter @moonshot-ai/klient docker:e2e` — docker e2e; the run
+  derives its runner name/namespace from the current workspace to avoid
+  cross-workspace conflicts.
+- `pnpm --filter @moonshot-ai/klient typecheck` / `pnpm smoke` (real-server
+  smoke; see `examples/smoke.ts`).
diff --git a/packages/server-e2e/Dockerfile b/packages/klient/Dockerfile
similarity index 91%
rename from packages/server-e2e/Dockerfile
rename to packages/klient/Dockerfile
index 36d24375d..98473034c 100644
--- a/packages/server-e2e/Dockerfile
+++ b/packages/klient/Dockerfile
@@ -1,6 +1,6 @@
 # syntax=docker/dockerfile:1.7
 #
-# server-e2e docker-run image.
+# klient e2e docker-run image.
 #
 # This image layers server-e2e defaults on top of the repository server dev
 # image. Source code and node_modules are still provided by bind mounts from
@@ -22,6 +22,6 @@ ENV KIMI_CODE_HOME=/data/docker-e2e/kimi-code-home \
     npm_config_store_dir=/workspace/kimi-code/node_modules/.pnpm-store \
     npm_config_package_import_method=copy
 
-WORKDIR /workspace/kimi-code/packages/server-e2e
+WORKDIR /workspace/kimi-code/packages/klient
 
 CMD ["bash"]
diff --git a/packages/klient/README.md b/packages/klient/README.md
index 08907d88b..620b2d765 100644
--- a/packages/klient/README.md
+++ b/packages/klient/README.md
@@ -1,54 +1,112 @@
 # @moonshot-ai/klient
 
-Client SDK that reuses `agent-core-v2` service interfaces and fulfills them over
-the `/api/v2` HTTP channel. It follows the VS Code model: a channel is bound to
-**one Service** (the URL carries the scope + the Service's decorator id) and
-method calls are forwarded **verbatim** to the server's reflection dispatcher —
-no per-method allowlist, no `resource:action`, no renaming. The shared interface
-is the whole contract.
+Contract-driven client SDK for the agent-core-v2 engine. One facade, three
+transports — you pick the transport **once** at creation; everything after
+that is byte-identical:
 
 ```ts
-import { Klient, SessionIndexClient, HttpChannel } from '@moonshot-ai/klient';
-import { ISessionIndex } from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
+import { createKlient } from '@moonshot-ai/klient/http';   // or '/ipc', '/memory'
 
-const client = new Klient({ url: 'http://127.0.0.1:58627' });
+const klient = createKlient({ url: 'http://127.0.0.1:58627', token });
 
-// Generic typed proxy: the v2 service token carries both the type and the
-// channel name (`String(ISessionIndex)` === 'sessionIndex').
-const sessions = await client.core(ISessionIndex).list({});
-const meta = await client.session('s1').service(ISessionMetadata).read();
+const env = await klient.global.env();
+const sessions = await klient.global.sessions.list({ limit: 20 });
 
-// Explicit, fully-typed implementation of a single interface. The channel is
-// bound to the Service's scope URL.
-const index: ISessionIndex = new SessionIndexClient(
-  new HttpChannel({ baseUrl: 'http://127.0.0.1:58627/api/v2/sessionIndex' }),
-);
-const page = await index.list({ workspaceId: 'w1' });
+const session = await klient.global.sessions.create({ workDir: process.cwd() });
+const agent = klient.session(session.id).agent('main');
+agent.events.on('assistant.delta', (e) => process.stdout.write(e.delta));
+agent.events.on('prompt.completed', () => console.log('\ndone'));
+await agent.prompt({ input: [{ type: 'text', text: 'Say OK.' }] });
+
+await klient.close();
 ```
 
-Service interfaces and tokens are imported directly from `agent-core-v2` leaf
-subpaths; the channel and proxy live in this package.
+## Architecture
 
-## WebSocket transport (calls + events)
-
-`Klient#ws()` returns a lazily-created `WsKlient` over the persistent
-`/api/v2/ws` socket: the same scope entries and typed proxies (one socket
-multiplexes every `call`), plus `listen(event, handler)` on each scope for the
-server's event streams — core `events`, session `interactions` /
-`interactions:resolved`, agent `events`:
-
-```ts
-const ws = client.ws();
-const sub = ws.session('s1').agent('main').listen('events', (event) => {
-  console.log('agent event', event);
-});
-const pending = await ws.session('s1').service(ISessionApprovalService).listPending();
-sub.dispose();
-ws.close();
+```
+facade (klient.global.*, klient.session(id).*, session.agent(id).*, *.events.*)
+   ↓ single-object params, zod-validated
+contract (procedure schemas, shared by all transports)
+   ↓
+KlientChannel { call, listen }   ← the only transport SPI
+   ↓
+http │ ipc │ memory
 ```
 
-The socket answers heartbeats, applies per-call timeouts, and reconnects
-automatically after an unexpected close (active `listen`s are re-subscribed;
-in-flight calls reject). The bearer token rides the
-`kimi-code.bearer.<token>` subprotocol, so the transport works unchanged in
-browsers.
+- **Facade** — aggregated methods, no engine service tokens, no
+  `onDid*`/`onWill*` event names. There is no escape hatch to raw services:
+  the facade is the public contract.
+  - `klient.global.*` — `sessions.*` (incl. `create`), `workspaces.*`,
+    `config.*`, `providers.*`, `models.*`, `catalog.*`, `auth.*`, `flags.*`,
+    `plugins.*`, `hostFs.*`, `env()`.
+  - `klient.session(id).*` — `get/setTitle/update/status/close/archive/
+    restore/fork/createChild`, `approvals.*`, `questions.*`,
+    `interactions.*`, `agents()`.
+  - `session.agent(id).*` — `prompt/steer/cancel/runShellCommand/
+    cancelShellCommand/getModel/setModel/setPermission/getUsage/getContext/
+    getPlan*/getTasks*/stopTask/getTaskOutput`.
+- **Contract** — every method has a zod input tuple + output schema, validated
+  on the client before send / after receive (default on; `validate: false` to
+  disable). Validation is sub-µs for typical payloads — cheaper than the JSON
+  serialization the wire already pays.
+- **Events** — `klient.events.on(...)` for the global bus
+  (`config.changed`, `models.changed`, `session.archived`, …),
+  `session(id).events.on('metadata.changed' | 'interactions.changed' |
+  'interactions.resolved')`, and `agent(id).events.on('turn.started' |
+  'assistant.delta' | 'tool.call.started' | 'prompt.completed' | …)`.
+  Underlying subscriptions are shared and ref-counted; payloads are
+  validated; bad payloads drop to `events.onError`.
+
+## Transports
+
+| entry | options | events |
+|---|---|---|
+| `@moonshot-ai/klient/http` | `{ url, token?, fetch?, WebSocketImpl? }` | lazily opened WS, transparent |
+| `@moonshot-ai/klient/ipc` | `{ socketPath, token? }` | same socket |
+| `@moonshot-ai/klient/memory` | `{ scope }` (a bootstrapped engine app scope) | direct emitter/bus subscription |
+
+`ipc` and `memory` share one in-process dispatcher, so they behave identically
+by construction; `memory` additionally JSON round-trips every value so results
+match the networked transports byte-for-byte. The IPC host ships with the
+transport: `serveKlientIpc({ scope, socketPath })`.
+
+The same conformance suite runs against all three transports in this
+package's tests (`test/helpers/conformance.ts` — one test file per transport;
+the http leg boots an in-process kap-server).
+
+This package also hosts the e2e suites (the retired `server-e2e` package was
+folded in here):
+
+- `test/e2e/dual/` — session/agent suites that run the **exact same body**
+  against an in-memory engine and an in-process kap-server
+  (`test/helpers/dual.ts`). Model-requiring suites skip unless
+  `KIMI_E2E_MODEL` + `KIMI_E2E_API_KEY` (optional `KIMI_E2E_BASE_URL`,
+  `KIMI_E2E_PROTOCOL`) are set; the model is seeded into each backend's temp
+  home through the facade itself.
+- `test/e2e/v2/` — `/api/v2` wire tests booting kap-server in-process.
+- `test/e2e/legacy/` + `test/e2e/harness/` — the legacy `/api/v1` live suites
+  and their client harness (skip unless `KIMI_SERVER_URL` is set; the v1
+  surface has no in-memory equivalent, so these stay http-only).
+
+The docker e2e runner (`pnpm docker:e2e`) runs this whole vitest suite inside
+a container against a container-local server. See `AGENTS.md` for the testing
+rules.
+
+## Scope
+
+The facade covers the global (app), session, and agent surfaces shown above.
+What it deliberately leaves out (for now): onWill/hook-style interception
+(engine hooks are in-process `OrderedHookSlot`s and not wire-exposable), file
+upload (v1 multipart REST only), and the terminal surface (v1 REST + WS
+only).
+
+## Real-server smoke check
+
+```sh
+KIMI_SERVER_URL=http://127.0.0.1:58627 \
+KIMI_SERVER_TOKEN=YOUR_SERVER_TOKEN \
+pnpm -C packages/klient smoke
+```
+
+Omit `KIMI_SERVER_TOKEN` only for a server started with authentication
+bypassed. `examples/basic.ts` is a shorter narrated tour.
diff --git a/packages/klient/examples/basic.ts b/packages/klient/examples/basic.ts
index 57eb25ca8..8919c1e0e 100644
--- a/packages/klient/examples/basic.ts
+++ b/packages/klient/examples/basic.ts
@@ -1,63 +1,56 @@
 /**
- * Minimal end-to-end example driving a running `kap-server` over `/api/v2` with
- * klient — core + session scopes, both the generic typed proxy and the
- * explicit `SessionIndexClient`, plus the error path.
+ * Minimal end-to-end example driving a running `kap-server` with klient's
+ * `global` facade over the HTTP transport (events ride a lazily opened WS —
+ * same facade either way).
  *
  * Run against a local dev server (auth bypassed for dev):
  *   pnpm dev:server --dangerous-bypass-auth
  *   pnpm -C packages/klient exec tsx examples/basic.ts
  */
-import { HttpChannel, Klient, SessionIndexClient } from '@moonshot-ai/klient';
-import { ISessionIndex } from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
-import { ISessionMetadata } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
+import { createKlient } from '@moonshot-ai/klient/http';
 
-const BASE = process.env.KIMI_SERVER_URL ?? 'http://127.0.0.1:58627';
-
-async function createSessionViaV1(cwd: string): Promise<string> {
-  const res = await fetch(`${BASE}/api/v1/sessions`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ metadata: { cwd } }),
-  });
-  const env = (await res.json()) as { code: number; data: { id: string } };
-  if (env.code !== 0) throw new Error(`create session failed: ${JSON.stringify(env)}`);
-  return env.data.id;
-}
+const BASE = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
 
 async function main(): Promise<void> {
-  const client = new Klient({ url: BASE });
+  const klient = createKlient({ url: BASE });
 
-  // 1) Generic typed proxy — core scope. The token carries type + channel name.
-  const page = await client.core(ISessionIndex).list({});
-  console.log('[core]    sessionIndex.list      ->', page.items.length, 'sessions');
+  // 1) Aggregated host snapshot.
+  const env = await klient.global.env();
+  console.log('[env]      platform/homeDir   ->', env.platform, env.homeDir);
 
-  // 2) Explicit impl — same interface, hand-written class on a bound channel.
-  const index: ISessionIndex = new SessionIndexClient(
-    new HttpChannel({ baseUrl: `${BASE}/api/v2/sessionIndex` }),
-  );
-  const page2 = await index.list({});
-  console.log('[core]    SessionIndexClient.list ->', page2.items.length, 'sessions (explicit)');
+  // 2) Read models.
+  const sessions = await klient.global.sessions.list({});
+  console.log('[sessions] list               ->', sessions.items.length, 'sessions');
+  const workspaces = await klient.global.workspaces.list();
+  console.log('[workspaces] list             ->', workspaces.length, 'workspaces');
+  const providers = await klient.global.providers.list();
+  console.log('[providers] list              ->', Object.keys(providers).length, 'providers');
 
-  // 3) Session scope — create a session via /api/v1, then read metadata via v2.
-  const id = await createSessionViaV1('/tmp/klient-example');
-  console.log('[v1]      created session         ->', id);
-  const meta = await client.session(id).service(ISessionMetadata).read();
-  console.log('[session] sessionMetadata.read   ->', {
-    id: meta.id,
-    cwd: meta.cwd,
-    archived: meta.archived,
+  // 3) Events — klient-level forwarding (no onDid*/onWill* in sight).
+  const sub = klient.events.on('providers.changed', (event) => {
+    console.log('[event]    providers.changed  -> +%s -%s ~%s', event.added, event.removed, event.changed);
   });
+  await klient.global.providers.set({
+    name: '__klient_example__',
+    config: { apiKey: 'example-key' },
+  });
+  await klient.global.providers.delete('__klient_example__');
+  sub.dispose();
 
-  // 4) Error path — unknown method -> RPCError(40001).
+  // 4) Error path — a missing plugin surfaces as RPCError with the server's code.
   try {
-    await (client.core(ISessionIndex) as unknown as { nope(): Promise<unknown> }).nope();
-  } catch (err) {
-    const e = err as { name: string; code: number };
-    console.log('[error]   unknown method         ->', e.name, e.code);
+    await klient.global.plugins.info('__definitely_missing__');
+  } catch (error) {
+    const e = error as { name: string; code?: number };
+    console.log('[error]    plugins.info        ->', e.name, e.code);
   }
+
+  await klient.close();
 }
 
-main().catch((err) => {
-  console.error(err);
+try {
+  await main();
+} catch (error) {
+  console.error(error);
   process.exit(1);
-});
+}
diff --git a/packages/klient/examples/context-usage.ts b/packages/klient/examples/context-usage.ts
new file mode 100644
index 000000000..460c9e7b4
--- /dev/null
+++ b/packages/klient/examples/context-usage.ts
@@ -0,0 +1,213 @@
+/**
+ * Trace how the reported "Context size" evolves on a brand-new session after
+ * a single "hi" prompt, against a real running `kap-server` over the HTTP
+ * transport.
+ *
+ * What gets sampled, all through the klient facade:
+ *   - `agent.getContext()` → `{ history, tokenCount }` — `tokenCount` is the
+ *     last MEASURED exchange total (`contextSize.get().measured` server-side);
+ *     it is 0 until the first LLM response lands and stays flat between turns.
+ *   - `agent.getUsage()` → accumulated token usage (`byModel` / `currentTurn`
+ *     / `total`), recorded per request.
+ *   - `agent.status.updated` events — the live `contextTokens` / `usage`
+ *     slices that feed the TUI footer.
+ *
+ * A 250 ms poll diffs (history length, tokenCount, usage.total) and prints a
+ * line only when something changed, so the output is a timeline of exactly
+ * when the Context size reading moves — and when it does NOT.
+ *
+ * Run against a local dev server (auth token resolves from
+ * `<kimi-home>/server.token`, same as the v2 e2e helpers):
+ *   pnpm dev:kap-server
+ *   pnpm -C packages/klient exec tsx examples/context-usage.ts
+ *
+ * Env:
+ *   KIMI_SERVER_URL         — default `http://127.0.0.1:58627`
+ *   KIMI_SERVER_TOKEN       — default: contents of `<KIMI_CODE_HOME|~/.kimi-code>/server.token`
+ *   KIMI_EXAMPLE_MODEL      — seed a throwaway model with this gateway model id…
+ *   KIMI_EXAMPLE_API_KEY    — …and this API key (otherwise the server's default model is used)
+ *   KIMI_EXAMPLE_BASE_URL   — optional gateway base URL for the seeded model
+ *   KIMI_EXAMPLE_PROTOCOL   — optional wire protocol for the seeded model (default `openai`)
+ */
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { createKlient } from '@moonshot-ai/klient/http';
+
+const BASE = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
+const SEEDED_MODEL_ID = 'klient-example-model';
+
+interface TokenUsage {
+  inputOther: number;
+  output: number;
+  inputCacheRead: number;
+  inputCacheCreation: number;
+}
+
+function usageTotal(usage: TokenUsage | undefined): number | undefined {
+  if (usage === undefined) return undefined;
+  return usage.inputOther + usage.output + usage.inputCacheRead + usage.inputCacheCreation;
+}
+
+async function resolveToken(): Promise<string | undefined> {
+  const explicit = process.env['KIMI_SERVER_TOKEN'];
+  if (explicit !== undefined && explicit.length > 0) return explicit;
+  const home = process.env['KIMI_CODE_HOME'] ?? join(homedir(), '.kimi-code');
+  try {
+    const token = (await readFile(join(home, 'server.token'), 'utf8')).trim();
+    return token.length > 0 ? token : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+const tick = (ms: number): Promise<void> =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+async function main(): Promise<void> {
+  const token = await resolveToken();
+  const klient = createKlient({ url: BASE, token });
+
+  const session = await klient.global.sessions.create({ workDir: process.cwd() });
+  console.log('[session] created ->', session.id);
+  const agent = klient.session(session.id).agent('main');
+
+  // Optional throwaway model seeding; otherwise the server's default model.
+  const seedModel = process.env['KIMI_EXAMPLE_MODEL'];
+  const seedKey = process.env['KIMI_EXAMPLE_API_KEY'];
+  if (seedModel !== undefined && seedKey !== undefined) {
+    await klient.global.models.set({
+      id: SEEDED_MODEL_ID,
+      config: {
+        model: seedModel,
+        apiKey: seedKey,
+        baseUrl: process.env['KIMI_EXAMPLE_BASE_URL'],
+        protocol: (process.env['KIMI_EXAMPLE_PROTOCOL'] ?? 'openai') as 'openai',
+        maxContextSize: 262_144,
+      },
+    });
+    await agent.setModel(SEEDED_MODEL_ID);
+  }
+  console.log('[model]   bound   ->', await agent.getModel());
+
+  const startedAt = Date.now();
+  const elapsed = (): string => `+${String(Date.now() - startedAt).padStart(6)}ms`;
+
+  // Live status slices (what the TUI footer consumes), as they arrive.
+  agent.events.on('agent.status.updated', (event) => {
+    const slice: Record<string, unknown> = {};
+    if ('contextTokens' in event) slice['contextTokens'] = event['contextTokens'];
+    if ('maxContextTokens' in event) slice['maxContextTokens'] = event['maxContextTokens'];
+    if ('contextUsage' in event) slice['contextUsage'] = event['contextUsage'];
+    if ('phase' in event) slice['phase'] = event['phase'];
+    const usage = event['usage'] as { total?: TokenUsage } | undefined;
+    if (usage !== undefined) slice['usage.total'] = usageTotal(usage.total);
+    console.log(`[event]   ${elapsed()} agent.status.updated ->`, JSON.stringify(slice));
+  });
+  agent.events.on('turn.started', (event) => {
+    console.log(`[event]   ${elapsed()} turn.started         -> turnId=${String(event.turnId)}`);
+  });
+  agent.events.on('turn.ended', (event) => {
+    console.log(`[event]   ${elapsed()} turn.ended           -> reason=${event.reason}`);
+  });
+  agent.events.on('error', (event) => {
+    console.log(`[event]   ${elapsed()} error                ->`, JSON.stringify(event));
+  });
+  agent.events.onError((error) => {
+    console.log(`[event-err] ${elapsed()} ${error.message.split('\n')[0] ?? error.message}`);
+  });
+
+  const completed = new Promise<'completed' | 'failed' | 'timeout'>((resolve) => {
+    const timer = setTimeout(() => {
+      sub.dispose();
+      resolve('timeout');
+    }, 120_000);
+    const sub = agent.events.on('prompt.completed', (event) => {
+      clearTimeout(timer);
+      sub.dispose();
+      console.log(
+        `[event]   ${elapsed()} prompt.completed     -> reason=${event.reason ?? 'unknown'}`,
+      );
+      resolve(event.reason === 'failed' ? 'failed' : 'completed');
+    });
+  });
+
+  // Diff-polled snapshot of the RPC-visible readings.
+  let lastKey = '';
+  const snapshot = async (tag: string): Promise<void> => {
+    const [ctx, usage] = await Promise.all([agent.getContext(), agent.getUsage()]);
+    const total = usageTotal(usage.total);
+    const turn = usageTotal(usage.currentTurn);
+    const key = `${String(ctx.history.length)}/${String(ctx.tokenCount)}/${String(total)}/${String(turn)}`;
+    if (key === lastKey) return;
+    lastKey = key;
+    console.log(
+      `[poll]    ${elapsed()} ${tag}`.padEnd(46),
+      `history=${String(ctx.history.length)}  tokenCount(measured)=${String(ctx.tokenCount)}` +
+        `  usage.total=${String(total)}  usage.currentTurn=${String(turn)}`,
+    );
+  };
+
+  let polling = true;
+  const pollLoop = (async (): Promise<void> => {
+    while (polling) {
+      try {
+        await snapshot('');
+      } catch {
+        // transient RPC failure during the turn — keep polling
+      }
+      await tick(250);
+    }
+  })();
+
+  await tick(300); // let the event subscriptions cross the lazily opened WS
+
+  await snapshot('created (pre-prompt)');
+  console.log(`[prompt]  ${elapsed()} sending "hi"`);
+  await agent.prompt({ input: [{ type: 'text', text: 'hi' }] });
+
+  const outcome = await completed;
+  polling = false;
+  await pollLoop;
+  lastKey = ''; // force the final line even if nothing moved since the last poll tick
+  await snapshot('after prompt.completed');
+
+  const ctx = await agent.getContext();
+  const usage = await agent.getUsage();
+  const total = usageTotal(usage.total);
+  console.log('---');
+  console.log('[result]  outcome              ->', outcome);
+  console.log('[result]  history messages     ->', ctx.history.length);
+  console.log('[result]  tokenCount (measured) ->', ctx.tokenCount);
+  console.log('[result]  usage.total           ->', JSON.stringify(usage.total));
+  console.log('[result]  usage.byModel         ->', JSON.stringify(usage.byModel));
+  console.log(
+    `[check]   tokenCount vs usage.total -> ${String(ctx.tokenCount)} vs ${String(total)}`,
+  );
+  console.log(
+    '[note]    reading guide:\n' +
+      '          - tokenCount is 0 until the first measured exchange lands, then it\n' +
+      '            should equal THAT exchange\'s total (input + output); new messages\n' +
+      '            appended between turns are the unmeasured tail.\n' +
+      '          - after one covered exchange on a fresh session, cumulative\n' +
+      '            usage.total and tokenCount should roughly agree; a large gap means\n' +
+      '            the measured total never made it onto the wire model and the reading\n' +
+      '            silently fell back to per-message estimates.\n' +
+      '          - outcome "timeout" means the turn finished its work but the\n' +
+      '            prompt.completed event never reached the client over the WS.',
+  );
+  console.log('[note]    session left open for inspection in the TUI ->', session.id);
+
+  await klient.close();
+  if (outcome === 'failed') process.exit(1);
+}
+
+try {
+  await main();
+} catch (error) {
+  console.error(error);
+  process.exit(1);
+}
diff --git a/packages/klient/examples/init.ts b/packages/klient/examples/init.ts
deleted file mode 100644
index d85669593..000000000
--- a/packages/klient/examples/init.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-/**
- * Example: drive the `/init` command end-to-end against a running server-v2
- * (kap-server) over the `/api/v2` channel, using `@moonshot-ai/klient`.
- *
- * Flow:
- *   1. read base url / token / default model from the local Kimi home
- *   2. create a session (v1 REST — klient is v2-only) pointed at a temp cwd
- *   3. bind the default model on the (auto-created) main agent
- *   4. call `ISessionInitService.generateAgentsMd()` and print the outcome
- *
- * No secrets are hard-coded: the token is read from `<home>/server.token`
- * (or `KIMI_SERVER_TOKEN`), the model from `default_model` in `<home>/config.toml`
- * (or `KIMI_INIT_MODEL`), and the base url from `KIMI_SERVER_URL`.
- *
- * Run: `pnpm exec tsx examples/init.ts` (cwd = this package).
- */
-
-import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { Klient, RPCError } from '@moonshot-ai/klient';
-import { IAgentProfileService } from '@moonshot-ai/agent-core-v2/agent/profile/profile';
-import { ISessionInitService } from '@moonshot-ai/agent-core-v2/session/sessionInit/sessionInit';
-
-interface Envelope<T> {
-  readonly code: number;
-  readonly msg: string;
-  readonly data: T;
-}
-
-const home = process.env['KIMI_CODE_HOME'] ?? join(homedir(), '.kimi-code');
-const baseUrl = (process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627').replace(/\/$/, '');
-
-async function readToken(): Promise<string> {
-  const fromEnv = process.env['KIMI_SERVER_TOKEN'];
-  if (fromEnv !== undefined && fromEnv.length > 0) return fromEnv;
-  const token = (await readFile(join(home, 'server.token'), 'utf8')).trim();
-  if (token.length === 0) throw new Error(`empty token at ${join(home, 'server.token')}`);
-  return token;
-}
-
-async function readDefaultModel(): Promise<string> {
-  const fromEnv = process.env['KIMI_INIT_MODEL'];
-  if (fromEnv !== undefined && fromEnv.length > 0) return fromEnv;
-  const config = await readFile(join(home, 'config.toml'), 'utf8');
-  const match = /^default_model\s*=\s*"([^"]+)"/m.exec(config);
-  if (match === null) throw new Error('default_model not found in config.toml; set KIMI_INIT_MODEL');
-  return match[1]!;
-}
-
-async function postV1<T>(token: string, path: string, body: unknown): Promise<T> {
-  const res = await fetch(`${baseUrl}${path}`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
-    body: JSON.stringify(body),
-  });
-  const envelope = (await res.json()) as Envelope<T>;
-  if (envelope.code !== 0) {
-    throw new Error(`v1 ${path} failed: code=${envelope.code} msg=${envelope.msg}`);
-  }
-  return envelope.data;
-}
-
-async function main(): Promise<void> {
-  const token = await readToken();
-  const model = await readDefaultModel();
-  const cwd = await mkdtemp(join(tmpdir(), 'klient-init-'));
-  await writeFile(
-    join(cwd, 'package.json'),
-    JSON.stringify({ name: 'init-demo', scripts: { test: 'echo ok', build: 'echo ok' } }, null, 2),
-  );
-  await writeFile(join(cwd, 'README.md'), '# init demo\n\nTiny fixture for the /init example.\n');
-
-  console.log(`baseUrl = ${baseUrl}`);
-  console.log(`model   = ${model}`);
-  console.log(`cwd     = ${cwd}`);
-
-  const client = new Klient({ url: baseUrl, token });
-
-  console.log('\n[1/3] creating session (v1) ...');
-  const created = await postV1<{ readonly id: string }>(token, '/api/v1/sessions', {
-    metadata: { cwd },
-  });
-  const sid = created.id;
-  console.log(`      session id = ${sid}`);
-
-  console.log('[2/3] binding model on main agent (setModel) ...');
-  const profile = client.session(sid).agent('main').service(IAgentProfileService);
-  const setModelResult = await profile.setModel(model);
-  console.log('      setModel ->', setModelResult);
-
-  console.log('[3/3] calling ISessionInitService.generateAgentsMd() ...');
-  const init = client.session(sid).service(ISessionInitService);
-  await init.generateAgentsMd();
-  console.log('      /init completed (no error)');
-}
-
-main().catch((error: unknown) => {
-  if (error instanceof RPCError) {
-    console.error(`\nFAILED (rpc): code=${error.code} msg=${error.message}`);
-    if (error.details !== undefined) console.error('details:', error.details);
-  } else {
-    console.error('\nFAILED:', error instanceof Error ? error.message : error);
-  }
-  process.exitCode = 1;
-});
diff --git a/packages/klient/examples/inspect-init.ts b/packages/klient/examples/inspect-init.ts
deleted file mode 100644
index c112221ce..000000000
--- a/packages/klient/examples/inspect-init.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-/**
- * Diagnostic: inspect a session after a `/init` attempt — session agents, and
- * for each agent the permission mode / active turn / context tail. Uses only
- * Services exposed on the wire. Usage: `pnpm exec tsx examples/inspect-init.ts <sessionId>`
- */
-
-import { readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-import { Klient } from '@moonshot-ai/klient';
-import { IAgentContextMemoryService } from '@moonshot-ai/agent-core-v2/agent/contextMemory/contextMemory';
-import { IAgentPermissionModeService } from '@moonshot-ai/agent-core-v2/agent/permissionMode/permissionMode';
-import { ISessionMetadata } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
-
-const home = process.env['KIMI_CODE_HOME'] ?? join(homedir(), '.kimi-code');
-const baseUrl = (process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627').replace(/\/$/, '');
-const sid = process.argv[2];
-if (sid === undefined) {
-  console.error('usage: inspect-init.ts <sessionId>');
-  process.exit(1);
-}
-
-const token = (await readFile(join(home, 'server.token'), 'utf8')).trim();
-const client = new Klient({ url: baseUrl, token });
-
-const meta = await client.session(sid).service(ISessionMetadata).read();
-const agentIds = Object.keys(meta.agents ?? {});
-console.log('agents in metadata:', agentIds);
-
-for (const agentId of ['main', ...agentIds.filter((id) => id !== 'main')]) {
-  const agent = client.session(sid).agent(agentId);
-  try {
-    const mode = await agent.service(IAgentPermissionModeService).mode();
-    // `get()` is sync in the shared interface but async over the wire.
-    const context = await Promise.resolve(agent.service(IAgentContextMemoryService).get());
-    console.log(`\n== agent ${agentId} == mode=${mode} messages=${context.length}`);
-    for (const last of context.slice(-2)) {
-      const text = last.content
-        .map((part) => (part.type === 'text' ? part.text : `[${part.type}]`))
-        .join(' ')
-        .slice(0, 300);
-      const calls = (last.toolCalls ?? []).map((c) => c.name).join(',');
-      console.log(
-        `  - role=${last.role} origin=${JSON.stringify(last.origin ?? null)}${calls.length > 0 ? ` toolCalls=[${calls}]` : ''} :: ${text}`,
-      );
-    }
-  } catch (error) {
-    console.log(`\n== agent ${agentId} == not reachable (${error instanceof Error ? error.message : String(error)})`);
-  }
-}
diff --git a/packages/klient/examples/media-recovery.ts b/packages/klient/examples/media-recovery.ts
deleted file mode 100644
index aa9578fa1..000000000
--- a/packages/klient/examples/media-recovery.ts
+++ /dev/null
@@ -1,457 +0,0 @@
-/**
- * Example: end-to-end cases for the image format policy and the requester's
- * media recovery projections, driven against a REAL running kap-server over
- * `/api/v1` + `/api/v2` with `@moonshot-ai/klient` — no mocks.
- *
- * What is covered:
- *   A. REST ingestion gate — AVIF (declared AND sniffed through a lying
- *      label) and a remote `.avif` URL become text notices; a valid PNG
- *      passes through; a large WebP is re-encoded (not passed through).
- *   B. Core backstop — an AVIF data-URL injected straight through the v2
- *      prompt service (bypassing the REST gate) lands in the context
- *      history as a text notice, never as an image part.
- *   C. HTTP 413 recovery — with the `fault-injection` experimental flag, a
- *      one-shot `request-too-large` fault is armed; the turn still completes
- *      against the real provider via the media-degraded resend.
- *   D. Image-format recovery — same, with the `image-format` fault and the
- *      media-stripped resend.
- *
- * Prerequisites:
- *   - a kap-server started with the fault-injection flag and a real model:
- *       KIMI_CODE_EXPERIMENTAL_FAULT_INJECTION=1 kimi server run --foreground
- *     (the master KIMI_CODE_EXPERIMENTAL_FLAG=1 also enables it)
- *   - the token is read from `<home>/server.token` (or `KIMI_SERVER_TOKEN`);
- *     omit both when the server runs with auth bypassed
- *   - the model comes from `KIMI_EXAMPLE_MODEL`, else `default_model` in
- *     `<home>/config.toml`; cases C/D run one tiny real turn each
- *
- * Run: `pnpm exec tsx examples/media-recovery.ts` (cwd = this package).
- */
-
-import { mkdtemp, readFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { homedir, tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { deflateSync } from 'node:zlib';
-
-import { Klient, RPCError } from '@moonshot-ai/klient';
-import { IAgentContextMemoryService } from '@moonshot-ai/agent-core-v2/agent/contextMemory/contextMemory';
-import { IFaultInjectionService } from '@moonshot-ai/agent-core-v2/agent/faultInjection/faultInjection';
-import { IAgentProfileService } from '@moonshot-ai/agent-core-v2/agent/profile/profile';
-import { IAgentPromptService } from '@moonshot-ai/agent-core-v2/agent/prompt/prompt';
-
-interface Envelope<T> {
-  readonly code: number;
-  readonly msg: string;
-  readonly data: T;
-}
-
-interface PromptItemWire {
-  readonly prompt_id: string;
-  readonly status: string;
-  readonly content: unknown;
-}
-
-type WirePart =
-  | { type: 'text'; text: string }
-  | { type: 'image'; source: { kind: 'base64'; media_type: string; data: string } | { kind: 'url'; url: string } };
-
-const home = process.env['KIMI_CODE_HOME'] ?? join(homedir(), '.kimi-code');
-const baseUrl = (process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627').replace(/\/$/, '');
-
-const failures: string[] = [];
-function check(name: string, ok: boolean, detail?: string): void {
-  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${ok || detail === undefined ? '' : ` — ${detail}`}`);
-  if (!ok) failures.push(name);
-}
-
-async function readToken(): Promise<string | undefined> {
-  const fromEnv = process.env['KIMI_SERVER_TOKEN'];
-  if (fromEnv !== undefined && fromEnv.length > 0) return fromEnv;
-  try {
-    const token = (await readFile(join(home, 'server.token'), 'utf8')).trim();
-    return token.length > 0 ? token : undefined;
-  } catch {
-    return undefined; // auth-bypassed dev server
-  }
-}
-
-async function readDefaultModel(): Promise<string> {
-  const fromEnv = process.env['KIMI_EXAMPLE_MODEL'];
-  if (fromEnv !== undefined && fromEnv.length > 0) return fromEnv;
-  const config = await readFile(join(home, 'config.toml'), 'utf8');
-  const match = /^default_model\s*=\s*"([^"]+)"/m.exec(config);
-  if (match === null) throw new Error('default_model not found in config.toml; set KIMI_EXAMPLE_MODEL');
-  return match[1]!;
-}
-
-function authHeaders(token: string | undefined, extra: Record<string, string> = {}): Record<string, string> {
-  return token === undefined ? extra : { ...extra, authorization: `Bearer ${token}` };
-}
-
-async function postV1<T>(token: string | undefined, path: string, body: unknown): Promise<T> {
-  const res = await fetch(`${baseUrl}${path}`, {
-    method: 'POST',
-    headers: authHeaders(token, { 'content-type': 'application/json' }),
-    body: JSON.stringify(body),
-  });
-  const envelope = (await res.json()) as Envelope<T>;
-  if (envelope.code !== 0) {
-    throw new Error(`v1 ${path} failed: code=${envelope.code} msg=${envelope.msg}`);
-  }
-  return envelope.data;
-}
-
-// ── fixtures ─────────────────────────────────────────────────────────
-
-const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-
-function crc32(bytes: Buffer): number {
-  let crc = 0xffffffff;
-  for (const byte of bytes) {
-    crc = CRC32_TABLE[(crc ^ byte) & 0xff]! ^ (crc >>> 8);
-  }
-  return (crc ^ 0xffffffff) >>> 0;
-}
-const CRC32_TABLE = ((): Uint32Array => {
-  const table = new Uint32Array(256);
-  for (let i = 0; i < 256; i++) {
-    let c = i;
-    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-    table[i] = c >>> 0;
-  }
-  return table;
-})();
-
-function pngChunk(type: string, data: Buffer): Buffer {
-  const typeBytes = Buffer.from(type, 'ascii');
-  const length = Buffer.alloc(4);
-  length.writeUInt32BE(data.length, 0);
-  const crc = Buffer.alloc(4);
-  crc.writeUInt32BE(crc32(Buffer.concat([typeBytes, data])), 0);
-  return Buffer.concat([length, typeBytes, data, crc]);
-}
-
-function solidPng(width: number, height: number, rgb: [number, number, number]): Buffer {
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(width, 0);
-  ihdr.writeUInt32BE(height, 4);
-  ihdr[8] = 8;
-  ihdr[9] = 2; // RGB
-  const row = Buffer.alloc(1 + width * 3);
-  for (let x = 0; x < width; x++) {
-    row[1 + x * 3] = rgb[0];
-    row[2 + x * 3] = rgb[1];
-    row[3 + x * 3] = rgb[2];
-  }
-  const raw = Buffer.alloc(row.length * height);
-  for (let y = 0; y < height; y++) row.copy(raw, y * row.length);
-  return Buffer.concat([
-    PNG_SIGNATURE,
-    pngChunk('IHDR', ihdr),
-    pngChunk('IDAT', deflateSync(raw)),
-    pngChunk('IEND', Buffer.alloc(0)),
-  ]);
-}
-
-/** Minimal ftyp box sniffed as image/avif (bytes authoritative, no pixels). */
-function avifFtyp(): Buffer {
-  const buf = Buffer.alloc(24);
-  buf.writeUInt32BE(24, 0);
-  buf.write('ftyp', 4, 'latin1');
-  buf.write('avif', 8, 'latin1');
-  buf.write('avif', 16, 'latin1');
-  return buf;
-}
-
-/** Encode a solid 2100x1050 WebP (over the 2000px edge cap) via the wasm
- * encoder bundled with agent-core-v2's @jsquash/webp dependency. */
-async function bigWebpBase64(): Promise<string> {
-  const requireLocal = createRequire(import.meta.url);
-  const requireFromV2 = createRequire(requireLocal.resolve('@moonshot-ai/agent-core-v2/package.json'));
-  const { Jimp } = (await import(requireFromV2.resolve('jimp'))) as never as {
-    Jimp: new (opts: { width: number; height: number; color: number }) => {
-      bitmap: { data: Buffer; width: number; height: number };
-    };
-  };
-  const encMod = (await import(
-    requireFromV2.resolve('@jsquash/webp/encode.js')
-  )) as { init(wasm: object): Promise<void>; default(data: unknown, opts: unknown): Promise<ArrayBuffer> };
-  const wasmNamespace = (
-    globalThis as unknown as { WebAssembly: { compile(bytes: Uint8Array): Promise<object> } }
-  ).WebAssembly;
-  const wasm = await wasmNamespace.compile(
-    await readFile(requireFromV2.resolve('@jsquash/webp/codec/enc/webp_enc.wasm')),
-  );
-  await encMod.init(wasm);
-  const { bitmap } = new Jimp({ width: 2100, height: 1050, color: 0x3366ccff });
-  const encoded = await encMod.default(
-    {
-      data: new Uint8ClampedArray(bitmap.data.buffer, bitmap.data.byteOffset, bitmap.data.byteLength),
-      width: bitmap.width,
-      height: bitmap.height,
-    },
-    { quality: 90 },
-  );
-  return Buffer.from(encoded).toString('base64');
-}
-
-// ── main ─────────────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  const token = await readToken();
-  const model = await readDefaultModel();
-  console.log(`baseUrl = ${baseUrl}`);
-  console.log(`model   = ${model}`);
-
-  const client = new Klient(token === undefined ? { url: baseUrl } : { url: baseUrl, token });
-
-  // Session A: REST ingestion gate (each submission also runs a background
-  // turn against the real model — harmless).
-  console.log('\n== A. REST ingestion gate ==');
-  const sessionA = (await postV1<{ id: string }>(token, '/api/v1/sessions', {
-    metadata: { cwd: await mkdtemp(join(tmpdir(), 'klient-media-a-')) },
-  })).id;
-  // Bind the model so the background turns can run.
-  await client.session(sessionA).agent('main').service(IAgentProfileService).setModel(model);
-
-  const submit = (content: unknown): Promise<PromptItemWire> =>
-    postV1<PromptItemWire>(token, `/api/v1/sessions/${sessionA}/prompts`, { content });
-
-  // A1: inline AVIF, honestly declared.
-  const a1 = await submit([
-    { type: 'image', source: { kind: 'base64', media_type: 'image/avif', data: avifFtyp().toString('base64') } },
-  ]);
-  const a1parts = a1.content as WirePart[];
-  check(
-    'A1 inline AVIF becomes a text notice',
-    a1parts.length === 1 && a1parts[0]?.type === 'text' && a1parts[0].text.includes('image/avif'),
-    JSON.stringify(a1parts).slice(0, 160),
-  );
-
-  // A2: AVIF bytes labeled image/png — the sniff wins over the label.
-  const a2 = await submit([
-    { type: 'image', source: { kind: 'base64', media_type: 'image/png', data: avifFtyp().toString('base64') } },
-  ]);
-  const a2parts = a2.content as WirePart[];
-  check(
-    'A2 mislabeled AVIF bytes gated by sniff',
-    a2parts.length === 1 && a2parts[0]?.type === 'text' && a2parts[0].text.includes('image/avif'),
-    JSON.stringify(a2parts).slice(0, 160),
-  );
-
-  // A3: remote .avif URL — notice keeps the URL.
-  const avifUrl = 'https://example.com/pic.avif';
-  const a3 = await submit([{ type: 'image', source: { kind: 'url', url: avifUrl } }]);
-  const a3parts = a3.content as WirePart[];
-  check(
-    'A3 remote .avif URL becomes a notice keeping the URL',
-    a3parts.length === 1 &&
-      a3parts[0]?.type === 'text' &&
-      a3parts[0].text.includes('image/avif') &&
-      a3parts[0].text.includes(avifUrl),
-    JSON.stringify(a3parts).slice(0, 160),
-  );
-
-  // A4: large WebP is re-encoded (caption + non-WebP image), not passed through.
-  const a4 = await submit([
-    { type: 'image', source: { kind: 'base64', media_type: 'image/webp', data: await bigWebpBase64() } },
-  ]);
-  const a4parts = a4.content as WirePart[];
-  const a4image = a4parts.find((p) => p.type === 'image');
-  const a4caption = a4parts.find((p) => p.type === 'text' && p.text.includes('Image compressed'));
-  check(
-    'A4 large WebP re-encoded instead of passed through',
-    a4image !== undefined &&
-      a4image.type === 'image' &&
-      a4image.source.kind === 'base64' &&
-      a4image.source.media_type !== 'image/webp' &&
-      a4caption !== undefined,
-    JSON.stringify(a4parts.map((p) => (p.type === 'text' ? p.text.slice(0, 60) : p))).slice(0, 200),
-  );
-
-  // A5: small valid PNG passes through untouched.
-  const a5 = await submit([
-    { type: 'image', source: { kind: 'base64', media_type: 'image/png', data: solidPng(32, 32, [0x33, 0x66, 0xcc]).toString('base64') } },
-  ]);
-  const a5parts = a5.content as WirePart[];
-  check(
-    'A5 valid PNG passes through as an image part',
-    a5parts.length === 1 &&
-      a5parts[0]?.type === 'image' &&
-      a5parts[0].source.kind === 'base64' &&
-      a5parts[0].source.media_type === 'image/png',
-    JSON.stringify(a5parts).slice(0, 120),
-  );
-
-  // Session B: core backstop + recovery cases.
-  const sessionB = (await postV1<{ id: string }>(token, '/api/v1/sessions', {
-    metadata: { cwd: await mkdtemp(join(tmpdir(), 'klient-media-b-')) },
-  })).id;
-  const agentB = client.session(sessionB).agent('main');
-  await agentB.service(IAgentProfileService).setModel(model);
-  const prompt = agentB.service(IAgentPromptService);
-  const context = agentB.service(IAgentContextMemoryService);
-
-  console.log('\n== B. core backstop (v2 prompt funnel) ==');
-  const backstopId = 'klient-backstop-avif';
-  await prompt.enqueue({
-    id: backstopId,
-    message: {
-      role: 'user',
-      content: [
-        {
-          type: 'image_url',
-          imageUrl: { url: `data:image/avif;base64,${avifFtyp().toString('base64')}` },
-        },
-      ],
-      toolCalls: [],
-      origin: { kind: 'user' },
-    },
-  });
-  // Wait for the message to materialize into the context, then abort the turn.
-  let landed = false;
-  for (let i = 0; i < 50; i++) {
-    const messages = await Promise.resolve(context.get());
-    const injected = messages.find((m) => m.role === 'user');
-    if (injected !== undefined) {
-      const hasAvifImage = injected.content.some(
-        (p) => p.type === 'image_url' && p.imageUrl.url.includes('avif'),
-      );
-      const hasNotice = injected.content.some(
-        (p) => p.type === 'text' && p.text.includes('image/avif'),
-      );
-      check(
-        'B AVIF prompt lands in history as a text notice, never an image',
-        !hasAvifImage && hasNotice,
-        JSON.stringify(injected.content).slice(0, 160),
-      );
-      landed = true;
-      break;
-    }
-    await new Promise((resolve) => {
-      setTimeout(resolve, 100);
-    });
-  }
-  if (!landed) check('B AVIF prompt lands in history', false, 'message never materialized');
-  await Promise.resolve(prompt.abort(backstopId));
-
-  console.log('\n== C/D. recovery resends against the real provider ==');
-  const fault = agentB.service(IFaultInjectionService);
-  const profile = agentB.service(IAgentProfileService);
-  const caps = await Promise.resolve(profile.data());
-  const canSeeImages = caps.modelCapabilities.image_in;
-
-  // Seed media into the history when the model can see images, so the
-  // recovery projections are non-trivial (degraded keeps the recent two,
-  // stripped removes all). Skip with a note on text-only models.
-  if (canSeeImages) {
-    const seedId = 'klient-seed-media';
-    await prompt.enqueue({
-      id: seedId,
-      message: {
-        role: 'user',
-        content: [
-          { type: 'text', text: 'three seed images' },
-          ...([0x3366cc, 0xcc6633, 0x66cc33] as const).map((color) => ({
-            type: 'image_url' as const,
-            imageUrl: {
-              url: `data:image/png;base64,${solidPng(32, 32, [(color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff]).toString('base64')}`,
-            },
-          })),
-        ],
-        toolCalls: [],
-        origin: { kind: 'user' },
-      },
-    });
-    for (let i = 0; i < 50; i++) {
-      const messages = await Promise.resolve(context.get());
-      if (messages.some((m) => m.content.some((p) => p.type === 'image_url'))) break;
-      await new Promise((resolve) => {
-        setTimeout(resolve, 100);
-      });
-    }
-    await Promise.resolve(prompt.abort(seedId));
-    console.log('  seeded 3 PNG images into the history');
-  } else {
-    console.log('  note: model reports image_in=false — recovery runs on a text-only history');
-  }
-
-  const ws = client.ws();
-  const agentEvents = ws.session(sessionB).agent('main');
-  function waitCompleted(promptId: string, timeoutMs = 120_000): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        sub.dispose();
-        reject(new Error(`timeout waiting for prompt.completed ${promptId}`));
-      }, timeoutMs);
-      const sub = agentEvents.listen('events', (event: unknown) => {
-        const e = event as { type?: string; promptId?: string; reason?: string };
-        if (e.type === 'prompt.completed' && e.promptId === promptId) {
-          clearTimeout(timer);
-          sub.dispose();
-          resolve(e.reason ?? 'unknown');
-        }
-      });
-    });
-  }
-
-  const runRecoverablePrompt = async (
-    caseName: string,
-    kind: 'request-too-large' | 'image-format',
-    promptId: string,
-  ): Promise<void> => {
-    await Promise.resolve(fault.clear());
-    await Promise.resolve(fault.arm(kind));
-    const armed = (await Promise.resolve(fault.status())).armed;
-    check(`${caseName} fault armed`, armed === kind);
-    const completed = waitCompleted(promptId);
-    await prompt.enqueue({
-      id: promptId,
-      message: {
-        role: 'user',
-        content: [{ type: 'text', text: 'Reply with exactly: PONG' }],
-        toolCalls: [],
-        origin: { kind: 'user' },
-      },
-    });
-    const reason = await completed;
-    const fired = (await Promise.resolve(fault.status())).fired;
-    check(
-      `${caseName} turn completes via recovery resend`,
-      reason === 'completed' && fired.length === 1 && fired[0] === kind,
-      `reason=${reason} fired=${JSON.stringify(fired)}`,
-    );
-  };
-
-  console.log('\n== C. HTTP 413 → media-degraded resend ==');
-  await runRecoverablePrompt('C', 'request-too-large', 'klient-413');
-
-  console.log('\n== D. image-format 400 → media-stripped resend ==');
-  await runRecoverablePrompt('D', 'image-format', 'klient-imgfmt');
-
-  ws.close();
-
-  console.log('');
-  if (failures.length > 0) {
-    console.log(`FAILED: ${String(failures.length)} case(s): ${failures.join(', ')}`);
-    process.exitCode = 1;
-  } else {
-    console.log('ALL CASES PASSED');
-  }
-}
-
-main().catch((error: unknown) => {
-  if (error instanceof RPCError) {
-    console.error(`\nFAILED (rpc): code=${String(error.code)} msg=${error.message}`);
-    if (error.code === 40001 || /disabled/i.test(error.message)) {
-      console.error(
-        'hint: start the server with KIMI_CODE_EXPERIMENTAL_FAULT_INJECTION=1 ' +
-          '(or KIMI_CODE_EXPERIMENTAL_FLAG=1) for cases C/D',
-      );
-    }
-  } else {
-    console.error('\nFAILED:', error instanceof Error ? error.message : error);
-  }
-  process.exitCode = 1;
-});
diff --git a/packages/klient/examples/sea-e2e-auto-background.ts b/packages/klient/examples/sea-e2e-auto-background.ts
deleted file mode 100644
index dbd17c4d2..000000000
--- a/packages/klient/examples/sea-e2e-auto-background.ts
+++ /dev/null
@@ -1,230 +0,0 @@
-/**
- * SEA e2e — auto-background on foreground Bash timeout (v2 engine, via klient).
- *
- * Drives the SEA-built kap-server (`kimi server run`, backend v2) over:
- *   - /api/v1 REST mirror: create session, submit prompt, read messages
- *   - /api/v2 typed service proxies (klient): IAgentTaskService assertions
- *
- * Flow: prompt the agent to run `sleep 5` with a 1s foreground Bash timeout.
- * The 1s deadline must move the command to the background (not kill it); the
- * task keeps running and settles as completed once `sleep 5` exits.
- *
- * Run:
- *   KIMI_CODE_EXPERIMENTAL_FLAG=1 KIMI_CODE_EXPERIMENTAL_MULTI_SERVER=1 \
- *     apps/kimi-code/dist-native/bin/darwin-arm64/kimi server run --foreground \
- *     --port 58628 --dangerous-bypass-auth
- *   pnpm -C packages/klient exec tsx examples/sea-e2e-auto-background.ts
- */
-
-import assert from 'node:assert/strict';
-
-import { Klient } from '@moonshot-ai/klient';
-import { IAgentTaskService } from '@moonshot-ai/agent-core-v2/agent/task/task';
-
-const BASE = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58628';
-const client = new Klient({ url: BASE });
-
-const SLEEP_SECONDS = 5;
-const TIMEOUT_SECONDS = 1;
-
-interface Envelope<T> {
-  code: number;
-  msg: string;
-  data: T;
-}
-
-async function v1<T>(path: string, init?: RequestInit): Promise<T> {
-  const headers = new Headers(init?.headers);
-  headers.set('content-type', 'application/json');
-  const res = await fetch(`${BASE}/api/v1${path}`, {
-    ...init,
-    headers,
-  });
-  const env = (await res.json()) as Envelope<T>;
-  if (env.code !== 0) throw new Error(`${path} failed: ${JSON.stringify(env)}`);
-  return env.data;
-}
-
-async function createSession(cwd: string): Promise<string> {
-  const data = await v1<{ id: string }>('/sessions', {
-    method: 'POST',
-    body: JSON.stringify({ metadata: { cwd } }),
-  });
-  return data.id;
-}
-
-interface PromptHandleView {
-  prompt_id: string;
-  status: string;
-}
-
-const MODEL = process.env['KIMI_E2E_MODEL'] ?? 'free-tokens_kimi/coding-model-okapi-0711-vibe';
-
-async function submitPrompt(sessionId: string, text: string): Promise<PromptHandleView> {
-  const data = await v1<unknown>(`/sessions/${sessionId}/prompts`, {
-    method: 'POST',
-    body: JSON.stringify({
-      content: [{ type: 'text', text }],
-      permission_mode: 'yolo',
-      model: MODEL,
-    }),
-  });
-  console.log('  submit response:', JSON.stringify(data).slice(0, 200));
-  return data as PromptHandleView;
-}
-
-async function pollPrompts(sessionId: string): Promise<readonly PromptHandleView[]> {
-  const data = await v1<{
-    active?: PromptHandleView | null;
-    queued?: readonly PromptHandleView[];
-  }>(`/sessions/${sessionId}/prompts`);
-  return [...(data.active ? [data.active] : []), ...(data.queued ?? [])];
-}
-
-async function sessionStatus(sessionId: string): Promise<string> {
-  const data = await v1<{ status: string }>(`/sessions/${sessionId}`);
-  return data.status;
-}
-
-interface MessageItem {
-  role: string;
-  content: readonly { type: string; text?: string; output?: unknown }[];
-}
-
-async function listMessages(sessionId: string): Promise<readonly MessageItem[]> {
-  const data = await v1<{ items: readonly MessageItem[] }>(
-    `/sessions/${sessionId}/messages?page_size=100`,
-  );
-  return data.items;
-}
-
-async function waitFor<T>(
-  label: string,
-  fn: () => Promise<T | undefined>,
-  timeoutMs: number,
-): Promise<T> {
-  const deadline = Date.now() + timeoutMs;
-  for (;;) {
-    const value = await fn();
-    if (value !== undefined) {
-      console.log(`▶ ${label}`);
-      return value;
-    }
-    if (Date.now() > deadline) throw new Error(`timed out waiting for: ${label}`);
-    await new Promise((resolve) => setTimeout(resolve, 500));
-  }
-}
-
-async function main(): Promise<void> {
-  const taskService = (sessionId: string) =>
-    client.session(sessionId).agent('main').service(IAgentTaskService);
-
-  const sessionId = await createSession('/tmp/sea-e2e-auto-background');
-  console.log(`▶ session ${sessionId} created (backend: v2, via SEA binary)`);
-
-  try {
-    const prompt = await submitPrompt(
-      sessionId,
-      [
-        'Use the Bash tool exactly once with these arguments:',
-        `- command: sleep ${String(SLEEP_SECONDS)}`,
-        `- timeout: ${String(TIMEOUT_SECONDS)}`,
-        'Do NOT set run_in_background. After the tool returns, quote its message field verbatim and stop.',
-      ].join('\n'),
-    );
-    console.log(`▶ prompt ${prompt.prompt_id} submitted (status=${prompt.status})`);
-
-    // 1) The 1s foreground deadline must auto-background the task, not kill it.
-    const tasks = taskService(sessionId);
-    const detached = await waitFor(
-      'task auto-backgrounded (detached, still running)',
-      async () => {
-        const list = tasks.list(false);
-        return list.find(
-          (t) => t.kind === 'process' && t.detached === true && t.status === 'running',
-        );
-      },
-      30_000,
-    );
-    console.log('  task:', JSON.stringify({
-      taskId: detached.taskId,
-      status: detached.status,
-      detached: detached.detached,
-      description: detached.description,
-    }));
-    assert.equal(detached.detached, true, 'task must be detached to the background');
-    assert.equal(detached.status, 'running', 'task must still be running after the timeout');
-
-    // 2) The tool result returned immediately with a running background task
-    //    (the side-channel "timed out and moved to background" message is
-    //    TUI-only; the wire carries the metadata + next_step).
-    const toolText = await waitFor(
-      'tool result returned a running background task',
-      async () => {
-        const messages = await listMessages(sessionId);
-        const text = messages
-          .filter((m) => m.role === 'tool')
-          .flatMap((m) => m.content)
-          .map((part) =>
-            typeof part.output === 'string' ? part.output : (part.text ?? ''),
-          )
-          .join('\n');
-        return text.includes('task_id: bash-') &&
-          text.includes('status: running') &&
-          text.includes('The task now runs in the background')
-          ? text
-          : undefined;
-      },
-      30_000,
-    );
-    assert.match(toolText, /task_id: bash-/);
-
-    // 3) The backgrounded command keeps running and settles as completed.
-    const terminal = await waitFor(
-      'backgrounded task completed after sleep exited',
-      async () => {
-        const info = tasks.getTask(detached.taskId);
-        return info?.status === 'completed' ? info : undefined;
-      },
-      30_000,
-    );
-    assert.equal(terminal.status, 'completed');
-    assert.notEqual(terminal.status, 'timed_out');
-
-    // 4) The agent turn itself finishes (no blocked turn).
-    await waitFor(
-      'session back to idle',
-      async () => {
-        const status = await sessionStatus(sessionId);
-        const prompts = await pollPrompts(sessionId);
-        return status === 'idle' && prompts.length === 0 ? status : undefined;
-      },
-      60_000,
-    );
-
-    console.log('✓ auto-background on foreground Bash timeout works end-to-end on v2 (SEA)');
-  } catch (err) {
-    // Diagnostics: dump whatever the session produced before giving up.
-    try {
-      const messages = await listMessages(sessionId);
-      console.error('  messages at failure:', JSON.stringify(messages, null, 2).slice(0, 3000));
-      const prompts = await pollPrompts(sessionId);
-      console.error('  prompts at failure:', JSON.stringify(prompts));
-    } catch {
-      // ignore diagnostics failure
-    }
-    throw err;
-  } finally {
-    try {
-      await v1(`/sessions/${sessionId}::archive`, { method: 'POST', body: '{}' });
-      console.log(`▶ session ${sessionId} archived`);
-    } catch {
-      // best effort cleanup
-    }
-  }
-}
-
-main().catch((err) => {
-  console.error('✗ e2e failed:', err);
-  process.exit(1);
-});
diff --git a/packages/klient/examples/smoke.ts b/packages/klient/examples/smoke.ts
new file mode 100644
index 000000000..431e0fefb
--- /dev/null
+++ b/packages/klient/examples/smoke.ts
@@ -0,0 +1,83 @@
+/**
+ * Assert-based smoke check for klient against a real `kap-server`. Exercises
+ * the `global` facade end-to-end over the HTTP transport: env snapshot, read
+ * models, a workspace round-trip, a model set/delete round-trip with the
+ * `models.changed` event, and the error path.
+ *
+ *   KIMI_SERVER_URL=http://127.0.0.1:58627 KIMI_SERVER_TOKEN=YOUR_SERVER_TOKEN \
+ *   pnpm -C packages/klient smoke
+ */
+import { createKlient } from '@moonshot-ai/klient/http';
+
+const BASE = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
+const TOKEN = process.env['KIMI_SERVER_TOKEN'];
+
+function assert(cond: boolean, message: string): asserts cond {
+  if (!cond) throw new Error(`assertion failed: ${message}`);
+}
+
+const tick = (ms: number): Promise<void> =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+async function main(): Promise<void> {
+  const klient = createKlient({ url: BASE, token: TOKEN });
+
+  const env = await klient.global.env();
+  assert(env.platform.length > 0 && env.homeDir.length > 0, 'env snapshot is populated');
+  console.log('[ok] env');
+
+  const page = await klient.global.sessions.list({ limit: 5 });
+  assert(Array.isArray(page.items), 'sessions.list returns a page');
+  console.log('[ok] sessions.list ->', page.items.length);
+
+  const workspaces = await klient.global.workspaces.list();
+  assert(Array.isArray(workspaces), 'workspaces.list returns an array');
+  console.log('[ok] workspaces.list ->', workspaces.length);
+
+  // Provider round-trip with the klient-level event.
+  const seen: string[] = [];
+  const sub = klient.events.on('providers.changed', (event) => {
+    seen.push(...event.added, ...event.changed, ...event.removed);
+  });
+  await tick(300); // let the subscription cross the lazy WS
+  const name = '__klient_smoke__';
+  await klient.global.providers.set({ name, config: { apiKey: 'smoke-key' } });
+  assert((await klient.global.providers.get(name)) !== undefined, 'providers.get returns the new provider');
+  const deadline = Date.now() + 5_000;
+  while (!seen.includes(name) && Date.now() < deadline) await tick(25);
+  assert(seen.includes(name), 'providers.changed fired for the new provider');
+  await klient.global.providers.delete(name);
+  sub.dispose();
+  console.log('[ok] providers set/get/delete + providers.changed');
+
+  const config = await klient.global.config.getAll();
+  assert(typeof config === 'object' && config !== null, 'config.getAll returns an object');
+  console.log('[ok] config.getAll');
+
+  assert(Array.isArray(await klient.global.flags.list()), 'flags.list returns an array');
+  assert(Array.isArray(await klient.global.plugins.list()), 'plugins.list returns an array');
+  const auth = await klient.global.auth.status();
+  assert(typeof auth.loggedIn === 'boolean', 'auth.status returns a status');
+  console.log('[ok] flags / plugins / auth');
+
+  let rpcError: { name: string; code?: number } | undefined;
+  try {
+    await klient.global.plugins.info('__definitely_missing__');
+  } catch (error) {
+    rpcError = error as { name: string; code?: number };
+  }
+  assert(rpcError !== undefined, 'missing plugin surfaces an error');
+  console.log('[ok] error path ->', rpcError.name, rpcError.code);
+
+  await klient.close();
+  console.log('smoke: OK');
+}
+
+try {
+  await main();
+} catch (error) {
+  console.error(error);
+  process.exit(1);
+}
diff --git a/packages/klient/package.json b/packages/klient/package.json
index 3c4ed1e28..a691b8597 100644
--- a/packages/klient/package.json
+++ b/packages/klient/package.json
@@ -2,7 +2,7 @@
   "name": "@moonshot-ai/klient",
   "version": "0.0.1",
   "private": true,
-  "description": "Kimi client SDK — reuse agent-core-v2 service interfaces over the /api/v2 HTTP channel.",
+  "description": "Kimi client SDK — contract-driven facade over agent-core-v2, routable over http, ipc, or in-memory transports.",
   "license": "MIT",
   "type": "module",
   "imports": {
@@ -13,6 +13,18 @@
       "types": "./src/index.ts",
       "default": "./src/index.ts"
     },
+    "./http": {
+      "types": "./src/transports/http/index.ts",
+      "default": "./src/transports/http/index.ts"
+    },
+    "./ipc": {
+      "types": "./src/transports/ipc/index.ts",
+      "default": "./src/transports/ipc/index.ts"
+    },
+    "./memory": {
+      "types": "./src/transports/memory/index.ts",
+      "default": "./src/transports/memory/index.ts"
+    },
     "./package.json": {
       "types": "./package.json",
       "default": "./package.json"
@@ -24,11 +36,22 @@
   },
   "scripts": {
     "build": "tsdown",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit && pnpm typecheck:examples",
+    "typecheck:examples": "tsc -p tsconfig.examples.json --noEmit",
     "test": "vitest run",
-    "clean": "rm -rf dist"
+    "smoke": "tsx examples/smoke.ts",
+    "clean": "rm -rf dist",
+    "docker:e2e": "bash scripts/run-docker-e2e.sh"
   },
   "dependencies": {
-    "@moonshot-ai/agent-core-v2": "workspace:^"
+    "@moonshot-ai/agent-core-v2": "workspace:^",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@moonshot-ai/kap-server": "workspace:^",
+    "@moonshot-ai/protocol": "workspace:^",
+    "@types/ws": "^8.18.0",
+    "ulid": "^3.0.1",
+    "ws": "^8.18.0"
   }
 }
diff --git a/packages/server-e2e/scripts/run-docker-e2e.sh b/packages/klient/scripts/run-docker-e2e.sh
similarity index 96%
rename from packages/server-e2e/scripts/run-docker-e2e.sh
rename to packages/klient/scripts/run-docker-e2e.sh
index d48068d42..59e72e293 100755
--- a/packages/server-e2e/scripts/run-docker-e2e.sh
+++ b/packages/klient/scripts/run-docker-e2e.sh
@@ -54,7 +54,7 @@ workspace_node_modules=(
   "pkg_acp-adapter:/workspace/kimi-code/packages/acp-adapter/node_modules"
   "pkg_agent-core:/workspace/kimi-code/packages/agent-core/node_modules"
   "pkg_kap-server:/workspace/kimi-code/packages/kap-server/node_modules"
-  "pkg_server-e2e:/workspace/kimi-code/packages/server-e2e/node_modules"
+  "pkg_server-e2e:/workspace/kimi-code/packages/klient/node_modules"
   "pkg_kaos:/workspace/kimi-code/packages/kaos/node_modules"
   "pkg_kosong:/workspace/kimi-code/packages/kosong/node_modules"
   "pkg_migration-legacy:/workspace/kimi-code/packages/migration-legacy/node_modules"
@@ -97,7 +97,7 @@ cd /workspace/kimi-code
 mkdir -p "${KIMI_CODE_HOME}/server" "${KIMI_SERVER_E2E_REPORT_DIR}" "${TMPDIR}" /data/server-e2e-reports/docker
 rm -f "${KIMI_CODE_HOME}/server/lock"
 
-if [[ ! -e /workspace/kimi-code/node_modules/.modules.yaml || ! -e /workspace/kimi-code/packages/server-e2e/node_modules/ws ]]; then
+if [[ ! -e /workspace/kimi-code/node_modules/.modules.yaml || ! -e /workspace/kimi-code/packages/klient/node_modules/ws ]]; then
   echo "[server-e2e:docker] installing pnpm deps"
   pnpm install --frozen-lockfile
 else
@@ -148,8 +148,8 @@ if [[ "${ready}" != "1" ]]; then
   exit 1
 fi
 
-cd /workspace/kimi-code/packages/server-e2e
-pnpm test:scenarios
+cd /workspace/kimi-code/packages/klient
+pnpm test
 EOS
 
 docker_args=(
@@ -157,7 +157,7 @@ docker_args=(
   --rm
   --init
   --name "${CONTAINER}"
-  --workdir /workspace/kimi-code/packages/server-e2e
+  --workdir /workspace/kimi-code/packages/klient
   --env "KIMI_CODE_HOME=${KIMI_HOME_CONTAINER}"
   --env "KIMI_SERVER_E2E_PORT=${PORT}"
   --env "KIMI_SERVER_URL=http://127.0.0.1:${PORT}"
diff --git a/packages/klient/src/channel.ts b/packages/klient/src/channel.ts
deleted file mode 100644
index 9feb271e2..000000000
--- a/packages/klient/src/channel.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Transport-agnostic channel contract for the `/api/v2` client.
- *
- * In the VS Code model the channel is bound to one Service (the URL carries the
- * scope + the Service's decorator id) and `command` is the method name, invoked
- * by reflection on the server. `listen` is for events over a persistent (WS)
- * transport; the HTTP channel only implements `call`.
- */
-
-export interface IDisposable {
-  dispose(): void;
-}
-
-export interface Event<T> {
-  (listener: (event: T) => unknown, thisArg?: unknown, disposables?: IDisposable[]): IDisposable;
-}
-
-/** The client-facing channel contract. Calls always carry the complete argument array. */
-export interface IChannel {
-  call<T>(command: string, args?: unknown[]): Promise<T>;
-  listen<T>(event: string, arg?: unknown): Event<T>;
-}
diff --git a/packages/klient/src/client.ts b/packages/klient/src/client.ts
deleted file mode 100644
index be1a925a4..000000000
--- a/packages/klient/src/client.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * `/api/v2` client — three-level scope entry (core / session / agent) over the
- * HTTP channel.
- *
- *   const client = new Klient({ url: 'http://127.0.0.1:58627' });
- *   await client.core(ISessionIndex).list({});
- *   await client.session('s1').service(ISessionMetadata).read();
- *   await client.session('s1').agent('a1').service(IAgentProfile).getModel();
- *
- * The `agent-core-v2` service token is the whole key: its type parameter `T`
- * types the returned proxy, and its decorator id (`String(id)`) is the channel
- * name in the URL. Each scope level binds a channel to
- * `<scope-url>/<decorator-id>` and hands back a typed proxy via `makeProxy`,
- * which forwards method calls verbatim to the server's reflection dispatcher.
- */
-
-import type { ServiceIdentifier } from '@moonshot-ai/agent-core-v2/_base/di/instantiation';
-
-import type { IChannel } from './channel.js';
-import { HttpChannel, type HttpChannelOptions } from './httpChannel.js';
-import { makeProxy } from './proxy.js';
-import { WsKlient } from './wsKlient.js';
-import type { WsLikeCtor } from './wsSocket.js';
-
-export interface KlientOptions {
-  /** Base URL of the server, e.g. `http://127.0.0.1:58627`. */
-  readonly url: string;
-  /** Optional bearer token. */
-  readonly token?: string;
-  /** `fetch` implementation; defaults to the global `fetch`. */
-  readonly fetch?: typeof fetch;
-  /** WebSocket implementation for `ws()`; defaults to the global `WebSocket`. */
-  readonly WebSocketImpl?: WsLikeCtor;
-}
-
-export class Klient {
-  private readonly url: string;
-  private readonly token?: string;
-  private readonly fetchImpl?: typeof fetch;
-  private readonly wsImpl?: WsLikeCtor;
-  private wsKlient?: WsKlient;
-
-  constructor(opts: KlientOptions) {
-    this.url = opts.url.replace(/\/$/, '');
-    this.token = opts.token;
-    this.fetchImpl = opts.fetch;
-    this.wsImpl = opts.WebSocketImpl;
-  }
-
-  private channelOptions(baseUrl: string): HttpChannelOptions {
-    return { baseUrl, token: this.token, fetch: this.fetchImpl };
-  }
-
-  /** Core-scoped Service, e.g. `client.core(ISessionIndex)`. */
-  core<T extends object>(id: ServiceIdentifier<T>): T {
-    return makeProxy<T>(
-      new HttpChannel(this.channelOptions(`${this.url}/api/v2/${String(id)}`)),
-    );
-  }
-
-  /** Session scope entry point. */
-  session(sessionId: string): SessionClient {
-    return new SessionClient(this.url, this.token, this.fetchImpl, sessionId);
-  }
-
-  /**
-   * WebSocket counterpart of this client — same scopes and typed proxies over
-   * the persistent `/api/v2/ws` socket, plus event `listen`s. Lazily created
-   * on first call so one `Klient` holds at most one live socket; close it with
-   * `client.ws().close()`. After a close, the next `ws()` call lazily creates a
-   * fresh `WsKlient` (so React StrictMode's mount → unmount → mount cycle,
-   * whose cleanup closes the socket, recovers on the second mount).
-   */
-  ws(): WsKlient {
-    if (this.wsKlient === undefined || this.wsKlient.state === 'closed') {
-      this.wsKlient = new WsKlient({
-        url: this.url,
-        token: this.token,
-        WebSocketImpl: this.wsImpl,
-      });
-    }
-    return this.wsKlient;
-  }
-}
-
-export class SessionClient {
-  private readonly baseUrl: string;
-
-  constructor(
-    url: string,
-    private readonly token: string | undefined,
-    private readonly fetchImpl: typeof fetch | undefined,
-    sessionId: string,
-  ) {
-    this.baseUrl = `${url.replace(/\/$/, '')}/api/v2/session/${encodeURIComponent(sessionId)}`;
-  }
-
-  /** Session-scoped Service, e.g. `.service(ISessionMetadata)`. */
-  service<T extends object>(id: ServiceIdentifier<T>): T {
-    const channel: IChannel = new HttpChannel({
-      baseUrl: `${this.baseUrl}/${String(id)}`,
-      token: this.token,
-      fetch: this.fetchImpl,
-    });
-    return makeProxy<T>(channel);
-  }
-
-  /** Agent scope entry point. */
-  agent(agentId: string): AgentClient {
-    return new AgentClient(this.baseUrl, this.token, this.fetchImpl, agentId);
-  }
-}
-
-export class AgentClient {
-  private readonly baseUrl: string;
-
-  constructor(
-    sessionBaseUrl: string,
-    private readonly token: string | undefined,
-    private readonly fetchImpl: typeof fetch | undefined,
-    agentId: string,
-  ) {
-    this.baseUrl = `${sessionBaseUrl}/agent/${encodeURIComponent(agentId)}`;
-  }
-
-  /** Agent-scoped Service, e.g. `.service(IAgentProfile)`. */
-  service<T extends object>(id: ServiceIdentifier<T>): T {
-    const channel: IChannel = new HttpChannel({
-      baseUrl: `${this.baseUrl}/${String(id)}`,
-      token: this.token,
-      fetch: this.fetchImpl,
-    });
-    return makeProxy<T>(channel);
-  }
-}
diff --git a/packages/klient/src/contract/agent/activity.ts b/packages/klient/src/contract/agent/activity.ts
new file mode 100644
index 000000000..5f9f0c5a0
--- /dev/null
+++ b/packages/klient/src/contract/agent/activity.ts
@@ -0,0 +1,75 @@
+/**
+ * `agentActivityView` — the agent's folded activity snapshot. Mirrors
+ * `agent-core-v2/agent/activityView/activityView.ts`. The `turn.origin`
+ * deep `PromptOrigin` union is mirrored as `unknown` (parity pins the
+ * engine → wire direction only, like `agentContextData.history`).
+ */
+
+import { z } from 'zod';
+
+import type { ServiceContract } from '../types.js';
+
+export const turnPhaseSchema = z.enum(['running', 'streaming', 'tool_call', 'retrying']);
+
+export const approvalRefSchema = z.object({
+  approvalId: z.string(),
+  toolCallId: z.string().optional(),
+  since: z.number(),
+});
+
+export const toolCallRefSchema = z.object({
+  toolCallId: z.string(),
+  name: z.string(),
+  since: z.number(),
+});
+
+export const activityRetryStateSchema = z.object({
+  failedAttempt: z.number(),
+  nextAttempt: z.number(),
+  maxAttempts: z.number(),
+  delayMs: z.number(),
+  errorName: z.string().optional(),
+  statusCode: z.number().optional(),
+});
+
+export const activityTurnStateSchema = z.object({
+  turnId: z.number(),
+  origin: z.unknown(),
+  phase: turnPhaseSchema,
+  stream: z.enum(['assistant', 'thinking', 'tool_call']).optional(),
+  step: z.number(),
+  ending: z.boolean(),
+  endingReason: z.enum(['aborted', 'max_steps', 'error']).optional(),
+  retry: activityRetryStateSchema.optional(),
+  pendingApprovals: z.array(approvalRefSchema),
+  activeToolCalls: z.array(toolCallRefSchema),
+  since: z.number(),
+});
+
+export const turnEndReasonSchema = z.enum(['completed', 'cancelled', 'failed', 'blocked']);
+
+export const activityLastTurnStateSchema = z.object({
+  turnId: z.number(),
+  reason: turnEndReasonSchema,
+  durationMs: z.number().optional(),
+  at: z.number(),
+});
+
+export const backgroundRefSchema = z.object({
+  kind: z.string(),
+  id: z.string(),
+  since: z.number(),
+});
+
+export const activityViewLifecycleSchema = z.enum(['ready', 'disposed']);
+
+export const agentActivityStateSchema = z.object({
+  lifecycle: activityViewLifecycleSchema,
+  turn: activityTurnStateSchema.optional(),
+  lastTurn: activityLastTurnStateSchema.optional(),
+  background: z.array(backgroundRefSchema),
+});
+
+export const agentActivityViewContract = {
+  state: { input: z.tuple([]), output: agentActivityStateSchema },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/agent/events.ts b/packages/klient/src/contract/agent/events.ts
new file mode 100644
index 000000000..6f7ced466
--- /dev/null
+++ b/packages/klient/src/contract/agent/events.ts
@@ -0,0 +1,174 @@
+/**
+ * Klient-level agent-scope events — the public, typed, namespaced event
+ * surface of one agent. All registrations filter the per-agent `events`
+ * scope stream by `type`; the payload is the whole flat `{ type, ... }`
+ * event (schemas keep the `type` literal so listeners receive it intact).
+ * Payload shapes mirror `protocol/src/events.ts`; events that are loose in
+ * the engine (or absent from the protocol union) are `z.looseObject`s.
+ */
+
+import { z } from 'zod';
+
+import type { EventRegistration } from '../types.js';
+
+/**
+ * Scope-stream registration (`kind: 'stream'`). Declared structurally here
+ * until `EventRegistration` in `../types.js` gains the `stream` variant;
+ * compatible with `src/core/events/hub.ts`, which already switches on it.
+ */
+interface StreamEventRegistration {
+  readonly kind: 'stream';
+  readonly name: string;
+  readonly type?: string;
+  readonly schema: z.ZodType;
+}
+
+type AgentEventRegistration = EventRegistration | StreamEventRegistration;
+
+// ── payload schemas ─────────────────────────────────────────────────────────
+
+export const turnStartedEventSchema = z.object({
+  type: z.literal('turn.started'),
+  turnId: z.number(),
+  /** Protocol `PromptOrigin` union — mirrored as `unknown`. */
+  origin: z.unknown(),
+});
+
+export const turnEndedEventSchema = z.object({
+  type: z.literal('turn.ended'),
+  turnId: z.number(),
+  reason: z.enum(['completed', 'cancelled', 'failed', 'blocked']),
+  /** Protocol `KimiErrorPayload` — mirrored as `unknown`. */
+  error: z.unknown().optional(),
+  durationMs: z.number().optional(),
+});
+
+export const assistantDeltaEventSchema = z.object({
+  type: z.literal('assistant.delta'),
+  turnId: z.number(),
+  delta: z.string(),
+});
+
+export const thinkingDeltaEventSchema = z.object({
+  type: z.literal('thinking.delta'),
+  turnId: z.number(),
+  delta: z.string(),
+});
+
+export const toolCallStartedEventSchema = z.object({
+  type: z.literal('tool.call.started'),
+  turnId: z.number(),
+  toolCallId: z.string(),
+  name: z.string(),
+  args: z.unknown(),
+  description: z.string().optional(),
+  /** Protocol `ToolInputDisplay` — mirrored as `unknown`. */
+  display: z.unknown().optional(),
+});
+
+export const toolResultEventSchema = z.object({
+  type: z.literal('tool.result'),
+  turnId: z.number(),
+  toolCallId: z.string(),
+  output: z.unknown(),
+  isError: z.boolean().optional(),
+  synthetic: z.boolean().optional(),
+});
+
+export const promptCompletedEventSchema = z.object({
+  type: z.literal('prompt.completed'),
+  promptId: z.string(),
+  /** ISO 8601 datetime string on the wire. */
+  finishedAt: z.string(),
+  reason: z.enum(['completed', 'failed', 'blocked']).optional(),
+});
+
+export const promptAbortedEventSchema = z.object({
+  type: z.literal('prompt.aborted'),
+  promptId: z.string(),
+  /** ISO 8601 datetime string on the wire. */
+  abortedAt: z.string(),
+});
+
+/** Engine `permission.approval.requested` — not in the protocol union; loose. */
+export const permissionApprovalRequestedEventSchema = z.looseObject({
+  turnId: z.number(),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  action: z.string(),
+});
+
+/** Engine `permission.approval.resolved` — not in the protocol union; loose. */
+export const permissionApprovalResolvedEventSchema = z.looseObject({
+  turnId: z.number(),
+  toolCallId: z.string(),
+});
+
+/** `error` payloads carry the full `KimiErrorPayload`; kept loose. */
+export const errorEventSchema = z.looseObject({
+  message: z.string(),
+});
+
+export const warningEventSchema = z.object({
+  type: z.literal('warning'),
+  message: z.string(),
+  code: z.string().optional(),
+});
+
+/** `agent.status.updated` carries a wide optional status bag; kept loose. */
+export const agentStatusUpdatedEventSchema = z.looseObject({
+  phase: z.string().optional(),
+});
+
+// ── registrations ───────────────────────────────────────────────────────────
+
+/** Public event name → payload type. Keys must stay in sync with `agentEvents`. */
+export interface AgentEventPayloads {
+  'turn.started': z.infer<typeof turnStartedEventSchema>;
+  'turn.ended': z.infer<typeof turnEndedEventSchema>;
+  'assistant.delta': z.infer<typeof assistantDeltaEventSchema>;
+  'thinking.delta': z.infer<typeof thinkingDeltaEventSchema>;
+  'tool.call.started': z.infer<typeof toolCallStartedEventSchema>;
+  'tool.result': z.infer<typeof toolResultEventSchema>;
+  'prompt.completed': z.infer<typeof promptCompletedEventSchema>;
+  'prompt.aborted': z.infer<typeof promptAbortedEventSchema>;
+  'permission.approval.requested': z.infer<typeof permissionApprovalRequestedEventSchema>;
+  'permission.approval.resolved': z.infer<typeof permissionApprovalResolvedEventSchema>;
+  error: z.infer<typeof errorEventSchema>;
+  warning: z.infer<typeof warningEventSchema>;
+  'agent.status.updated': z.infer<typeof agentStatusUpdatedEventSchema>;
+}
+
+export type AgentEventName = keyof AgentEventPayloads;
+
+/** Public event name → stream binding + payload schema. */
+export const agentEvents = {
+  'turn.started': { kind: 'stream', name: 'events', type: 'turn.started', schema: turnStartedEventSchema },
+  'turn.ended': { kind: 'stream', name: 'events', type: 'turn.ended', schema: turnEndedEventSchema },
+  'assistant.delta': { kind: 'stream', name: 'events', type: 'assistant.delta', schema: assistantDeltaEventSchema },
+  'thinking.delta': { kind: 'stream', name: 'events', type: 'thinking.delta', schema: thinkingDeltaEventSchema },
+  'tool.call.started': { kind: 'stream', name: 'events', type: 'tool.call.started', schema: toolCallStartedEventSchema },
+  'tool.result': { kind: 'stream', name: 'events', type: 'tool.result', schema: toolResultEventSchema },
+  'prompt.completed': { kind: 'stream', name: 'events', type: 'prompt.completed', schema: promptCompletedEventSchema },
+  'prompt.aborted': { kind: 'stream', name: 'events', type: 'prompt.aborted', schema: promptAbortedEventSchema },
+  'permission.approval.requested': {
+    kind: 'stream',
+    name: 'events',
+    type: 'permission.approval.requested',
+    schema: permissionApprovalRequestedEventSchema,
+  },
+  'permission.approval.resolved': {
+    kind: 'stream',
+    name: 'events',
+    type: 'permission.approval.resolved',
+    schema: permissionApprovalResolvedEventSchema,
+  },
+  error: { kind: 'stream', name: 'events', type: 'error', schema: errorEventSchema },
+  warning: { kind: 'stream', name: 'events', type: 'warning', schema: warningEventSchema },
+  'agent.status.updated': {
+    kind: 'stream',
+    name: 'events',
+    type: 'agent.status.updated',
+    schema: agentStatusUpdatedEventSchema,
+  },
+} satisfies Record<AgentEventName, AgentEventRegistration>;
diff --git a/packages/klient/src/contract/agent/rpc.ts b/packages/klient/src/contract/agent/rpc.ts
new file mode 100644
index 000000000..1e68532e6
--- /dev/null
+++ b/packages/klient/src/contract/agent/rpc.ts
@@ -0,0 +1,213 @@
+/**
+ * `agentRPCService` — the per-agent RPC surface. Mirrors the `AgentAPI`
+ * subset of `agent-core-v2/agent/rpc/core-api.ts`; every method takes one
+ * payload object. `PromptPayload.input` mirrors the `PromptPart` subset of
+ * `ContentPart` (text / image_url / video_url) from
+ * `agent-core-v2/app/llmProtocol/message.ts`. Task wire shapes mirror the
+ * `TaskInfo` union in `protocol/src/events.ts`.
+ */
+
+import { z } from 'zod';
+
+import { maybe, noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+// ── prompt parts ────────────────────────────────────────────────────────────
+
+const textPartSchema = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+});
+
+const imageUrlPartSchema = z.object({
+  type: z.literal('image_url'),
+  imageUrl: z.object({ url: z.string(), id: z.string().optional() }),
+});
+
+const videoUrlPartSchema = z.object({
+  type: z.literal('video_url'),
+  videoUrl: z.object({ url: z.string(), id: z.string().optional() }),
+});
+
+/** `PromptPart = Extract<ContentPart, { type: 'text' | 'image_url' | 'video_url' }>`. */
+export const promptPartSchema = z.discriminatedUnion('type', [
+  textPartSchema,
+  imageUrlPartSchema,
+  videoUrlPartSchema,
+]);
+
+// ── payloads / results ──────────────────────────────────────────────────────
+
+export const emptyPayloadSchema = z.object({});
+
+export const promptPayloadSchema = z.object({
+  input: z.array(promptPartSchema),
+});
+
+/** Same shape as `PromptPayload` in the engine. */
+export const steerPayloadSchema = promptPayloadSchema;
+
+export const promptLaunchResultSchema = z.object({
+  turn_id: z.number(),
+});
+
+export const cancelPayloadSchema = z.object({
+  turnId: z.number().optional(),
+});
+
+export const runShellCommandPayloadSchema = z.object({
+  command: z.string(),
+  commandId: z.string().optional(),
+});
+
+export const shellCommandResultSchema = z.object({
+  stdout: z.string(),
+  stderr: z.string(),
+  isError: z.boolean().optional(),
+  backgrounded: z.boolean().optional(),
+});
+
+export const cancelShellCommandPayloadSchema = z.object({
+  commandId: z.string(),
+});
+
+export const setModelPayloadSchema = z.object({
+  model: z.string(),
+});
+
+export const setModelResultSchema = z.object({
+  model: z.string(),
+  providerName: z.string().optional(),
+});
+
+export const permissionModeSchema = z.enum(['manual', 'yolo', 'auto']);
+
+export const setPermissionPayloadSchema = z.object({
+  mode: permissionModeSchema,
+});
+
+export const tokenUsageSchema = z.object({
+  inputOther: z.number(),
+  output: z.number(),
+  inputCacheRead: z.number(),
+  inputCacheCreation: z.number(),
+});
+
+export const usageStatusSchema = z.object({
+  byModel: z.record(z.string(), tokenUsageSchema).optional(),
+  currentTurn: tokenUsageSchema.optional(),
+  total: tokenUsageSchema.optional(),
+});
+
+/**
+ * `AgentContextData` — `history` items are full `ContextMessage`s (deep
+ * `Message` / `Tool` / `PromptOrigin` unions); mirrored as `unknown` entries.
+ */
+export const agentContextDataSchema = z.object({
+  history: z.array(z.unknown()),
+  tokenCount: z.number(),
+});
+
+/** `PlanData = null | { id, content, path }` — null is JSON-representable. */
+export const planDataSchema = z.union([
+  z.null(),
+  z.object({
+    id: z.string(),
+    content: z.string(),
+    path: z.string(),
+  }),
+]);
+
+export const cancelPlanPayloadSchema = z.object({
+  id: z.string().optional(),
+});
+
+export const getTasksPayloadSchema = z.object({
+  activeOnly: z.boolean().optional(),
+  limit: z.number().optional(),
+});
+
+const taskLifecycleStatusSchema = z.enum([
+  'running',
+  'completed',
+  'failed',
+  'timed_out',
+  'killed',
+  'lost',
+]);
+
+const taskInfoBaseFields = {
+  taskId: z.string(),
+  description: z.string(),
+  status: taskLifecycleStatusSchema,
+  detached: z.boolean().optional(),
+  startedAt: z.number(),
+  endedAt: z.union([z.number(), z.null()]),
+  stopReason: z.string().optional(),
+  terminalNotificationSuppressed: z.boolean().optional(),
+  timeoutMs: z.number().optional(),
+} as const;
+
+/** Protocol `TaskInfo` union (`protocol/src/events.ts`). */
+export const agentTaskInfoSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('process'),
+    command: z.string(),
+    pid: z.number(),
+    exitCode: z.union([z.number(), z.null()]),
+    ...taskInfoBaseFields,
+  }),
+  z.object({
+    kind: z.literal('agent'),
+    agentId: z.string().optional(),
+    subagentType: z.string().optional(),
+    ...taskInfoBaseFields,
+  }),
+  z.object({
+    kind: z.literal('question'),
+    questionCount: z.number(),
+    toolCallId: z.string().optional(),
+    ...taskInfoBaseFields,
+  }),
+]);
+
+export const stopTaskPayloadSchema = z.object({
+  taskId: z.string(),
+  reason: z.string().optional(),
+});
+
+export const getTaskOutputPayloadSchema = z.object({
+  taskId: z.string(),
+  tail: z.number().optional(),
+});
+
+// ── contract ────────────────────────────────────────────────────────────────
+
+export const agentRpcContract = {
+  prompt: { input: z.tuple([promptPayloadSchema]), output: maybe(promptLaunchResultSchema) },
+  steer: { input: z.tuple([steerPayloadSchema]), output: maybe(promptLaunchResultSchema) },
+  cancel: { input: z.tuple([cancelPayloadSchema]), output: noResult },
+  runShellCommand: {
+    input: z.tuple([runShellCommandPayloadSchema]),
+    output: shellCommandResultSchema,
+  },
+  cancelShellCommand: {
+    input: z.tuple([cancelShellCommandPayloadSchema]),
+    output: noResult,
+  },
+  getModel: { input: z.tuple([emptyPayloadSchema]), output: z.string() },
+  setModel: { input: z.tuple([setModelPayloadSchema]), output: setModelResultSchema },
+  setPermission: { input: z.tuple([setPermissionPayloadSchema]), output: noResult },
+  getUsage: { input: z.tuple([emptyPayloadSchema]), output: usageStatusSchema },
+  getContext: { input: z.tuple([emptyPayloadSchema]), output: agentContextDataSchema },
+  getPlan: { input: z.tuple([emptyPayloadSchema]), output: planDataSchema },
+  enterPlan: { input: z.tuple([emptyPayloadSchema]), output: noResult },
+  clearPlan: { input: z.tuple([emptyPayloadSchema]), output: noResult },
+  cancelPlan: { input: z.tuple([cancelPlanPayloadSchema]), output: noResult },
+  getTasks: {
+    input: z.tuple([getTasksPayloadSchema]),
+    output: z.array(agentTaskInfoSchema),
+  },
+  stopTask: { input: z.tuple([stopTaskPayloadSchema]), output: noResult },
+  getTaskOutput: { input: z.tuple([getTaskOutputPayloadSchema]), output: z.string() },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/auth.ts b/packages/klient/src/contract/global/auth.ts
new file mode 100644
index 000000000..618cede73
--- /dev/null
+++ b/packages/klient/src/contract/global/auth.ts
@@ -0,0 +1,104 @@
+/**
+ * `oauthService` + `authSummaryService` — app-scope OAuth flow and auth
+ * summary. Mirrors `agent-core-v2/app/auth/auth.ts`; wire shapes mirror
+ * `protocol/src/rest/oauth.ts` (snake_case fields). `resolveTokenProvider`
+ * and `getCachedAccessToken` are excluded (non-serializable).
+ */
+
+import { z } from 'zod';
+
+import { maybe, noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const oAuthFlowStatusSchema = z.enum([
+  'pending',
+  'authenticated',
+  'denied',
+  'expired',
+  'cancelled',
+]);
+
+export const oAuthFlowStartSchema = z.discriminatedUnion('status', [
+  z.object({
+    flow_id: z.string(),
+    provider: z.string(),
+    status: z.literal('pending'),
+    verification_uri: z.string(),
+    verification_uri_complete: z.string(),
+    user_code: z.string(),
+    expires_in: z.number(),
+    interval: z.number(),
+    expires_at: z.string(),
+  }),
+  z.object({
+    flow_id: z.string(),
+    provider: z.string(),
+    status: z.literal('authenticated'),
+  }),
+]);
+
+export const oAuthFlowSnapshotSchema = z.object({
+  flow_id: z.string(),
+  provider: z.string(),
+  status: oAuthFlowStatusSchema,
+  verification_uri: z.string(),
+  verification_uri_complete: z.string(),
+  user_code: z.string(),
+  expires_in: z.number(),
+  expires_at: z.string(),
+  interval: z.number(),
+  resolved_at: z.string().optional(),
+  error_message: z.string().optional(),
+});
+
+export const oAuthLoginCancelResponseSchema = z.object({
+  cancelled: z.boolean(),
+  status: oAuthFlowStatusSchema,
+});
+
+export const oAuthLogoutResponseSchema = z.object({
+  logged_out: z.literal(true),
+  provider: z.string(),
+});
+
+export const authStatusSchema = z.object({
+  loggedIn: z.boolean(),
+  provider: z.string().optional(),
+});
+
+/** Same shape as `refreshProviderModelsResponseSchema` in `./catalog.js` — keep in sync. */
+export const refreshOAuthProviderModelsResponseSchema = z.object({
+  changed: z.array(
+    z.object({
+      provider_id: z.string(),
+      provider_name: z.string(),
+      added: z.number(),
+      removed: z.number(),
+    }),
+  ),
+  unchanged: z.array(z.string()),
+  failed: z.array(z.object({ provider: z.string(), reason: z.string() })),
+});
+
+export const authContract = {
+  startLogin: { input: z.tuple([z.string().optional()]), output: oAuthFlowStartSchema },
+  getFlow: {
+    input: z.tuple([z.string().optional()]),
+    output: maybe(oAuthFlowSnapshotSchema),
+  },
+  cancelLogin: {
+    input: z.tuple([z.string().optional()]),
+    output: oAuthLoginCancelResponseSchema,
+  },
+  logout: { input: z.tuple([z.string().optional()]), output: oAuthLogoutResponseSchema },
+  status: { input: z.tuple([z.string().optional()]), output: authStatusSchema },
+  refreshOAuthProviderModels: {
+    input: z.tuple([]),
+    output: refreshOAuthProviderModelsResponseSchema,
+  },
+} satisfies ServiceContract;
+
+export const authSummaryContract = {
+  summarize: { input: z.tuple([]), output: z.array(authStatusSchema) },
+  ensureReady: { input: z.tuple([z.string().optional()]), output: noResult },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/catalog.ts b/packages/klient/src/contract/global/catalog.ts
new file mode 100644
index 000000000..7c7a68562
--- /dev/null
+++ b/packages/klient/src/contract/global/catalog.ts
@@ -0,0 +1,68 @@
+/**
+ * `modelCatalogService` — read-only catalog over configured providers and
+ * model aliases, plus the global default-model selection. Mirrors
+ * `agent-core-v2/app/modelCatalog/modelCatalog.ts`; wire shapes mirror
+ * `protocol/src/modelCatalog.ts` and `protocol/src/rest/modelCatalog.ts`
+ * (snake_case fields).
+ */
+
+import { z } from 'zod';
+
+import type { ServiceContract } from '../types.js';
+
+export const modelCatalogItemSchema = z.object({
+  provider: z.string(),
+  model: z.string(),
+  display_name: z.string().optional(),
+  max_context_size: z.number(),
+  capabilities: z.array(z.string()).optional(),
+  support_efforts: z.array(z.string()).optional(),
+  default_effort: z.string().optional(),
+});
+
+export const providerCatalogStatusSchema = z.enum(['connected', 'error', 'unconfigured']);
+
+export const providerCatalogItemSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  base_url: z.string().optional(),
+  default_model: z.string().optional(),
+  has_api_key: z.boolean(),
+  status: providerCatalogStatusSchema,
+  models: z.array(z.string()).optional(),
+});
+
+export const setDefaultModelResponseSchema = z.object({
+  default_model: z.string(),
+  model: modelCatalogItemSchema,
+});
+
+export const refreshProviderModelsOptionsSchema = z.object({
+  scope: z.enum(['all', 'oauth']).optional(),
+  providerId: z.string().optional(),
+});
+
+/** Same shape as `refreshOAuthProviderModelsResponseSchema` in `./auth.js` — keep in sync. */
+export const refreshProviderModelsResponseSchema = z.object({
+  changed: z.array(
+    z.object({
+      provider_id: z.string(),
+      provider_name: z.string(),
+      added: z.number(),
+      removed: z.number(),
+    }),
+  ),
+  unchanged: z.array(z.string()),
+  failed: z.array(z.object({ provider: z.string(), reason: z.string() })),
+});
+
+export const catalogContract = {
+  listModels: { input: z.tuple([]), output: z.array(modelCatalogItemSchema) },
+  listProviders: { input: z.tuple([]), output: z.array(providerCatalogItemSchema) },
+  getProvider: { input: z.tuple([z.string()]), output: providerCatalogItemSchema },
+  setDefaultModel: { input: z.tuple([z.string()]), output: setDefaultModelResponseSchema },
+  refreshProviderModels: {
+    input: z.tuple([refreshProviderModelsOptionsSchema.optional()]),
+    output: refreshProviderModelsResponseSchema,
+  },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/config.ts b/packages/klient/src/contract/global/config.ts
new file mode 100644
index 000000000..80b7097a2
--- /dev/null
+++ b/packages/klient/src/contract/global/config.ts
@@ -0,0 +1,40 @@
+/**
+ * `configService` — layered global config service. Mirrors
+ * `agent-core-v2/app/config/config.ts`.
+ */
+
+import { z } from 'zod';
+
+import { noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const configTargetSchema = z.enum(['user', 'memory']);
+
+export const configInspectValueSchema = z.object({
+  value: z.unknown().optional(),
+  defaultValue: z.unknown().optional(),
+  userValue: z.unknown().optional(),
+  memoryValue: z.unknown().optional(),
+});
+
+export const configDiagnosticSchema = z.object({
+  domain: z.string().optional(),
+  severity: z.enum(['warning', 'error']),
+  message: z.string(),
+});
+
+export const configContract = {
+  get: { input: z.tuple([z.string()]), output: z.unknown() },
+  inspect: { input: z.tuple([z.string()]), output: configInspectValueSchema },
+  getAll: { input: z.tuple([]), output: z.record(z.string(), z.unknown()) },
+  set: {
+    input: z.tuple([z.string(), z.unknown(), configTargetSchema.optional()]),
+    output: noResult,
+  },
+  replace: {
+    input: z.tuple([z.string(), z.unknown(), configTargetSchema.optional()]),
+    output: noResult,
+  },
+  reload: { input: z.tuple([]), output: noResult },
+  diagnostics: { input: z.tuple([]), output: z.array(configDiagnosticSchema) },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/env.ts b/packages/klient/src/contract/global/env.ts
new file mode 100644
index 000000000..f784f391a
--- /dev/null
+++ b/packages/klient/src/contract/global/env.ts
@@ -0,0 +1,26 @@
+/**
+ * `bootstrapService` — frozen startup snapshot: host facts and app path
+ * layout. Mirrors `agent-core-v2/app/bootstrap/bootstrap.ts`. The string
+ * properties are exposed as zero-arg reads.
+ */
+
+import { z } from 'zod';
+
+import type { ServiceContract } from '../types.js';
+
+const stringRead = { input: z.tuple([]), output: z.string() };
+
+export const envContract = {
+  platform: stringRead,
+  arch: stringRead,
+  cwd: stringRead,
+  osHomeDir: stringRead,
+  homeDir: stringRead,
+  configPath: stringRead,
+  clientVersion: stringRead,
+  sessionsDir: stringRead,
+  blobsDir: stringRead,
+  storeDir: stringRead,
+  cacheDir: stringRead,
+  logsDir: stringRead,
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/events.ts b/packages/klient/src/contract/global/events.ts
new file mode 100644
index 000000000..1f0b9e9c0
--- /dev/null
+++ b/packages/klient/src/contract/global/events.ts
@@ -0,0 +1,140 @@
+/**
+ * Klient-level global events — the public, typed, namespaced event surface.
+ * Each registration binds a public event name to its underlying source (the
+ * `IEventService` bus or one service's `onDid*` emitter) plus the zod schema
+ * its payload must satisfy. Consumers never see the engine's `onDid`/`onWill`
+ * naming; unknown bus event types are not forwarded.
+ */
+
+import { z } from 'zod';
+
+import type { ConfigChangedEvent } from '@moonshot-ai/agent-core-v2/app/config/config';
+import type { ModelsChangedEvent } from '@moonshot-ai/agent-core-v2/app/model/model';
+import type { ProvidersChangedEvent } from '@moonshot-ai/agent-core-v2/app/provider/provider';
+import type { ReloadSummary } from '@moonshot-ai/agent-core-v2/app/plugin/types';
+import type { IOAuthService } from '@moonshot-ai/agent-core-v2/app/auth/auth';
+
+import { stringDeltaSchema } from '../helpers.js';
+import type { EventRegistration } from '../types.js';
+
+/** Payload of `event.session.archived` on the global bus. */
+export interface SessionArchivedPayload {
+  readonly sessionId: string;
+}
+
+/** Payload of `session.meta.updated` on the global bus (`agent/rpc/prompt-metadata.ts`). */
+export interface SessionMetaUpdatedPayload {
+  readonly agentId: string;
+  readonly sessionId: string;
+  readonly title?: string;
+  readonly patch: {
+    readonly title?: string;
+    readonly isCustomTitle?: boolean;
+    readonly lastPrompt: string;
+  };
+}
+
+/** Payload of `event.model_catalog.changed` — same shape as an OAuth refresh result. */
+export type CatalogChangedPayload = Awaited<
+  ReturnType<IOAuthService['refreshOAuthProviderModels']>
+>;
+
+/** Public event name → payload type. Keys must stay in sync with `globalEvents`. */
+export interface KlientEventPayloads {
+  'config.changed': ConfigChangedEvent;
+  'config.sectionChanged': ConfigChangedEvent;
+  'providers.changed': ProvidersChangedEvent;
+  'models.changed': ModelsChangedEvent;
+  'plugins.reloaded': ReloadSummary;
+  'session.archived': SessionArchivedPayload;
+  'session.metaUpdated': SessionMetaUpdatedPayload;
+  'catalog.changed': CatalogChangedPayload;
+}
+
+export type KlientEventName = keyof KlientEventPayloads;
+
+const configChangedSchema = z.object({
+  domain: z.string(),
+  source: z.enum(['load', 'reload', 'set']),
+  value: z.unknown(),
+  previousValue: z.unknown(),
+});
+
+const reloadSummarySchema = z.object({
+  added: z.array(z.string()),
+  removed: z.array(z.string()),
+  errors: z.array(z.object({ id: z.string(), message: z.string() })),
+});
+
+const sessionMetaUpdatedSchema = z.object({
+  agentId: z.string(),
+  sessionId: z.string(),
+  title: z.string().optional(),
+  patch: z.object({
+    title: z.string().optional(),
+    isCustomTitle: z.boolean().optional(),
+    lastPrompt: z.string(),
+  }),
+});
+
+export const catalogChangedSchema = z.object({
+  changed: z.array(
+    z.object({
+      provider_id: z.string(),
+      provider_name: z.string(),
+      added: z.number(),
+      removed: z.number(),
+    }),
+  ),
+  unchanged: z.array(z.string()),
+  failed: z.array(z.object({ provider: z.string(), reason: z.string() })),
+});
+
+/** Public event name → source binding + payload schema. */
+export const globalEvents = {
+  'config.changed': {
+    kind: 'emitter',
+    service: 'configService',
+    event: 'onDidChangeConfiguration',
+    schema: configChangedSchema,
+  },
+  'config.sectionChanged': {
+    kind: 'emitter',
+    service: 'configService',
+    event: 'onDidSectionChange',
+    schema: configChangedSchema,
+  },
+  'providers.changed': {
+    kind: 'emitter',
+    service: 'providerService',
+    event: 'onDidChangeProviders',
+    schema: stringDeltaSchema,
+  },
+  'models.changed': {
+    kind: 'emitter',
+    service: 'modelService',
+    event: 'onDidChangeModels',
+    schema: stringDeltaSchema,
+  },
+  'plugins.reloaded': {
+    kind: 'emitter',
+    service: 'pluginService',
+    event: 'onDidReload',
+    schema: reloadSummarySchema,
+  },
+  'session.archived': {
+    kind: 'bus',
+    type: 'event.session.archived',
+    schema: z.object({ sessionId: z.string() }),
+  },
+  'session.metaUpdated': {
+    kind: 'bus',
+    type: 'session.meta.updated',
+    schema: sessionMetaUpdatedSchema,
+  },
+  'catalog.changed': {
+    kind: 'bus',
+    type: 'event.model_catalog.changed',
+    schema: catalogChangedSchema,
+  },
+} satisfies Record<KlientEventName, EventRegistration>;
diff --git a/packages/klient/src/contract/global/flags.ts b/packages/klient/src/contract/global/flags.ts
new file mode 100644
index 000000000..d842fd5e7
--- /dev/null
+++ b/packages/klient/src/contract/global/flags.ts
@@ -0,0 +1,30 @@
+/**
+ * `flagService` — experimental-flag resolution. Mirrors
+ * `agent-core-v2/app/flag/flag.ts`. The `registry` property and
+ * `setConfigOverrides` are excluded (not part of the read-only wire surface).
+ */
+
+import { z } from 'zod';
+
+import { maybe } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const experimentalFeatureStateSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  surface: z.enum(['core', 'tui', 'both']),
+  env: z.string(),
+  defaultEnabled: z.boolean(),
+  enabled: z.boolean(),
+  source: z.enum(['master-env', 'env', 'config', 'default']),
+  configValue: z.boolean().optional(),
+});
+
+export const flagsContract = {
+  enabled: { input: z.tuple([z.string()]), output: z.boolean() },
+  snapshot: { input: z.tuple([]), output: z.record(z.string(), z.boolean()) },
+  enabledIds: { input: z.tuple([]), output: z.array(z.string()) },
+  explain: { input: z.tuple([z.string()]), output: maybe(experimentalFeatureStateSchema) },
+  explainAll: { input: z.tuple([]), output: z.array(experimentalFeatureStateSchema) },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/hostFs.ts b/packages/klient/src/contract/global/hostFs.ts
new file mode 100644
index 000000000..7b19146d8
--- /dev/null
+++ b/packages/klient/src/contract/global/hostFs.ts
@@ -0,0 +1,31 @@
+/**
+ * `hostFolderBrowser` — host-side folder picker for choosing a workspace
+ * folder. Mirrors `agent-core-v2/app/hostFolderBrowser/hostFolderBrowser.ts`;
+ * wire shapes mirror `protocol/src/rest/fsBrowse.ts` (snake_case fields).
+ */
+
+import { z } from 'zod';
+
+import type { ServiceContract } from '../types.js';
+
+export const fsBrowseEntrySchema = z.object({
+  name: z.string().min(1),
+  path: z.string().min(1),
+  is_dir: z.literal(true),
+});
+
+export const fsBrowseResponseSchema = z.object({
+  path: z.string().min(1),
+  parent: z.string().min(1).nullable(),
+  entries: z.array(fsBrowseEntrySchema),
+});
+
+export const fsHomeResponseSchema = z.object({
+  home: z.string().min(1),
+  recent_roots: z.array(z.string().min(1)),
+});
+
+export const hostFsContract = {
+  browse: { input: z.tuple([z.string().optional()]), output: fsBrowseResponseSchema },
+  home: { input: z.tuple([]), output: fsHomeResponseSchema },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/models.ts b/packages/klient/src/contract/global/models.ts
new file mode 100644
index 000000000..e61fcf9a0
--- /dev/null
+++ b/packages/klient/src/contract/global/models.ts
@@ -0,0 +1,77 @@
+/**
+ * `modelService` — model configuration registry. Mirrors
+ * `agent-core-v2/app/model/model.ts` (`ModelSchema`, including its
+ * passthrough of unknown keys) and `agent-core-v2/app/protocol/protocol.ts`
+ * (`ProtocolSchema`).
+ */
+
+import { z } from 'zod';
+
+import { maybe, noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+const protocolSchema = z.enum([
+  'kimi',
+  'anthropic',
+  'openai',
+  'openai_responses',
+  'google-genai',
+  'vertexai',
+]);
+
+const oAuthRefSchema = z.object({
+  storage: z.enum(['file', 'keyring']),
+  key: z.string().min(1),
+  oauthHost: z.string().min(1).optional(),
+});
+
+const modelBaseSchema = z.object({
+  providerId: z.string().optional(),
+
+  baseUrl: z.string().optional(),
+  apiKey: z.string().optional(),
+  oauth: oAuthRefSchema.optional(),
+
+  protocol: protocolSchema.optional(),
+
+  name: z.string().optional(),
+  aliases: z.array(z.string()).optional(),
+
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  maxContextSize: z.number().int().min(1).optional(),
+  maxOutputSize: z.number().int().min(1).optional(),
+  capabilities: z.array(z.string()).optional(),
+  displayName: z.string().optional(),
+  reasoningKey: z.string().optional(),
+  adaptiveThinking: z.boolean().optional(),
+  betaApi: z.boolean().optional(),
+  supportEfforts: z.array(z.string()).optional(),
+  defaultEffort: z.string().optional(),
+});
+
+const modelOverrideSchema = modelBaseSchema
+  .omit({
+    providerId: true,
+    baseUrl: true,
+    apiKey: true,
+    oauth: true,
+    protocol: true,
+    name: true,
+    aliases: true,
+    provider: true,
+    model: true,
+    betaApi: true,
+  })
+  .partial();
+
+export const modelConfigSchema = modelBaseSchema
+  .extend({ overrides: modelOverrideSchema.optional() })
+  .passthrough();
+
+export const modelsContract = {
+  get: { input: z.tuple([z.string()]), output: maybe(modelConfigSchema) },
+  list: { input: z.tuple([]), output: z.record(z.string(), modelConfigSchema) },
+  set: { input: z.tuple([z.string(), modelConfigSchema]), output: noResult },
+  delete: { input: z.tuple([z.string()]), output: noResult },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/plugins.ts b/packages/klient/src/contract/global/plugins.ts
new file mode 100644
index 000000000..ef0e2baca
--- /dev/null
+++ b/packages/klient/src/contract/global/plugins.ts
@@ -0,0 +1,239 @@
+/**
+ * `pluginService` — plugin management and consumption. Mirrors
+ * `agent-core-v2/app/plugin/plugin.ts` and `agent-core-v2/app/plugin/types.ts`;
+ * nested `McpServerConfig` mirrors `agent-core-v2/agent/mcp/config-schema.ts`,
+ * `HookDefConfig` mirrors `agent-core-v2/agent/externalHooks/configSection.ts`.
+ * `pluginSkillRoots`, `enabledSessionStarts`, `enabledMcpServers`, and
+ * `enabledHooks` are excluded (not part of the klient wire surface).
+ */
+
+import { z } from 'zod';
+
+import { noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const pluginDiagnosticSchema = z.object({
+  severity: z.enum(['error', 'warn', 'info']),
+  message: z.string(),
+});
+
+const pluginAuthorSchema = z.object({
+  name: z.string().optional(),
+  email: z.string().optional(),
+});
+
+const pluginSessionStartSchema = z.object({
+  skill: z.string(),
+});
+
+const pluginInterfaceSchema = z.object({
+  displayName: z.string().optional(),
+  shortDescription: z.string().optional(),
+  longDescription: z.string().optional(),
+  developerName: z.string().optional(),
+  websiteURL: z.string().optional(),
+});
+
+const stringRecordSchema = z.record(z.string(), z.string());
+
+const mcpServerCommonFields = {
+  enabled: z.boolean().optional(),
+  startupTimeoutMs: z.number().int().min(1).optional(),
+  toolTimeoutMs: z.number().int().min(1).optional(),
+  enabledTools: z.array(z.string()).optional(),
+  disabledTools: z.array(z.string()).optional(),
+} as const;
+
+const mcpServerConfigSchema = z.discriminatedUnion('transport', [
+  z.object({
+    transport: z.literal('stdio'),
+    command: z.string().min(1),
+    args: z.array(z.string()).optional(),
+    env: stringRecordSchema.optional(),
+    cwd: z.string().optional(),
+    executor: z.enum(['local', 'kaos']).optional(),
+    ...mcpServerCommonFields,
+  }),
+  z.object({
+    transport: z.literal('http'),
+    url: z.string().url(),
+    headers: stringRecordSchema.optional(),
+    bearerTokenEnvVar: z.string().min(1).optional(),
+    ...mcpServerCommonFields,
+  }),
+  z.object({
+    transport: z.literal('sse'),
+    url: z.string().url(),
+    headers: stringRecordSchema.optional(),
+    bearerTokenEnvVar: z.string().min(1).optional(),
+    ...mcpServerCommonFields,
+  }),
+]);
+
+const hookDefSchema = z.object({
+  event: z.enum([
+    'PreToolUse',
+    'PostToolUse',
+    'PostToolUseFailure',
+    'PermissionRequest',
+    'PermissionResult',
+    'UserPromptSubmit',
+    'Stop',
+    'StopFailure',
+    'Interrupt',
+    'SessionStart',
+    'SessionEnd',
+    'SubagentStart',
+    'SubagentStop',
+    'PreCompact',
+    'PostCompact',
+    'Notification',
+  ]),
+  matcher: z.string().optional(),
+  command: z.string().min(1),
+  timeout: z.number().int().min(1).max(600).optional(),
+});
+
+const pluginCommandEntrySchema = z.object({
+  path: z.string(),
+  name: z.string(),
+});
+
+const pluginManifestKindSchema = z.enum(['kimi-plugin-root', 'kimi-plugin-dir']);
+
+const pluginSourceSchema = z.enum(['local-path', 'zip-url', 'github']);
+
+const pluginStateSchema = z.enum(['ok', 'error']);
+
+const pluginGithubRefSchema = z.object({
+  kind: z.enum(['branch', 'tag', 'sha']),
+  value: z.string(),
+});
+
+export const pluginManifestSchema = z.object({
+  name: z.string(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  keywords: z.array(z.string()).optional(),
+  author: pluginAuthorSchema.optional(),
+  homepage: z.string().optional(),
+  license: z.string().optional(),
+  skills: z.array(z.string()).optional(),
+  sessionStart: pluginSessionStartSchema.optional(),
+  mcpServers: z.record(z.string(), mcpServerConfigSchema).optional(),
+  hooks: z.array(hookDefSchema).optional(),
+  commands: z.array(pluginCommandEntrySchema).optional(),
+  interface: pluginInterfaceSchema.optional(),
+  skillInstructions: z.string().optional(),
+});
+
+export const pluginMcpServerInfoSchema = z.object({
+  name: z.string(),
+  runtimeName: z.string(),
+  enabled: z.boolean(),
+  transport: z.enum(['stdio', 'http', 'sse']),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  cwd: z.string().optional(),
+  url: z.string().optional(),
+  envKeys: z.array(z.string()).optional(),
+  headerKeys: z.array(z.string()).optional(),
+});
+
+export const pluginGithubMetadataSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  ref: pluginGithubRefSchema,
+  installedSha: z.string().optional(),
+});
+
+export const pluginSummarySchema = z.object({
+  id: z.string(),
+  displayName: z.string(),
+  version: z.string().optional(),
+  enabled: z.boolean(),
+  state: pluginStateSchema,
+  skillCount: z.number(),
+  mcpServerCount: z.number(),
+  enabledMcpServerCount: z.number(),
+  hookCount: z.number(),
+  commandCount: z.number(),
+  hasErrors: z.boolean(),
+  source: pluginSourceSchema,
+  originalSource: z.string().optional(),
+  github: pluginGithubMetadataSchema.optional(),
+});
+
+export const pluginInfoSchema = pluginSummarySchema.extend({
+  root: z.string(),
+  installedAt: z.string(),
+  updatedAt: z.string().optional(),
+  manifestKind: pluginManifestKindSchema.optional(),
+  manifestPath: z.string().optional(),
+  manifest: pluginManifestSchema.optional(),
+  mcpServers: z.array(pluginMcpServerInfoSchema),
+  shadowedManifestPath: z.string().optional(),
+  diagnostics: z.array(pluginDiagnosticSchema),
+});
+
+/** Same shape as `reloadSummarySchema` in `./events.js` — keep in sync. */
+export const reloadSummarySchema = z.object({
+  added: z.array(z.string()),
+  removed: z.array(z.string()),
+  errors: z.array(z.object({ id: z.string(), message: z.string() })),
+});
+
+export const pluginUpdateStatusSchema = z.object({
+  id: z.string(),
+  source: pluginSourceSchema,
+  current: pluginGithubRefSchema.optional(),
+  latest: pluginGithubRefSchema,
+  displayVersion: z.string(),
+  updateAvailable: z.boolean(),
+});
+
+export const pluginCommandDefSchema = z.object({
+  pluginId: z.string(),
+  name: z.string(),
+  description: z.string(),
+  body: z.string(),
+  path: z.string(),
+});
+
+export const installPluginInputSchema = z.object({
+  source: z.string(),
+});
+
+export const setPluginEnabledInputSchema = z.object({
+  id: z.string(),
+  enabled: z.boolean(),
+});
+
+export const setPluginMcpServerEnabledInputSchema = z.object({
+  id: z.string(),
+  server: z.string(),
+  enabled: z.boolean(),
+});
+
+export const removePluginInputSchema = z.object({
+  id: z.string(),
+});
+
+export const getPluginInfoInputSchema = z.object({
+  id: z.string(),
+});
+
+export const pluginsContract = {
+  listPlugins: { input: z.tuple([]), output: z.array(pluginSummarySchema) },
+  installPlugin: { input: z.tuple([installPluginInputSchema]), output: pluginSummarySchema },
+  setPluginEnabled: { input: z.tuple([setPluginEnabledInputSchema]), output: noResult },
+  setPluginMcpServerEnabled: {
+    input: z.tuple([setPluginMcpServerEnabledInputSchema]),
+    output: noResult,
+  },
+  removePlugin: { input: z.tuple([removePluginInputSchema]), output: noResult },
+  reloadPlugins: { input: z.tuple([]), output: reloadSummarySchema },
+  getPluginInfo: { input: z.tuple([getPluginInfoInputSchema]), output: pluginInfoSchema },
+  listPluginCommands: { input: z.tuple([]), output: z.array(pluginCommandDefSchema) },
+  checkUpdates: { input: z.tuple([]), output: z.array(pluginUpdateStatusSchema) },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/providers.ts b/packages/klient/src/contract/global/providers.ts
new file mode 100644
index 000000000..72f158de0
--- /dev/null
+++ b/packages/klient/src/contract/global/providers.ts
@@ -0,0 +1,50 @@
+/**
+ * `providerService` — provider configuration registry. Mirrors
+ * `agent-core-v2/app/provider/provider.ts` (`ProviderConfigSchema`).
+ */
+
+import { z } from 'zod';
+
+import { maybe, noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+const providerTypeSchema = z.enum([
+  'anthropic',
+  'openai',
+  'kimi',
+  'google-genai',
+  'openai_responses',
+  'vertexai',
+]);
+
+const oAuthRefSchema = z.object({
+  storage: z.enum(['file', 'keyring']),
+  key: z.string().min(1),
+  oauthHost: z.string().min(1).optional(),
+});
+
+const stringRecordSchema = z.record(z.string(), z.string());
+
+const modelSourceSchema = z.enum(['static', 'discover', 'oauth-catalog']);
+
+export const providerConfigSchema = z.object({
+  platformId: z.string().optional(),
+  modelSource: modelSourceSchema.optional(),
+
+  baseUrl: z.string().optional(),
+  customHeaders: stringRecordSchema.optional(),
+  defaultModel: z.string().optional(),
+
+  type: providerTypeSchema.optional(),
+  apiKey: z.string().optional(),
+  oauth: oAuthRefSchema.optional(),
+  env: stringRecordSchema.optional(),
+  source: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const providersContract = {
+  get: { input: z.tuple([z.string()]), output: maybe(providerConfigSchema) },
+  list: { input: z.tuple([]), output: z.record(z.string(), providerConfigSchema) },
+  set: { input: z.tuple([z.string(), providerConfigSchema]), output: noResult },
+  delete: { input: z.tuple([z.string()]), output: noResult },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/sessions.ts b/packages/klient/src/contract/global/sessions.ts
new file mode 100644
index 000000000..3e389bdaf
--- /dev/null
+++ b/packages/klient/src/contract/global/sessions.ts
@@ -0,0 +1,36 @@
+/**
+ * `sessionIndex` — the persisted session read model. Mirrors
+ * `agent-core-v2/app/sessionIndex/sessionIndex.ts`.
+ */
+
+import { z } from 'zod';
+
+import { maybe, pageOf } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const sessionSummarySchema = z.object({
+  id: z.string(),
+  workspaceId: z.string(),
+  cwd: z.string().optional(),
+  title: z.string().optional(),
+  lastPrompt: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  archived: z.boolean(),
+  custom: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const sessionListQuerySchema = z.object({
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  includeArchived: z.boolean().optional(),
+  cursor: z.string().optional(),
+  limit: z.number().optional(),
+  childOf: z.string().optional(),
+});
+
+export const sessionsContract = {
+  list: { input: z.tuple([sessionListQuerySchema]), output: pageOf(sessionSummarySchema) },
+  get: { input: z.tuple([z.string()]), output: maybe(sessionSummarySchema) },
+  countActive: { input: z.tuple([z.string()]), output: z.number() },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/global/workspaces.ts b/packages/klient/src/contract/global/workspaces.ts
new file mode 100644
index 000000000..d5577f2c1
--- /dev/null
+++ b/packages/klient/src/contract/global/workspaces.ts
@@ -0,0 +1,35 @@
+/**
+ * `workspaceRegistry` — process-wide catalog of known workspaces. Mirrors
+ * `agent-core-v2/app/workspaceRegistry/workspaceRegistry.ts`.
+ */
+
+import { z } from 'zod';
+
+import { maybe, noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const workspaceSchema = z.object({
+  id: z.string(),
+  root: z.string(),
+  name: z.string(),
+  createdAt: z.number(),
+  lastOpenedAt: z.number(),
+});
+
+export const workspaceUpdateSchema = z.object({
+  name: z.string().optional(),
+});
+
+export const workspacesContract = {
+  list: { input: z.tuple([]), output: z.array(workspaceSchema) },
+  get: { input: z.tuple([z.string()]), output: maybe(workspaceSchema) },
+  createOrTouch: {
+    input: z.tuple([z.string(), z.string().optional()]),
+    output: workspaceSchema,
+  },
+  update: {
+    input: z.tuple([z.string(), workspaceUpdateSchema]),
+    output: maybe(workspaceSchema),
+  },
+  delete: { input: z.tuple([z.string()]), output: noResult },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/helpers.ts b/packages/klient/src/contract/helpers.ts
new file mode 100644
index 000000000..377d5cc94
--- /dev/null
+++ b/packages/klient/src/contract/helpers.ts
@@ -0,0 +1,35 @@
+/**
+ * Shared schema helpers for contract fragments.
+ */
+
+import { z } from 'zod';
+
+/** `Page<T>` on the wire (`persistence/interface/queryStore.ts`). */
+export const pageOf = <T extends z.ZodType>(item: T) =>
+  z.object({
+    items: z.array(item),
+    nextCursor: z.string().optional(),
+  });
+
+/**
+ * Engine `X | undefined` returns cross the wire as `null` over HTTP (JSON
+ * has no `undefined`) and as `undefined` in-process — accept both and
+ * normalize to `undefined`.
+ */
+export const maybe = <T extends z.ZodType>(schema: T) =>
+  z.union([schema, z.null(), z.undefined()]).transform((value) => value ?? undefined);
+
+/**
+ * `void` method results arrive as `null` over HTTP (JSON has no `undefined`)
+ * and as `undefined` in-process — accept both and normalize to `undefined`.
+ */
+export const noResult = z
+  .union([z.void(), z.null()])
+  .transform(() => undefined);
+
+/** Engine `{ added, removed, changed }` change-set events. */
+export const stringDeltaSchema = z.object({
+  added: z.array(z.string()),
+  removed: z.array(z.string()),
+  changed: z.array(z.string()),
+});
diff --git a/packages/klient/src/contract/index.ts b/packages/klient/src/contract/index.ts
new file mode 100644
index 000000000..4ec7235ba
--- /dev/null
+++ b/packages/klient/src/contract/index.ts
@@ -0,0 +1,54 @@
+/**
+ * The aggregated klient contract — service wire name → method → zod
+ * input/output schemas, across the core/session/agent scopes. The klient
+ * factory validates every call against this table; transports never see it.
+ * Event registrations live in the per-scope `events.ts` files alongside
+ * their payload schemas.
+ */
+
+import type { KlientContract } from './types.js';
+import { agentActivityViewContract } from './agent/activity.js';
+import { agentRpcContract } from './agent/rpc.js';
+import { authContract, authSummaryContract } from './global/auth.js';
+import { catalogContract } from './global/catalog.js';
+import { configContract } from './global/config.js';
+import { envContract } from './global/env.js';
+import { flagsContract } from './global/flags.js';
+import { hostFsContract } from './global/hostFs.js';
+import { modelsContract } from './global/models.js';
+import { pluginsContract } from './global/plugins.js';
+import { providersContract } from './global/providers.js';
+import { sessionsContract } from './global/sessions.js';
+import { workspacesContract } from './global/workspaces.js';
+import { sessionApprovalContract } from './session/approval.js';
+import { sessionInteractionContract } from './session/interaction.js';
+import { sessionLifecycleContract } from './session/lifecycle.js';
+import { sessionMetadataContract } from './session/metadata.js';
+import { sessionQuestionContract } from './session/question.js';
+
+export const globalContract: KlientContract = {
+  // core (app scope)
+  sessionIndex: sessionsContract,
+  workspaceRegistry: workspacesContract,
+  configService: configContract,
+  providerService: providersContract,
+  modelService: modelsContract,
+  modelCatalogService: catalogContract,
+  oauthService: authContract,
+  authSummaryService: authSummaryContract,
+  flagService: flagsContract,
+  pluginService: pluginsContract,
+  hostFolderBrowser: hostFsContract,
+  bootstrapService: envContract,
+  // session scope (+ the app-registered lifecycle service)
+  sessionLifecycleService: sessionLifecycleContract,
+  sessionMetadata: sessionMetadataContract,
+  sessionInteractionService: sessionInteractionContract,
+  sessionApprovalService: sessionApprovalContract,
+  sessionQuestionService: sessionQuestionContract,
+  // agent scope
+  agentRPCService: agentRpcContract,
+  agentActivityView: agentActivityViewContract,
+};
+
+export type { KlientContract, ProcedureContract, ServiceContract } from './types.js';
diff --git a/packages/klient/src/contract/session/approval.ts b/packages/klient/src/contract/session/approval.ts
new file mode 100644
index 000000000..8256c3376
--- /dev/null
+++ b/packages/klient/src/contract/session/approval.ts
@@ -0,0 +1,35 @@
+/**
+ * `sessionApprovalService` — session-scope approval broker. Mirrors
+ * `agent-core-v2/session/approval/approval.ts`. `ApprovalRequest.display` is
+ * the protocol `ToolInputDisplay` union (huge); it crosses the wire
+ * uninspected, so it is `z.unknown()` here.
+ */
+
+import { z } from 'zod';
+
+import { noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const approvalRequestSchema = z.object({
+  id: z.string().optional(),
+  sessionId: z.string().optional(),
+  agentId: z.string().optional(),
+  turnId: z.number().optional(),
+  toolCallId: z.string().optional(),
+  toolName: z.string(),
+  action: z.string(),
+  /** Protocol `ToolInputDisplay` — mirrored as `unknown` (see file header). */
+  display: z.unknown(),
+});
+
+export const approvalResponseSchema = z.object({
+  decision: z.enum(['approved', 'rejected', 'cancelled']),
+  scope: z.literal('session').optional(),
+  feedback: z.string().optional(),
+  selectedLabel: z.string().optional(),
+});
+
+export const sessionApprovalContract = {
+  listPending: { input: z.tuple([]), output: z.array(approvalRequestSchema) },
+  decide: { input: z.tuple([z.string(), approvalResponseSchema]), output: noResult },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/session/events.ts b/packages/klient/src/contract/session/events.ts
new file mode 100644
index 000000000..75f037bb0
--- /dev/null
+++ b/packages/klient/src/contract/session/events.ts
@@ -0,0 +1,66 @@
+/**
+ * Klient-level session-scope events — the public, typed, namespaced event
+ * surface of one session. Mirrors the pattern of `../global/events.ts`;
+ * stream names match the kap-server session event map (`interactions`,
+ * `interactions:resolved`).
+ */
+
+import { z } from 'zod';
+
+import type {
+  Interaction,
+  InteractionResolution,
+} from '@moonshot-ai/agent-core-v2/session/interaction/interaction';
+import type { SessionMetadataChangedEvent } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
+
+import type { EventRegistration } from '../types.js';
+import {
+  interactionResolutionSchema,
+  interactionSchema,
+} from './interaction.js';
+import { sessionMetadataChangedEventSchema } from './metadata.js';
+
+/**
+ * Scope-stream registration (`kind: 'stream'`). Declared structurally here
+ * until `EventRegistration` in `../types.js` gains the `stream` variant;
+ * compatible with `src/core/events/hub.ts`, which already switches on it.
+ */
+interface StreamEventRegistration {
+  readonly kind: 'stream';
+  readonly name: string;
+  readonly type?: string;
+  readonly schema: z.ZodType;
+}
+
+type SessionEventRegistration = EventRegistration | StreamEventRegistration;
+
+/** Public event name → payload type. Keys must stay in sync with `sessionEvents`. */
+export interface SessionEventPayloads {
+  'metadata.changed': SessionMetadataChangedEvent;
+  'interactions.changed': readonly Interaction[];
+  'interactions.resolved': InteractionResolution;
+}
+
+export type SessionEventName = keyof SessionEventPayloads;
+
+/** Public event name → source binding + payload schema. */
+export const sessionEvents = {
+  'metadata.changed': {
+    kind: 'emitter',
+    service: 'sessionMetadata',
+    event: 'onDidChangeMetadata',
+    schema: sessionMetadataChangedEventSchema,
+  },
+  // Passthrough stream (no `type` filter): the source pushes the full
+  // pending interaction set on every change.
+  'interactions.changed': {
+    kind: 'stream',
+    name: 'interactions',
+    schema: z.array(interactionSchema),
+  },
+  'interactions.resolved': {
+    kind: 'stream',
+    name: 'interactions:resolved',
+    schema: interactionResolutionSchema,
+  },
+} satisfies Record<SessionEventName, SessionEventRegistration>;
diff --git a/packages/klient/src/contract/session/interaction.ts b/packages/klient/src/contract/session/interaction.ts
new file mode 100644
index 000000000..a7d5153b4
--- /dev/null
+++ b/packages/klient/src/contract/session/interaction.ts
@@ -0,0 +1,38 @@
+/**
+ * `sessionInteractionService` — blocking human-in-the-loop request kernel.
+ * Mirrors `agent-core-v2/session/interaction/interaction.ts`.
+ */
+
+import { z } from 'zod';
+
+import { noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const interactionKindSchema = z.enum(['approval', 'question', 'user_tool']);
+
+export const interactionOriginSchema = z.object({
+  agentId: z.string().optional(),
+  turnId: z.number().optional(),
+});
+
+export const interactionSchema = z.object({
+  id: z.string(),
+  kind: interactionKindSchema,
+  payload: z.unknown(),
+  origin: interactionOriginSchema,
+  createdAt: z.number(),
+});
+
+export const interactionResolutionSchema = z.object({
+  id: z.string(),
+  response: z.unknown(),
+});
+
+export const sessionInteractionContract = {
+  listPending: {
+    input: z.tuple([interactionKindSchema.optional()]),
+    output: z.array(interactionSchema),
+  },
+  respond: { input: z.tuple([z.string(), z.unknown()]), output: noResult },
+  isRecentlyResolved: { input: z.tuple([z.string()]), output: z.boolean() },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/session/lifecycle.ts b/packages/klient/src/contract/session/lifecycle.ts
new file mode 100644
index 000000000..355ceb401
--- /dev/null
+++ b/packages/klient/src/contract/session/lifecycle.ts
@@ -0,0 +1,86 @@
+/**
+ * `sessionLifecycleService` — creates and tracks sessions at the process
+ * root. Mirrors `agent-core-v2/app/sessionLifecycle/sessionLifecycle.ts`.
+ * The engine returns `ISessionScopeHandle`s; over JSON only the plain data
+ * fields survive, so the wire keeps `{ id, kind }` (loose — extra fields may
+ * appear in-process).
+ */
+
+import { z } from 'zod';
+
+import { maybe, noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+/**
+ * Mirror of `mcpServerConfigSchema` in `../global/plugins.js` — kept local
+ * because that fragment does not export its copy; keep the two in sync.
+ * Mirrors `agent-core-v2/agent/mcp/config-schema.ts`.
+ */
+const stringRecordSchema = z.record(z.string(), z.string());
+
+const mcpServerCommonFields = {
+  enabled: z.boolean().optional(),
+  startupTimeoutMs: z.number().int().min(1).optional(),
+  toolTimeoutMs: z.number().int().min(1).optional(),
+  enabledTools: z.array(z.string()).optional(),
+  disabledTools: z.array(z.string()).optional(),
+} as const;
+
+const mcpServerConfigSchema = z.discriminatedUnion('transport', [
+  z.object({
+    transport: z.literal('stdio'),
+    command: z.string().min(1),
+    args: z.array(z.string()).optional(),
+    env: stringRecordSchema.optional(),
+    cwd: z.string().optional(),
+    executor: z.enum(['local', 'kaos']).optional(),
+    ...mcpServerCommonFields,
+  }),
+  z.object({
+    transport: z.literal('http'),
+    url: z.string().url(),
+    headers: stringRecordSchema.optional(),
+    bearerTokenEnvVar: z.string().min(1).optional(),
+    ...mcpServerCommonFields,
+  }),
+  z.object({
+    transport: z.literal('sse'),
+    url: z.string().url(),
+    headers: stringRecordSchema.optional(),
+    bearerTokenEnvVar: z.string().min(1).optional(),
+    ...mcpServerCommonFields,
+  }),
+]);
+
+export const createSessionOptionsSchema = z.object({
+  sessionId: z.string().optional(),
+  workDir: z.string(),
+  additionalDirs: z.array(z.string()).optional(),
+  mcpServers: z.record(z.string(), mcpServerConfigSchema).optional(),
+});
+
+export const forkSessionOptionsSchema = z.object({
+  sourceSessionId: z.string(),
+  newSessionId: z.string().optional(),
+  title: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+/** Same fields as `ForkSessionOptions` in the engine — keep in sync. */
+export const createChildSessionOptionsSchema = forkSessionOptionsSchema;
+
+/** `ISessionScopeHandle` as it survives JSON — `{ id, kind }` plus extras. */
+export const handleWireSchema = z.looseObject({
+  id: z.string(),
+  kind: z.number(),
+});
+
+export const sessionLifecycleContract = {
+  create: { input: z.tuple([createSessionOptionsSchema]), output: handleWireSchema },
+  resume: { input: z.tuple([z.string()]), output: maybe(handleWireSchema) },
+  close: { input: z.tuple([z.string()]), output: noResult },
+  archive: { input: z.tuple([z.string()]), output: noResult },
+  restore: { input: z.tuple([z.string()]), output: maybe(handleWireSchema) },
+  fork: { input: z.tuple([forkSessionOptionsSchema]), output: handleWireSchema },
+  createChild: { input: z.tuple([createChildSessionOptionsSchema]), output: handleWireSchema },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/session/metadata.ts b/packages/klient/src/contract/session/metadata.ts
new file mode 100644
index 000000000..13eaabc02
--- /dev/null
+++ b/packages/klient/src/contract/session/metadata.ts
@@ -0,0 +1,76 @@
+/**
+ * `sessionMetadata` — typed session metadata. Mirrors
+ * `agent-core-v2/session/sessionMetadata/sessionMetadata.ts`. The `ready`
+ * promise property is excluded (not a wire method).
+ */
+
+import { z } from 'zod';
+
+import { noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const agentMetaSchema = z.object({
+  homedir: z.string().optional(),
+  type: z.enum(['main', 'sub', 'independent']).optional(),
+  parentAgentId: z.union([z.string(), z.null()]).optional(),
+  forkedFrom: z.string().optional(),
+  labels: z.record(z.string(), z.string()).optional(),
+  swarmItem: z.string().optional(),
+});
+
+export const sessionMetaSchema = z.object({
+  id: z.string(),
+  version: z.number().optional(),
+  title: z.string().optional(),
+  isCustomTitle: z.boolean().optional(),
+  lastPrompt: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  archived: z.boolean(),
+  cwd: z.string().optional(),
+  forkedFrom: z.string().optional(),
+  agents: z.record(z.string(), agentMetaSchema).optional(),
+  custom: z.record(z.string(), z.unknown()).optional(),
+});
+
+/** `Partial<Omit<SessionMeta, 'id' | 'createdAt'>>` — every key optional. */
+export const sessionMetaPatchSchema = z.object({
+  version: z.number().optional(),
+  title: z.string().optional(),
+  isCustomTitle: z.boolean().optional(),
+  lastPrompt: z.string().optional(),
+  updatedAt: z.number().optional(),
+  archived: z.boolean().optional(),
+  cwd: z.string().optional(),
+  forkedFrom: z.string().optional(),
+  agents: z.record(z.string(), agentMetaSchema).optional(),
+  custom: z.record(z.string(), z.unknown()).optional(),
+});
+
+/** `keyof SessionMeta` — keep in sync with `sessionMetaSchema`. */
+export const sessionMetaKeySchema = z.enum([
+  'id',
+  'version',
+  'title',
+  'isCustomTitle',
+  'lastPrompt',
+  'createdAt',
+  'updatedAt',
+  'archived',
+  'cwd',
+  'forkedFrom',
+  'agents',
+  'custom',
+]);
+
+export const sessionMetadataChangedEventSchema = z.object({
+  changed: z.array(sessionMetaKeySchema),
+});
+
+export const sessionMetadataContract = {
+  read: { input: z.tuple([]), output: sessionMetaSchema },
+  update: { input: z.tuple([sessionMetaPatchSchema]), output: noResult },
+  setTitle: { input: z.tuple([z.string()]), output: noResult },
+  setArchived: { input: z.tuple([z.boolean()]), output: noResult },
+  registerAgent: { input: z.tuple([z.string(), agentMetaSchema]), output: noResult },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/session/question.ts b/packages/klient/src/contract/session/question.ts
new file mode 100644
index 000000000..470bcc669
--- /dev/null
+++ b/packages/klient/src/contract/session/question.ts
@@ -0,0 +1,56 @@
+/**
+ * `sessionQuestionService` — ask-user request broker. Mirrors
+ * `agent-core-v2/session/question/question.ts` (the in-process camelCase
+ * representation; the snake_case protocol shape is adapted at the edge).
+ */
+
+import { z } from 'zod';
+
+import { noResult } from '../helpers.js';
+import type { ServiceContract } from '../types.js';
+
+export const questionOptionSchema = z.object({
+  label: z.string(),
+  description: z.string().optional(),
+});
+
+export const questionItemSchema = z.object({
+  question: z.string(),
+  header: z.string().optional(),
+  body: z.string().optional(),
+  options: z.array(questionOptionSchema),
+  multiSelect: z.boolean().optional(),
+  otherLabel: z.string().optional(),
+  otherDescription: z.string().optional(),
+});
+
+/** `QuestionAnswers = Record<string, string | true>`. */
+export const questionAnswersSchema = z.record(
+  z.string(),
+  z.union([z.string(), z.literal(true)]),
+);
+
+export const questionResponseSchema = z.object({
+  answers: questionAnswersSchema,
+  method: z.enum(['enter', 'space', 'number_key']).optional(),
+});
+
+/** `QuestionResult = null | QuestionAnswers | QuestionResponse`. */
+export const questionResultSchema = z.union([
+  z.null(),
+  questionAnswersSchema,
+  questionResponseSchema,
+]);
+
+export const questionRequestSchema = z.object({
+  id: z.string().optional(),
+  turnId: z.number().optional(),
+  toolCallId: z.string().optional(),
+  questions: z.array(questionItemSchema),
+});
+
+export const sessionQuestionContract = {
+  listPending: { input: z.tuple([]), output: z.array(questionRequestSchema) },
+  answer: { input: z.tuple([z.string(), questionResultSchema]), output: noResult },
+  dismiss: { input: z.tuple([z.string()]), output: noResult },
+} satisfies ServiceContract;
diff --git a/packages/klient/src/contract/types.ts b/packages/klient/src/contract/types.ts
new file mode 100644
index 000000000..707a227fe
--- /dev/null
+++ b/packages/klient/src/contract/types.ts
@@ -0,0 +1,46 @@
+/**
+ * Contract vocabulary. A procedure mirrors one engine service method: `input`
+ * is a zod tuple over its positional arguments, `output` the zod schema of its
+ * resolved result. The facade reshapes positional args into single-object
+ * params; the wire keeps the engine's original argument order so contracts
+ * stay mechanical to write and audit.
+ */
+
+import type { z } from 'zod';
+
+export interface ProcedureContract {
+  /** Tuple schema over the engine method's positional args. */
+  readonly input: z.ZodType;
+  /** Schema of the method's resolved return value as it appears on the wire. */
+  readonly output: z.ZodType;
+}
+
+/** method name → procedure */
+export type ServiceContract = Readonly<Record<string, ProcedureContract>>;
+
+/** service wire name (decorator id string) → its methods */
+export type KlientContract = Readonly<Record<string, ServiceContract>>;
+
+/**
+ * Where a klient-level event reads from:
+ * - `bus` — filter the process-wide `IEventService` stream by `type`
+ *   (payload unwrapped from `{ type, payload }`).
+ * - `stream` — a named scope stream (`events`, `interactions`,
+ *   `interactions:resolved`); with `type` set, only flat `{ type, ...fields }`
+ *   events of that type are forwarded, whole.
+ * - `emitter` — subscribe one service's `onDid*` property.
+ */
+export type EventRegistration =
+  | { readonly kind: 'bus'; readonly type: string; readonly schema: z.ZodType }
+  | {
+      readonly kind: 'stream';
+      readonly name: string;
+      readonly type?: string;
+      readonly schema: z.ZodType;
+    }
+  | {
+      readonly kind: 'emitter';
+      readonly service: string;
+      readonly event: string;
+      readonly schema: z.ZodType;
+    };
diff --git a/packages/klient/src/core/channel.ts b/packages/klient/src/core/channel.ts
new file mode 100644
index 000000000..f24678cff
--- /dev/null
+++ b/packages/klient/src/core/channel.ts
@@ -0,0 +1,50 @@
+/**
+ * Transport SPI — the single abstraction every klient transport implements.
+ *
+ * A `KlientChannel` carries service calls and event subscriptions for one
+ * scope triple. The facade above it never knows which transport is underneath
+ * (http, ipc, or in-memory); transports never know which facade method
+ * triggered a frame. `ScopeRef` already carries session/agent coordinates so
+ * future session/agent facades plug in without changing this interface.
+ */
+
+export interface IDisposable {
+  dispose(): void;
+}
+
+/** Scope coordinates of a call/subscription. Empty object = core (app) scope. */
+export interface ScopeRef {
+  readonly sessionId?: string;
+  readonly agentId?: string;
+}
+
+/**
+ * Where an event subscription reads from:
+ * - `stream` — a scope's named event stream, mirroring kap-server's WS
+ *   `eventMap`: core `events` (the global `IEventService` bus), session
+ *   `interactions` / `interactions:resolved`, agent `events` (the per-agent
+ *   `IEventBus`). The scope coordinates disambiguate which scope's stream.
+ * - `emitter` — one service's `onDid*` `Event<T>` property, addressed by the
+ *   service's wire name and the property name (e.g. `onDidChangeModels`).
+ */
+export type EventSourceRef =
+  | { readonly kind: 'stream'; readonly name: string }
+  | { readonly kind: 'emitter'; readonly service: string; readonly event: string };
+
+export interface KlientChannel {
+  /** Invoke `service.method(...args)` in the given scope; resolves with the raw wire result. */
+  call(scope: ScopeRef, service: string, method: string, args: unknown[]): Promise<unknown>;
+  /**
+   * Subscribe to an event source; `handler` receives raw wire payloads.
+   * `onError` reports asynchronous subscription failures (bad source, dropped
+   * remote subscription) — synchronous validation may also throw.
+   */
+  listen(
+    scope: ScopeRef,
+    source: EventSourceRef,
+    handler: (data: unknown) => void,
+    onError?: (error: Error) => void,
+  ): IDisposable;
+  /** Tear the transport down (sockets, lazy bridges). Rejects in-flight calls. */
+  close(): Promise<void>;
+}
diff --git a/packages/klient/src/errors.ts b/packages/klient/src/core/errors.ts
similarity index 81%
rename from packages/klient/src/errors.ts
rename to packages/klient/src/core/errors.ts
index b655802de..bb46bd1fa 100644
--- a/packages/klient/src/errors.ts
+++ b/packages/klient/src/core/errors.ts
@@ -1,5 +1,5 @@
 /**
- * Client-side RPC error surfaced when the `/api/v2` envelope carries a non-zero
+ * Client-side RPC error surfaced when the wire envelope carries a non-zero
  * `code`. Mirrors the server envelope (`{ code, msg, data, request_id }`) — the
  * numeric `code` is the stable branch key across the wire, not `instanceof`.
  */
diff --git a/packages/klient/src/core/events/hub.ts b/packages/klient/src/core/events/hub.ts
new file mode 100644
index 000000000..cb14b4dcd
--- /dev/null
+++ b/packages/klient/src/core/events/hub.ts
@@ -0,0 +1,227 @@
+/**
+ * The event hub — klient-level event forwarding. It exposes typed, namespaced
+ * events and hides the engine's `onDid*`/`onWill*` surface: each public event
+ * name resolves to one registration (a global-bus type filter, a scope
+ * stream, or a service emitter). Underlying channel subscriptions are shared
+ * per source and ref-counted by listener count. Payloads are validated
+ * against the event schema before delivery; bad payloads are dropped and
+ * reported through `onError`, never thrown.
+ *
+ * One hub serves one scope: the global klient hub binds `{}`, session/agent
+ * handles bind their scope coordinates, so `stream` sources resolve to the
+ * right scope's event stream on every transport.
+ */
+
+import type { IDisposable, KlientChannel, ScopeRef } from '../channel.js';
+import type { EventRegistration } from '#/contract/types';
+import type { KlientEventPayloads } from '#/contract/global/events';
+import { parseEvent } from '../validation.js';
+
+export interface KlientEvents<TPayloadMap extends object = KlientEventPayloads> {
+  on<E extends keyof TPayloadMap & string>(
+    event: E,
+    listener: (payload: TPayloadMap[E]) => void,
+  ): IDisposable;
+  /** Validation failures and listener exceptions surface here. */
+  onError(listener: (error: Error) => void): IDisposable;
+}
+
+type AnyListener = (payload: never) => void;
+
+interface SharedSub {
+  readonly reg: EventRegistration;
+  disposable: IDisposable;
+  refs: number;
+}
+
+/** Stable identity of a registration's underlying channel subscription. */
+function keyOf(reg: EventRegistration): string {
+  switch (reg.kind) {
+    case 'bus':
+      return 'bus';
+    case 'stream':
+      return `stream:${reg.name}`;
+    case 'emitter':
+      return `emitter:${reg.service}:${reg.event}`;
+  }
+}
+
+function rawTypeOf(raw: unknown): string | undefined {
+  if (typeof raw !== 'object' || raw === null) return undefined;
+  const type = (raw as { type?: unknown }).type;
+  return typeof type === 'string' ? type : undefined;
+}
+
+export class EventHub<TPayloadMap extends object = KlientEventPayloads>
+  implements KlientEvents<TPayloadMap>
+{
+  private readonly listeners = new Map<string, Set<AnyListener>>();
+  private readonly subs = new Map<string, SharedSub>();
+  private readonly errorListeners = new Set<(error: Error) => void>();
+  private closed = false;
+
+  constructor(
+    private readonly channel: KlientChannel,
+    private readonly validate: boolean,
+    private readonly scope: ScopeRef,
+    private readonly registrations: Record<string, EventRegistration>,
+  ) {}
+
+  on<E extends keyof TPayloadMap & string>(
+    event: E,
+    listener: (payload: TPayloadMap[E]) => void,
+  ): IDisposable {
+    if (this.closed) throw new Error('event hub is closed');
+    if (this.registrations[event] === undefined) {
+      throw new Error(`unknown event: ${event}`);
+    }
+    let set = this.listeners.get(event);
+    if (set === undefined) {
+      set = new Set();
+      this.listeners.set(event, set);
+    }
+    const entry = listener as AnyListener;
+    set.add(entry);
+    this.acquire(event);
+
+    let disposed = false;
+    return {
+      dispose: () => {
+        if (disposed) return;
+        disposed = true;
+        set.delete(entry);
+        if (set.size === 0) {
+          this.listeners.delete(event);
+        }
+        this.release(event);
+      },
+    };
+  }
+
+  onError(listener: (error: Error) => void): IDisposable {
+    this.errorListeners.add(listener);
+    return {
+      dispose: () => {
+        this.errorListeners.delete(listener);
+      },
+    };
+  }
+
+  /** Detach every subscription; the hub may not be reused after. */
+  close(): void {
+    this.closed = true;
+    for (const sub of this.subs.values()) {
+      sub.disposable.dispose();
+    }
+    this.subs.clear();
+    this.listeners.clear();
+  }
+
+  private acquire(event: string): void {
+    const reg = this.registrations[event];
+    if (reg === undefined) return;
+    const key = keyOf(reg);
+    let sub = this.subs.get(key);
+    if (sub === undefined) {
+      sub = {
+        reg,
+        disposable: this.subscribe(key, reg),
+        refs: 0,
+      };
+      this.subs.set(key, sub);
+    }
+    sub.refs += 1;
+  }
+
+  private release(event: string): void {
+    const reg = this.registrations[event];
+    if (reg === undefined) return;
+    const key = keyOf(reg);
+    const sub = this.subs.get(key);
+    if (sub === undefined) return;
+    sub.refs -= 1;
+    if (sub.refs <= 0) {
+      sub.disposable.dispose();
+      this.subs.delete(key);
+    }
+  }
+
+  private subscribe(key: string, reg: EventRegistration): IDisposable {
+    if (reg.kind === 'emitter') {
+      return this.channel.listen(
+        this.scope,
+        { kind: 'emitter', service: reg.service, event: reg.event },
+        (data) => {
+          this.deliver(key, data);
+        },
+        (error) => {
+          this.reportError(error);
+        },
+      );
+    }
+    const name = reg.kind === 'bus' ? 'events' : reg.name;
+    return this.channel.listen(
+      this.scope,
+      { kind: 'stream', name },
+      (data) => {
+        this.deliver(key, data);
+      },
+      (error) => {
+        this.reportError(error);
+      },
+    );
+  }
+
+  /** Fan one raw payload out to the registrations attached to this source. */
+  private deliver(key: string, raw: unknown): void {
+    for (const [event, reg] of Object.entries(this.registrations)) {
+      if (keyOf(reg) !== key || !this.listeners.has(event)) continue;
+      if (reg.kind === 'bus') {
+        // Global bus events are `{ type, payload }` facts; only registered
+        // types are forwarded, with the payload unwrapped.
+        if (rawTypeOf(raw) !== reg.type) continue;
+        this.deliverValidated(event, reg, (raw as { payload?: unknown }).payload);
+        continue;
+      }
+      if (reg.kind === 'stream' && reg.type !== undefined) {
+        // Scoped streams (e.g. the agent `events` bus) carry flat
+        // `{ type, ...fields }` events; forward the whole event.
+        if (rawTypeOf(raw) !== reg.type) continue;
+        this.deliverValidated(event, reg, raw);
+        continue;
+      }
+      this.deliverValidated(event, reg, raw);
+    }
+  }
+
+  private deliverValidated(event: string, reg: EventRegistration, data: unknown): void {
+    let payload: unknown = data;
+    if (this.validate) {
+      const parsed = parseEvent(event, reg.schema, data);
+      if (!parsed.ok) {
+        this.reportError(parsed.error);
+        return;
+      }
+      payload = parsed.data;
+    }
+    const set = this.listeners.get(event);
+    if (set === undefined) return;
+    for (const listener of set) {
+      try {
+        (listener as (payload: unknown) => void)(payload);
+      } catch (error) {
+        this.reportError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+
+  private reportError(error: Error): void {
+    for (const listener of this.errorListeners) {
+      try {
+        listener(error);
+      } catch {
+        // error listeners must not take the hub down
+      }
+    }
+  }
+}
diff --git a/packages/klient/src/core/facade/agent.ts b/packages/klient/src/core/facade/agent.ts
new file mode 100644
index 000000000..f3537561b
--- /dev/null
+++ b/packages/klient/src/core/facade/agent.ts
@@ -0,0 +1,68 @@
+/**
+ * The agent facade — one `session.agent(id)` handle over the `agentRPCService`
+ * channel (the single agent-scope facade service the wire exposes). Prompt
+ * streaming is NOT on this interface: it flows through the agent's `events`
+ * hub (`turn.*`, `assistant.delta`, `tool.call.*`, `prompt.completed`, …).
+ */
+
+import type { IAgentRPCService } from '@moonshot-ai/agent-core-v2/agent/rpc/rpc';
+import type { ContentPart } from '@moonshot-ai/agent-core-v2/app/llmProtocol/message';
+import type { PermissionMode } from '@moonshot-ai/agent-core-v2/agent/permissionPolicy/types';
+
+import type { ScopeRef } from '../channel.js';
+import type { ScopedCaller } from './session.js';
+
+// Wire-type aliases derived through the RPC interface (keeps klient free of
+// protocol-package imports).
+export type PromptLaunchResult = Awaited<ReturnType<IAgentRPCService['prompt']>>;
+export type ShellCommandResult = Awaited<ReturnType<IAgentRPCService['runShellCommand']>>;
+export type SetModelResult = Awaited<ReturnType<IAgentRPCService['setModel']>>;
+export type UsageStatus = Awaited<ReturnType<IAgentRPCService['getUsage']>>;
+export type AgentContextData = Awaited<ReturnType<IAgentRPCService['getContext']>>;
+export type PlanData = Awaited<ReturnType<IAgentRPCService['getPlan']>>;
+export type AgentTaskInfo = Awaited<ReturnType<IAgentRPCService['getTasks']>>[number];
+
+export interface AgentFacade {
+  prompt(input: { input: readonly ContentPart[] }): Promise<PromptLaunchResult>;
+  steer(input: { input: readonly ContentPart[] }): Promise<PromptLaunchResult>;
+  cancel(input?: { turnId?: number }): Promise<void>;
+  runShellCommand(input: { command: string; commandId?: string }): Promise<ShellCommandResult>;
+  cancelShellCommand(input: { commandId: string }): Promise<void>;
+  getModel(): Promise<string>;
+  setModel(model: string): Promise<SetModelResult>;
+  setPermission(mode: PermissionMode): Promise<void>;
+  getUsage(): Promise<UsageStatus>;
+  getContext(): Promise<AgentContextData>;
+  getPlan(): Promise<PlanData>;
+  enterPlan(): Promise<void>;
+  clearPlan(): Promise<void>;
+  cancelPlan(input?: { id?: string }): Promise<void>;
+  getTasks(input?: { activeOnly?: boolean; limit?: number }): Promise<readonly AgentTaskInfo[]>;
+  stopTask(input: { taskId: string; reason?: string }): Promise<void>;
+  getTaskOutput(input: { taskId: string; tail?: number }): Promise<string>;
+}
+
+export function createAgentFacade(call: ScopedCaller, scope: ScopeRef): AgentFacade {
+  const rpc = (method: string, payload: unknown): Promise<unknown> =>
+    call(scope, 'agentRPCService', method, [payload]);
+
+  return {
+    prompt: (input) => rpc('prompt', input) as Promise<PromptLaunchResult>,
+    steer: (input) => rpc('steer', input) as Promise<PromptLaunchResult>,
+    cancel: (input) => rpc('cancel', input ?? {}) as Promise<void>,
+    runShellCommand: (input) => rpc('runShellCommand', input) as Promise<ShellCommandResult>,
+    cancelShellCommand: (input) => rpc('cancelShellCommand', input) as Promise<void>,
+    getModel: () => rpc('getModel', {}) as Promise<string>,
+    setModel: (model) => rpc('setModel', { model }) as Promise<SetModelResult>,
+    setPermission: (mode) => rpc('setPermission', { mode }) as Promise<void>,
+    getUsage: () => rpc('getUsage', {}) as Promise<UsageStatus>,
+    getContext: () => rpc('getContext', {}) as Promise<AgentContextData>,
+    getPlan: () => rpc('getPlan', {}) as Promise<PlanData>,
+    enterPlan: () => rpc('enterPlan', {}) as Promise<void>,
+    clearPlan: () => rpc('clearPlan', {}) as Promise<void>,
+    cancelPlan: (input) => rpc('cancelPlan', input ?? {}) as Promise<void>,
+    getTasks: (input) => rpc('getTasks', input ?? {}) as Promise<readonly AgentTaskInfo[]>,
+    stopTask: (input) => rpc('stopTask', input) as Promise<void>,
+    getTaskOutput: (input) => rpc('getTaskOutput', input) as Promise<string>,
+  };
+}
diff --git a/packages/klient/src/core/facade/global.ts b/packages/klient/src/core/facade/global.ts
new file mode 100644
index 000000000..6c29bb0f8
--- /dev/null
+++ b/packages/klient/src/core/facade/global.ts
@@ -0,0 +1,380 @@
+/**
+ * The `global` facade — aggregated, single-object-param methods over the
+ * engine's app-scope services. Each method maps to one underlying service
+ * call (except `env()`, which fans out and merges); the `Caller` underneath
+ * applies contract validation and hands the call to the transport. Facade
+ * code never sees service tokens, scope routing, or transport details.
+ */
+
+import type {
+  SessionListQuery,
+  SessionSummary,
+} from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
+import type { SessionMeta } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
+import type { Page } from '@moonshot-ai/agent-core-v2/persistence/interface/queryStore';
+import type {
+  Workspace,
+  WorkspaceUpdate,
+} from '@moonshot-ai/agent-core-v2/app/workspaceRegistry/workspaceRegistry';
+import type {
+  ConfigDiagnostic,
+  ConfigInspectValue,
+  ConfigTarget,
+} from '@moonshot-ai/agent-core-v2/app/config/config';
+import type { ProviderConfig } from '@moonshot-ai/agent-core-v2/app/provider/provider';
+import type {
+  AuthStatus,
+  IOAuthService,
+} from '@moonshot-ai/agent-core-v2/app/auth/auth';
+import type { ExperimentalFeatureState } from '@moonshot-ai/agent-core-v2/app/flag/flag';
+import type {
+  FsBrowseResponse,
+  FsHomeResponse,
+} from '@moonshot-ai/agent-core-v2/app/hostFolderBrowser/hostFolderBrowser';
+import type { ModelConfig } from '@moonshot-ai/agent-core-v2/app/model/model';
+import type {
+  IModelCatalogService,
+} from '@moonshot-ai/agent-core-v2/app/modelCatalog/modelCatalog';
+import type {
+  PluginCommandDef,
+  PluginInfo,
+  PluginSummary,
+  PluginUpdateStatus,
+  ReloadSummary,
+} from '@moonshot-ai/agent-core-v2/app/plugin/types';
+
+/** Low-level caller the klient factory builds: routes + validates one service call. */
+export type Caller = (service: string, method: string, args: unknown[]) => Promise<unknown>;
+
+/** Scoped variant — the factory's real signature; global methods bind the core scope. */
+export type ScopedCaller = (
+  scope: { readonly sessionId?: string; readonly agentId?: string },
+  service: string,
+  method: string,
+  args: unknown[],
+) => Promise<unknown>;
+
+// ---------------------------------------------------------------------------
+// Wire-type aliases for shapes the engine sources from `@moonshot-ai/protocol`
+// (not a direct klient dependency) — derived through the service interfaces.
+// ---------------------------------------------------------------------------
+
+export type RefreshProviderModelsResponse = Awaited<
+  ReturnType<IOAuthService['refreshOAuthProviderModels']>
+>;
+export type OAuthFlowStart = Awaited<ReturnType<IOAuthService['startLogin']>>;
+export type OAuthFlowSnapshot = NonNullable<Awaited<ReturnType<IOAuthService['getFlow']>>>;
+export type OAuthLoginCancelResponse = Awaited<ReturnType<IOAuthService['cancelLogin']>>;
+export type OAuthLogoutResponse = Awaited<ReturnType<IOAuthService['logout']>>;
+
+export type ModelCatalogItem = Awaited<ReturnType<IModelCatalogService['listModels']>>[number];
+export type ProviderCatalogItem = Awaited<
+  ReturnType<IModelCatalogService['listProviders']>
+>[number];
+export type SetDefaultModelResponse = Awaited<
+  ReturnType<IModelCatalogService['setDefaultModel']>
+>;
+export type RefreshProviderModelsOptions = NonNullable<
+  Parameters<IModelCatalogService['refreshProviderModels']>[0]
+>;
+
+/** String-literal form of the engine's `ConfigTarget` enum, so consumers never import the enum value. */
+export type ConfigTargetLiteral = `${ConfigTarget}`;
+
+// ---------------------------------------------------------------------------
+// Facade interfaces
+// ---------------------------------------------------------------------------
+
+export interface GlobalSessionsFacade {
+  list(query: SessionListQuery): Promise<Page<SessionSummary>>;
+  get(id: string): Promise<SessionSummary | undefined>;
+  countActive(workspaceId: string): Promise<number>;
+  /**
+   * Create a session rooted at `workDir` (the workspace is registered
+   * implicitly), optionally titled. Returns the persisted metadata. No agent
+   * is created — `session(id).agent('main')` materializes it on first use.
+   */
+  create(input: {
+    workDir: string;
+    additionalDirs?: readonly string[];
+    title?: string;
+  }): Promise<SessionMeta>;
+}
+
+export interface GlobalWorkspacesFacade {
+  list(): Promise<readonly Workspace[]>;
+  get(id: string): Promise<Workspace | undefined>;
+  createOrTouch(input: { root: string; name?: string }): Promise<Workspace>;
+  update(input: { id: string; patch: WorkspaceUpdate }): Promise<Workspace | undefined>;
+  delete(id: string): Promise<void>;
+}
+
+export interface GlobalConfigFacade {
+  get<T = unknown>(domain: string): Promise<T>;
+  getAll(): Promise<Record<string, unknown>>;
+  inspect<T = unknown>(domain: string): Promise<ConfigInspectValue<T>>;
+  set(input: { domain: string; patch: unknown; target?: ConfigTargetLiteral }): Promise<void>;
+  replace(input: {
+    domain: string;
+    value: unknown;
+    target?: ConfigTargetLiteral;
+  }): Promise<void>;
+  reload(): Promise<void>;
+  diagnostics(): Promise<readonly ConfigDiagnostic[]>;
+}
+
+export interface GlobalProvidersFacade {
+  list(): Promise<Readonly<Record<string, ProviderConfig>>>;
+  get(name: string): Promise<ProviderConfig | undefined>;
+  set(input: { name: string; config: ProviderConfig }): Promise<void>;
+  delete(name: string): Promise<void>;
+}
+
+export interface GlobalModelsFacade {
+  list(): Promise<Readonly<Record<string, ModelConfig>>>;
+  get(id: string): Promise<ModelConfig | undefined>;
+  set(input: { id: string; config: ModelConfig }): Promise<void>;
+  delete(id: string): Promise<void>;
+}
+
+export interface GlobalCatalogFacade {
+  listModels(): Promise<readonly ModelCatalogItem[]>;
+  listProviders(): Promise<readonly ProviderCatalogItem[]>;
+  getProvider(providerId: string): Promise<ProviderCatalogItem>;
+  setDefaultModel(modelId: string): Promise<SetDefaultModelResponse>;
+  refresh(input?: RefreshProviderModelsOptions): Promise<RefreshProviderModelsResponse>;
+}
+
+export interface GlobalAuthFacade {
+  status(provider?: string): Promise<AuthStatus>;
+  summarize(): Promise<readonly AuthStatus[]>;
+  startLogin(provider?: string): Promise<OAuthFlowStart>;
+  flow(provider?: string): Promise<OAuthFlowSnapshot | undefined>;
+  cancelLogin(provider?: string): Promise<OAuthLoginCancelResponse>;
+  logout(provider?: string): Promise<OAuthLogoutResponse>;
+  /**
+   * @deprecated Use `catalog.refresh({ scope: 'oauth' })` — the model catalog
+   * owns provider-model refresh; this alias remains for one release cycle.
+   */
+  refreshProviderModels(): Promise<RefreshProviderModelsResponse>;
+}
+
+export interface GlobalFlagsFacade {
+  list(): Promise<readonly ExperimentalFeatureState[]>;
+  enabled(id: string): Promise<boolean>;
+  enabledIds(): Promise<readonly string[]>;
+  explain(id: string): Promise<ExperimentalFeatureState | undefined>;
+  snapshot(): Promise<Record<string, boolean>>;
+}
+
+export interface GlobalPluginsFacade {
+  list(): Promise<readonly PluginSummary[]>;
+  info(id: string): Promise<PluginInfo>;
+  install(source: string): Promise<PluginSummary>;
+  setEnabled(input: { id: string; enabled: boolean }): Promise<void>;
+  setMcpServerEnabled(input: { id: string; server: string; enabled: boolean }): Promise<void>;
+  remove(id: string): Promise<void>;
+  reload(): Promise<ReloadSummary>;
+  checkUpdates(): Promise<readonly PluginUpdateStatus[]>;
+  listCommands(): Promise<readonly PluginCommandDef[]>;
+}
+
+export interface GlobalHostFsFacade {
+  browse(absPath?: string): Promise<FsBrowseResponse>;
+  home(): Promise<FsHomeResponse>;
+}
+
+/** Aggregated host/environment snapshot (`bootstrapService` properties). */
+export interface KlientEnvInfo {
+  readonly platform: string;
+  readonly arch: string;
+  readonly cwd: string;
+  readonly osHomeDir: string;
+  readonly homeDir: string;
+  readonly configPath: string;
+  readonly clientVersion: string;
+  readonly sessionsDir: string;
+  readonly blobsDir: string;
+  readonly storeDir: string;
+  readonly cacheDir: string;
+  readonly logsDir: string;
+}
+
+export interface GlobalFacade {
+  readonly sessions: GlobalSessionsFacade;
+  readonly workspaces: GlobalWorkspacesFacade;
+  readonly config: GlobalConfigFacade;
+  readonly providers: GlobalProvidersFacade;
+  readonly models: GlobalModelsFacade;
+  readonly catalog: GlobalCatalogFacade;
+  readonly auth: GlobalAuthFacade;
+  readonly flags: GlobalFlagsFacade;
+  readonly plugins: GlobalPluginsFacade;
+  readonly hostFs: GlobalHostFsFacade;
+  env(): Promise<KlientEnvInfo>;
+}
+
+// ---------------------------------------------------------------------------
+// Implementation — thin reshaping over `Caller`. Casts are safe by
+// construction: the contract validates outputs, and type-parity assertions
+// tie every contract schema to its engine type.
+// ---------------------------------------------------------------------------
+
+const ENV_PROPERTIES = [
+  'platform',
+  'arch',
+  'cwd',
+  'osHomeDir',
+  'homeDir',
+  'configPath',
+  'clientVersion',
+  'sessionsDir',
+  'blobsDir',
+  'storeDir',
+  'cacheDir',
+  'logsDir',
+] as const;
+
+export function createGlobalFacade(scoped: ScopedCaller): GlobalFacade {
+  const call: Caller = (service, method, args) => scoped({}, service, method, args);
+  // The bootstrap snapshot is frozen at process start, so the aggregated
+  // env() result can never change — resolve it once and reuse the promise.
+  let envPromise: Promise<KlientEnvInfo> | undefined;
+  const env = (): Promise<KlientEnvInfo> => {
+    envPromise ??= Promise.all(
+      ENV_PROPERTIES.map((prop) => call('bootstrapService', prop, []) as Promise<string>),
+    ).then(
+      (values) =>
+        Object.fromEntries(
+          ENV_PROPERTIES.map((prop, index) => [prop, values[index]]),
+        ) as unknown as KlientEnvInfo,
+    );
+    return envPromise;
+  };
+
+  return {
+    sessions: {
+      list: (query) => call('sessionIndex', 'list', [query]) as Promise<Page<SessionSummary>>,
+      get: (id) => call('sessionIndex', 'get', [id]) as Promise<SessionSummary | undefined>,
+      countActive: (workspaceId) =>
+        call('sessionIndex', 'countActive', [workspaceId]) as Promise<number>,
+      create: async ({ workDir, additionalDirs, title }) => {
+        const handle = (await scoped({}, 'sessionLifecycleService', 'create', [
+          { workDir, additionalDirs },
+        ])) as { id: string };
+        const scope = { sessionId: handle.id };
+        if (title !== undefined) {
+          await scoped(scope, 'sessionMetadata', 'setTitle', [title]);
+        }
+        return scoped(scope, 'sessionMetadata', 'read', []) as Promise<SessionMeta>;
+      },
+    },
+
+    workspaces: {
+      list: () => call('workspaceRegistry', 'list', []) as Promise<readonly Workspace[]>,
+      get: (id) => call('workspaceRegistry', 'get', [id]) as Promise<Workspace | undefined>,
+      createOrTouch: ({ root, name }) =>
+        call('workspaceRegistry', 'createOrTouch', [root, name]) as Promise<Workspace>,
+      update: ({ id, patch }) =>
+        call('workspaceRegistry', 'update', [id, patch]) as Promise<Workspace | undefined>,
+      delete: (id) => call('workspaceRegistry', 'delete', [id]) as Promise<void>,
+    },
+
+    config: {
+      get: <T>(domain: string) => call('configService', 'get', [domain]) as Promise<T>,
+      getAll: () => call('configService', 'getAll', []) as Promise<Record<string, unknown>>,
+      inspect: <T>(domain: string) =>
+        call('configService', 'inspect', [domain]) as Promise<ConfigInspectValue<T>>,
+      set: ({ domain, patch, target }) =>
+        call('configService', 'set', [domain, patch, target]) as Promise<void>,
+      replace: ({ domain, value, target }) =>
+        call('configService', 'replace', [domain, value, target]) as Promise<void>,
+      reload: () => call('configService', 'reload', []) as Promise<void>,
+      diagnostics: () =>
+        call('configService', 'diagnostics', []) as Promise<readonly ConfigDiagnostic[]>,
+    },
+
+    providers: {
+      list: () =>
+        call('providerService', 'list', []) as Promise<Readonly<Record<string, ProviderConfig>>>,
+      get: (name) => call('providerService', 'get', [name]) as Promise<ProviderConfig | undefined>,
+      set: ({ name, config }) => call('providerService', 'set', [name, config]) as Promise<void>,
+      delete: (name) => call('providerService', 'delete', [name]) as Promise<void>,
+    },
+
+    models: {
+      list: () =>
+        call('modelService', 'list', []) as Promise<Readonly<Record<string, ModelConfig>>>,
+      get: (id) => call('modelService', 'get', [id]) as Promise<ModelConfig | undefined>,
+      set: ({ id, config }) => call('modelService', 'set', [id, config]) as Promise<void>,
+      delete: (id) => call('modelService', 'delete', [id]) as Promise<void>,
+    },
+
+    catalog: {
+      listModels: () =>
+        call('modelCatalogService', 'listModels', []) as Promise<readonly ModelCatalogItem[]>,
+      listProviders: () =>
+        call('modelCatalogService', 'listProviders', []) as Promise<
+          readonly ProviderCatalogItem[]
+        >,
+      getProvider: (providerId) =>
+        call('modelCatalogService', 'getProvider', [providerId]) as Promise<ProviderCatalogItem>,
+      setDefaultModel: (modelId) =>
+        call('modelCatalogService', 'setDefaultModel', [modelId]) as Promise<
+          SetDefaultModelResponse
+        >,
+      refresh: (input) =>
+        call('modelCatalogService', 'refreshProviderModels', [
+          input,
+        ]) as Promise<RefreshProviderModelsResponse>,
+    },
+
+    auth: {
+      status: (provider) => call('oauthService', 'status', [provider]) as Promise<AuthStatus>,
+      summarize: () => call('authSummaryService', 'summarize', []) as Promise<readonly AuthStatus[]>,
+      startLogin: (provider) =>
+        call('oauthService', 'startLogin', [provider]) as Promise<OAuthFlowStart>,
+      flow: (provider) =>
+        call('oauthService', 'getFlow', [provider]) as Promise<OAuthFlowSnapshot | undefined>,
+      cancelLogin: (provider) =>
+        call('oauthService', 'cancelLogin', [provider]) as Promise<OAuthLoginCancelResponse>,
+      logout: (provider) =>
+        call('oauthService', 'logout', [provider]) as Promise<OAuthLogoutResponse>,
+      refreshProviderModels: () =>
+        call('oauthService', 'refreshOAuthProviderModels', []) as Promise<RefreshProviderModelsResponse>,
+    },
+
+    flags: {
+      list: () => call('flagService', 'explainAll', []) as Promise<readonly ExperimentalFeatureState[]>,
+      enabled: (id) => call('flagService', 'enabled', [id]) as Promise<boolean>,
+      enabledIds: () => call('flagService', 'enabledIds', []) as Promise<readonly string[]>,
+      explain: (id) =>
+        call('flagService', 'explain', [id]) as Promise<ExperimentalFeatureState | undefined>,
+      snapshot: () => call('flagService', 'snapshot', []) as Promise<Record<string, boolean>>,
+    },
+
+    plugins: {
+      list: () => call('pluginService', 'listPlugins', []) as Promise<readonly PluginSummary[]>,
+      info: (id) => call('pluginService', 'getPluginInfo', [{ id }]) as Promise<PluginInfo>,
+      install: (source) =>
+        call('pluginService', 'installPlugin', [{ source }]) as Promise<PluginSummary>,
+      setEnabled: (input) => call('pluginService', 'setPluginEnabled', [input]) as Promise<void>,
+      setMcpServerEnabled: (input) =>
+        call('pluginService', 'setPluginMcpServerEnabled', [input]) as Promise<void>,
+      remove: (id) => call('pluginService', 'removePlugin', [{ id }]) as Promise<void>,
+      reload: () => call('pluginService', 'reloadPlugins', []) as Promise<ReloadSummary>,
+      checkUpdates: () =>
+        call('pluginService', 'checkUpdates', []) as Promise<readonly PluginUpdateStatus[]>,
+      listCommands: () =>
+        call('pluginService', 'listPluginCommands', []) as Promise<readonly PluginCommandDef[]>,
+    },
+
+    hostFs: {
+      browse: (absPath) =>
+        call('hostFolderBrowser', 'browse', [absPath]) as Promise<FsBrowseResponse>,
+      home: () => call('hostFolderBrowser', 'home', []) as Promise<FsHomeResponse>,
+    },
+
+    env,
+  };
+}
diff --git a/packages/klient/src/core/facade/session.ts b/packages/klient/src/core/facade/session.ts
new file mode 100644
index 000000000..cce957aa6
--- /dev/null
+++ b/packages/klient/src/core/facade/session.ts
@@ -0,0 +1,174 @@
+/**
+ * The session facade — one `klient.session(id)` handle aggregating the
+ * session-scope services (metadata, activity, approvals, questions,
+ * interactions) plus the app-scope lifecycle service for close/archive/
+ * restore/fork/createChild. `agents()` reads the metadata registry (agent
+ * handles are not serializable, so no agent-lifecycle channel exists on the
+ * wire).
+ */
+
+import type { AgentActivityState } from '@moonshot-ai/agent-core-v2/agent/activityView/activityView';
+import type {
+  AgentMeta,
+  SessionMeta,
+  SessionMetaPatch,
+} from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
+import type {
+  ApprovalRequest,
+  ApprovalResponse,
+} from '@moonshot-ai/agent-core-v2/session/approval/approval';
+import type {
+  QuestionRequest,
+  QuestionResult,
+} from '@moonshot-ai/agent-core-v2/session/question/question';
+import type {
+  Interaction,
+  InteractionKind,
+} from '@moonshot-ai/agent-core-v2/session/interaction/interaction';
+
+import type { ScopeRef } from '../channel.js';
+import type { ScopedCaller } from './global.js';
+
+export type { ScopedCaller } from './global.js';
+
+/** What `sessionLifecycleService.create/fork/createChild` leaves on the wire. */
+interface HandleWire {
+  readonly id: string;
+}
+
+export interface SessionApprovalsFacade {
+  list(): Promise<readonly ApprovalRequest[]>;
+  decide(id: string, response: ApprovalResponse): Promise<void>;
+}
+
+export interface SessionQuestionsFacade {
+  list(): Promise<readonly QuestionRequest[]>;
+  answer(id: string, result: QuestionResult): Promise<void>;
+  dismiss(id: string): Promise<void>;
+}
+
+export interface SessionInteractionsFacade {
+  list(kind?: InteractionKind): Promise<readonly Interaction[]>;
+  respond(id: string, response: unknown): Promise<void>;
+}
+
+/**
+ * Derived session lifecycle phase. The engine retired its `sessionActivity`
+ * service (#1751) — busy is now derived from agent activity views — so the
+ * facade composes the phase from the pending interaction lists and each
+ * agent's `agentActivityView`, keeping the retired service's precedence.
+ */
+export type SessionStatus = 'running' | 'idle' | 'awaiting_approval' | 'awaiting_question';
+
+export interface SessionFacade {
+  get(): Promise<SessionMeta>;
+  setTitle(title: string): Promise<void>;
+  update(patch: SessionMetaPatch): Promise<void>;
+  setArchived(archived: boolean): Promise<void>;
+  status(): Promise<SessionStatus>;
+  close(): Promise<void>;
+  archive(): Promise<void>;
+  /** Re-materialize a closed session; `false` when it no longer exists. */
+  restore(): Promise<boolean>;
+  fork(input?: { title?: string; metadata?: Record<string, unknown> }): Promise<SessionMeta>;
+  createChild(input?: {
+    title?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<SessionMeta>;
+  readonly approvals: SessionApprovalsFacade;
+  readonly questions: SessionQuestionsFacade;
+  readonly interactions: SessionInteractionsFacade;
+  /** Agent id → metadata for every agent registered in this session. */
+  agents(): Promise<Readonly<Record<string, AgentMeta>>>;
+}
+
+export function createSessionFacade(call: ScopedCaller, sessionId: string): SessionFacade {
+  const scope: ScopeRef = { sessionId };
+  const read = (): Promise<SessionMeta> =>
+    call(scope, 'sessionMetadata', 'read', []) as Promise<SessionMeta>;
+  const spawn = async (
+    method: 'fork' | 'createChild',
+    input: { title?: string; metadata?: Record<string, unknown> } = {},
+  ): Promise<SessionMeta> => {
+    const handle = (await call({}, 'sessionLifecycleService', method, [
+      { sourceSessionId: sessionId, title: input.title, metadata: input.metadata },
+    ])) as HandleWire;
+    return call({ sessionId: handle.id }, 'sessionMetadata', 'read', []) as Promise<SessionMeta>;
+  };
+
+  return {
+    get: read,
+    setTitle: (title) => call(scope, 'sessionMetadata', 'setTitle', [title]) as Promise<void>,
+    update: (patch) => call(scope, 'sessionMetadata', 'update', [patch]) as Promise<void>,
+    setArchived: (archived) =>
+      call(scope, 'sessionMetadata', 'setArchived', [archived]) as Promise<void>,
+    status: async () => {
+      const pending = (kind: 'approval' | 'question') =>
+        call(scope, 'sessionInteractionService', 'listPending', [kind]) as Promise<
+          readonly unknown[]
+        >;
+      if ((await pending('approval')).length > 0) return 'awaiting_approval';
+      if ((await pending('question')).length > 0) return 'awaiting_question';
+      const meta = await read();
+      for (const agentId of Object.keys(meta.agents ?? {})) {
+        try {
+          const state = (await call(
+            { sessionId, agentId },
+            'agentActivityView',
+            'state',
+            [],
+          )) as AgentActivityState;
+          if (state.turn !== undefined || state.background.length > 0) return 'running';
+        } catch {
+          // Agents stay registered after their live handle is gone; the scope
+          // probe fails for a dead agent, so treat it as not active — the same
+          // view the retired service had from iterating live handles only.
+        }
+      }
+      return 'idle';
+    },
+    close: () => call({}, 'sessionLifecycleService', 'close', [sessionId]) as Promise<void>,
+    archive: () => call({}, 'sessionLifecycleService', 'archive', [sessionId]) as Promise<void>,
+    restore: async () => {
+      const handle = (await call({}, 'sessionLifecycleService', 'restore', [
+        sessionId,
+      ])) as HandleWire | null;
+      return handle !== null;
+    },
+    fork: (input) => spawn('fork', input),
+    createChild: (input) => spawn('createChild', input),
+
+    approvals: {
+      list: () =>
+        call(scope, 'sessionApprovalService', 'listPending', []) as Promise<
+          readonly ApprovalRequest[]
+        >,
+      decide: (id, response) =>
+        call(scope, 'sessionApprovalService', 'decide', [id, response]) as Promise<void>,
+    },
+
+    questions: {
+      list: () =>
+        call(scope, 'sessionQuestionService', 'listPending', []) as Promise<
+          readonly QuestionRequest[]
+        >,
+      answer: (id, result) =>
+        call(scope, 'sessionQuestionService', 'answer', [id, result]) as Promise<void>,
+      dismiss: (id) => call(scope, 'sessionQuestionService', 'dismiss', [id]) as Promise<void>,
+    },
+
+    interactions: {
+      list: (kind) =>
+        call(scope, 'sessionInteractionService', 'listPending', [kind]) as Promise<
+          readonly Interaction[]
+        >,
+      respond: (id, response) =>
+        call(scope, 'sessionInteractionService', 'respond', [id, response]) as Promise<void>,
+    },
+
+    agents: async () => {
+      const meta = await read();
+      return meta.agents ?? {};
+    },
+  };
+}
diff --git a/packages/klient/src/core/klient.ts b/packages/klient/src/core/klient.ts
new file mode 100644
index 000000000..621c6855a
--- /dev/null
+++ b/packages/klient/src/core/klient.ts
@@ -0,0 +1,98 @@
+/**
+ * The transport-agnostic klient factory. Every transport entry point
+ * (`@moonshot-ai/klient/http|ipc|memory`) builds a `KlientChannel` and hands
+ * it here; the returned `Klient` is identical in shape and behavior no matter
+ * which transport carried the bytes.
+ */
+
+import type { KlientChannel, ScopeRef } from './channel.js';
+import { globalContract } from '#/contract/index';
+import { globalEvents, type KlientEventPayloads } from '#/contract/global/events';
+import { sessionEvents, type SessionEventPayloads } from '#/contract/session/events';
+import { agentEvents, type AgentEventPayloads } from '#/contract/agent/events';
+import type { EventRegistration } from '#/contract/types';
+import { EventHub, type KlientEvents } from './events/hub.js';
+import { createGlobalFacade, type GlobalFacade, type ScopedCaller } from './facade/global.js';
+import { createSessionFacade, type SessionFacade } from './facade/session.js';
+import { createAgentFacade, type AgentFacade } from './facade/agent.js';
+import { parseInput, parseOutput } from './validation.js';
+
+export interface KlientOptions {
+  /**
+   * Validate wire inputs/outputs and event payloads against the contract.
+   * Default `true`. Disable only on measured hot paths — validation is cheap
+   * (sub-µs for typical payloads) and is the drift tripwire.
+   */
+  readonly validate?: boolean;
+}
+
+export interface SessionHandle extends SessionFacade {
+  readonly events: KlientEvents<SessionEventPayloads>;
+  agent(agentId: string): AgentHandle;
+}
+
+export interface AgentHandle extends AgentFacade {
+  readonly events: KlientEvents<AgentEventPayloads>;
+}
+
+export interface Klient {
+  readonly global: GlobalFacade;
+  readonly events: KlientEvents;
+  session(sessionId: string): SessionHandle;
+  close(): Promise<void>;
+}
+
+export function createKlientFromChannel(
+  channel: KlientChannel,
+  options: KlientOptions = {},
+): Klient {
+  const validate = options.validate ?? true;
+
+  const call: ScopedCaller = async (scope, service, method, args) => {
+    const procedure = globalContract[service]?.[method];
+    if (procedure === undefined) {
+      // A facade method without a contract entry is a klient bug, not a wire error.
+      throw new Error(`no contract registered for ${service}.${method}`);
+    }
+    const name = `${service}.${method}`;
+    const wireArgs = validate ? parseInput(name, procedure, args) : args;
+    const data = await channel.call(scope, service, method, wireArgs);
+    return validate ? parseOutput(name, procedure, data) : data;
+  };
+
+  const hubs = new Set<{ close(): void }>();
+  const makeHub = <TPayloadMap extends object>(
+    scope: ScopeRef,
+    registrations: Record<string, EventRegistration>,
+  ): KlientEvents<TPayloadMap> => {
+    const hub = new EventHub<TPayloadMap>(channel, validate, scope, registrations);
+    hubs.add(hub);
+    return hub;
+  };
+
+  return {
+    global: createGlobalFacade(call),
+    events: makeHub<KlientEventPayloads>({}, globalEvents),
+    session(sessionId: string): SessionHandle {
+      const scope: ScopeRef = { sessionId };
+      return {
+        ...createSessionFacade(call, sessionId),
+        events: makeHub<SessionEventPayloads>(scope, sessionEvents),
+        agent(agentId: string): AgentHandle {
+          const agentScope: ScopeRef = { sessionId, agentId };
+          return {
+            ...createAgentFacade(call, agentScope),
+            events: makeHub<AgentEventPayloads>(agentScope, agentEvents),
+          };
+        },
+      };
+    },
+    close: () => {
+      for (const hub of hubs) {
+        hub.close();
+      }
+      hubs.clear();
+      return channel.close();
+    },
+  };
+}
diff --git a/packages/klient/src/core/validation.ts b/packages/klient/src/core/validation.ts
new file mode 100644
index 000000000..3ae01bb7c
--- /dev/null
+++ b/packages/klient/src/core/validation.ts
@@ -0,0 +1,70 @@
+/**
+ * zod-backed wire validation. Every procedure in the contract validates its
+ * input tuple before it goes on the wire (caller bugs) and its output when it
+ * comes back (server drift). Event payloads are validated on delivery;
+ * failures there are reported, not thrown, so one bad event cannot kill a
+ * subscription stream.
+ */
+
+import { z } from 'zod';
+
+import type { ProcedureContract } from '#/contract/types';
+
+export type ValidationPhase = 'input' | 'output' | 'event';
+
+export class KlientValidationError extends Error {
+  constructor(
+    readonly phase: ValidationPhase,
+    /** `service.method` for calls, the klient event name for events. */
+    readonly procedure: string,
+    readonly issues: z.ZodError['issues'],
+    /** The offending raw payload (input args, output data, or event data). */
+    readonly payload: unknown,
+  ) {
+    super(
+      `${phase} validation failed for ${procedure}: ${issues
+        .map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`)
+        .join('; ')}`,
+    );
+    this.name = 'KlientValidationError';
+  }
+}
+
+/** Parse the positional-args tuple; returns the normalized args to send. */
+export function parseInput(
+  procedure: string,
+  contract: ProcedureContract,
+  args: unknown[],
+): unknown[] {
+  const result = contract.input.safeParse(args);
+  if (!result.success) {
+    throw new KlientValidationError('input', procedure, result.error.issues, args);
+  }
+  return result.data as unknown[];
+}
+
+/** Parse a wire result; returns the normalized data to hand to the caller. */
+export function parseOutput(
+  procedure: string,
+  contract: ProcedureContract,
+  data: unknown,
+): unknown {
+  const result = contract.output.safeParse(data);
+  if (!result.success) {
+    throw new KlientValidationError('output', procedure, result.error.issues, data);
+  }
+  return result.data;
+}
+
+/** Parse an event payload without throwing; `undefined` on failure. */
+export function parseEvent(
+  event: string,
+  schema: z.ZodType,
+  data: unknown,
+): { ok: true; data: unknown } | { ok: false; error: KlientValidationError } {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    return { ok: false, error: new KlientValidationError('event', event, result.error.issues, data) };
+  }
+  return { ok: true, data: result.data };
+}
diff --git a/packages/klient/src/httpChannel.ts b/packages/klient/src/httpChannel.ts
deleted file mode 100644
index df9cf3e14..000000000
--- a/packages/klient/src/httpChannel.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- * `fetch`-backed `IChannel` for the `/api/v2` HTTP surface.
- *
- * Every call `POST`s the `resource:action` command to the scope base URL with
- * the single argument as a JSON body, then unwraps the project envelope: a
- * non-zero `code` throws `RPCError`, otherwise `data` is returned. The
- * server accepts `GET` for readonly actions too, but the client does not need
- * it. `fetch` is injectable so tests and non-global runtimes can supply it.
- */
-
-import type { IChannel } from './channel.js';
-import { RPCError } from './errors.js';
-
-interface Envelope<T> {
-  readonly code: number;
-  readonly msg: string;
-  readonly data: T;
-  readonly request_id: string;
-  readonly details?: unknown;
-}
-
-export interface HttpChannelOptions {
-  /** Scope base URL, e.g. `http://127.0.0.1:58627/api/v2[/session/:sid]`. */
-  readonly baseUrl: string;
-  /** Optional bearer token. */
-  readonly token?: string;
-  /** `fetch` implementation; defaults to the global `fetch`. */
-  readonly fetch?: typeof fetch;
-}
-
-export class HttpChannel implements IChannel {
-  private readonly baseUrl: string;
-  private readonly token?: string;
-  private readonly fetchImpl: typeof fetch;
-
-  constructor(opts: HttpChannelOptions) {
-    this.baseUrl = opts.baseUrl.replace(/\/$/, '');
-    this.token = opts.token;
-    // Bind the global fetch: browsers throw "Illegal invocation" when the
-    // native function is invoked with a non-Window receiver.
-    this.fetchImpl = opts.fetch ?? fetch.bind(globalThis);
-  }
-
-  async call<T>(command: string, args: unknown[] = []): Promise<T> {
-    const headers: Record<string, string> = {};
-    let body: string | undefined;
-    if (args.length > 0) {
-      headers['content-type'] = 'application/json';
-      body = JSON.stringify(args);
-    }
-    if (this.token !== undefined) {
-      headers['authorization'] = `Bearer ${this.token}`;
-    }
-    const res = await this.fetchImpl(`${this.baseUrl}/${command}`, {
-      method: 'POST',
-      headers,
-      body,
-    });
-    const envelope = (await res.json()) as Envelope<T>;
-    if (envelope.code !== 0) {
-      throw new RPCError(envelope.code, envelope.msg, envelope.details);
-    }
-    return envelope.data;
-  }
-
-  listen<T>(_event: string, _arg?: unknown): import('./channel.js').Event<T> {
-    throw new Error('events are not supported over the HTTP channel; use the WS transport');
-  }
-}
diff --git a/packages/klient/src/index.ts b/packages/klient/src/index.ts
index 267e84d81..ff3101461 100644
--- a/packages/klient/src/index.ts
+++ b/packages/klient/src/index.ts
@@ -1,35 +1,128 @@
 /**
- * `@moonshot-ai/klient` public surface — the `/api/v2` channel, the typed
- * service proxy, the scope-routed client, and the explicit service
- * implementations. Service interfaces and tokens are imported directly from
- * `agent-core-v2` leaf subpaths by consumers.
+ * `@moonshot-ai/klient` public surface — the transport-agnostic client facade
+ * over the agent-core-v2 engine. Create a klient with one of the transport
+ * entry points (`@moonshot-ai/klient/http`, `/ipc`, or `/memory`); everything
+ * exported here behaves identically regardless of which one carried the
+ * bytes.
  */
 
-export type { IChannel } from './channel.js';
-export { RPCError } from './errors.js';
-export { HttpChannel, type HttpChannelOptions } from './httpChannel.js';
-export { makeProxy } from './proxy.js';
+export type {
+  EventSourceRef,
+  IDisposable,
+  KlientChannel,
+  ScopeRef,
+} from './core/channel.js';
+export { RPCError } from './core/errors.js';
+export { KlientValidationError, type ValidationPhase } from './core/validation.js';
 export {
-  AgentClient,
-  Klient,
-  SessionClient,
+  createKlientFromChannel,
+  type AgentHandle,
+  type Klient,
   type KlientOptions,
-} from './client.js';
-export { SessionIndexClient } from './services/sessionIndex.js';
-export {
-  WsSocket,
-  type WsLike,
-  type WsLikeCtor,
-  type WsScopeIds,
-  type WsScopeKind,
-  type WsSocketOptions,
-  type WsSocketState,
-  type WsSubscription,
-} from './wsSocket.js';
-export { WsChannel, type WsChannelOptions } from './wsChannel.js';
-export {
-  WsAgentClient,
-  WsKlient,
-  WsSessionClient,
-  type WsKlientOptions,
-} from './wsKlient.js';
+  type SessionHandle,
+} from './core/klient.js';
+export type { KlientEvents } from './core/events/hub.js';
+export type { Caller, ScopedCaller } from './core/facade/global.js';
+
+export type {
+  ConfigTargetLiteral,
+  GlobalAuthFacade,
+  GlobalCatalogFacade,
+  GlobalConfigFacade,
+  GlobalFacade,
+  GlobalFlagsFacade,
+  GlobalHostFsFacade,
+  GlobalModelsFacade,
+  GlobalPluginsFacade,
+  GlobalProvidersFacade,
+  GlobalSessionsFacade,
+  GlobalWorkspacesFacade,
+  KlientEnvInfo,
+  ModelCatalogItem,
+  OAuthFlowSnapshot,
+  OAuthFlowStart,
+  OAuthLoginCancelResponse,
+  OAuthLogoutResponse,
+  ProviderCatalogItem,
+  RefreshProviderModelsOptions,
+  RefreshProviderModelsResponse,
+  SetDefaultModelResponse,
+} from './core/facade/global.js';
+
+export type {
+  SessionApprovalsFacade,
+  SessionFacade,
+  SessionInteractionsFacade,
+  SessionQuestionsFacade,
+  SessionStatus,
+} from './core/facade/session.js';
+export type {
+  AgentContextData,
+  AgentFacade,
+  AgentTaskInfo,
+  PlanData,
+  PromptLaunchResult,
+  SetModelResult,
+  ShellCommandResult,
+  UsageStatus,
+} from './core/facade/agent.js';
+
+export type {
+  CatalogChangedPayload,
+  KlientEventName,
+  KlientEventPayloads,
+  SessionArchivedPayload,
+  SessionMetaUpdatedPayload,
+} from './contract/global/events.js';
+export type { SessionEventPayloads } from './contract/session/events.js';
+export type { AgentEventPayloads } from './contract/agent/events.js';
+
+// Wire types re-exported for consumer convenience (type-only; the engine is
+// not pulled in at runtime for http consumers).
+export type {
+  SessionListQuery,
+  SessionSummary,
+} from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
+export type { Page } from '@moonshot-ai/agent-core-v2/persistence/interface/queryStore';
+export type {
+  Workspace,
+  WorkspaceUpdate,
+} from '@moonshot-ai/agent-core-v2/app/workspaceRegistry/workspaceRegistry';
+export type {
+  ConfigDiagnostic,
+  ConfigInspectValue,
+} from '@moonshot-ai/agent-core-v2/app/config/config';
+export type { ProviderConfig } from '@moonshot-ai/agent-core-v2/app/provider/provider';
+export type { AuthStatus } from '@moonshot-ai/agent-core-v2/app/auth/auth';
+export type { ExperimentalFeatureState } from '@moonshot-ai/agent-core-v2/app/flag/flag';
+export type { ModelConfig } from '@moonshot-ai/agent-core-v2/app/model/model';
+export type {
+  FsBrowseResponse,
+  FsHomeResponse,
+} from '@moonshot-ai/agent-core-v2/app/hostFolderBrowser/hostFolderBrowser';
+export type {
+  PluginCommandDef,
+  PluginInfo,
+  PluginSummary,
+  PluginUpdateStatus,
+  ReloadSummary,
+} from '@moonshot-ai/agent-core-v2/app/plugin/types';
+export type {
+  AgentMeta,
+  SessionMeta,
+  SessionMetaPatch,
+} from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
+export type {
+  ApprovalRequest,
+  ApprovalResponse,
+} from '@moonshot-ai/agent-core-v2/session/approval/approval';
+export type {
+  QuestionRequest,
+  QuestionResult,
+} from '@moonshot-ai/agent-core-v2/session/question/question';
+export type {
+  Interaction,
+  InteractionKind,
+} from '@moonshot-ai/agent-core-v2/session/interaction/interaction';
+export type { ContentPart } from '@moonshot-ai/agent-core-v2/app/llmProtocol/message';
+export type { PermissionMode } from '@moonshot-ai/agent-core-v2/agent/permissionPolicy/types';
diff --git a/packages/klient/src/proxy.ts b/packages/klient/src/proxy.ts
deleted file mode 100644
index bf53dba74..000000000
--- a/packages/klient/src/proxy.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- * Typed proxy turning an `IChannel` (bound to one Service) into a value
- * satisfying that Service's interface `T`.
- *
- * Members named `onUpperCase` become channel events; every other property access
- * becomes a function forwarding its complete argument array to `channel.call`.
- * This is VS Code's `ProxyChannel.toService`: the shared interface `T` is the
- * whole contract, with no per-method allowlist or renaming.
- */
-
-import type { IChannel } from './channel.js';
-
-export function makeProxy<T extends object>(channel: IChannel): T {
-  return new Proxy({} as T, {
-    get(_target, prop) {
-      if (typeof prop !== 'string') return undefined;
-      if (/^on[A-Z]/.test(prop)) return channel.listen(prop);
-      return (...args: unknown[]) => channel.call(prop, args);
-    },
-  });
-}
diff --git a/packages/klient/src/services/sessionIndex.ts b/packages/klient/src/services/sessionIndex.ts
deleted file mode 100644
index abb404f1e..000000000
--- a/packages/klient/src/services/sessionIndex.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Explicit, fully-typed `ISessionIndex` implementation over the HTTP channel.
- *
- * The hand-written counterpart to `makeProxy`: useful when a single interface
- * wants a named class, bespoke argument shaping, or a place to hang client-side
- * behavior. The injected `IChannel` must be bound to the `sessionIndex` scope
- * URL (`<base>/api/v2/sessionIndex`); methods are forwarded by name (`list` /
- * `get` / `countActive`). `ISessionIndex` carries only data methods (no `Event`
- * / stream / handle members), so it can be implemented faithfully.
- */
-
-import type {
-  ISessionIndex,
-  SessionListQuery,
-  SessionSummary,
-} from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
-import type { Page } from '@moonshot-ai/agent-core-v2/persistence/interface/queryStore';
-
-import type { IChannel } from '../channel.js';
-
-export class SessionIndexClient implements ISessionIndex {
-  declare readonly _serviceBrand: undefined;
-
-  constructor(private readonly channel: IChannel) {}
-
-  list(query: SessionListQuery): Promise<Page<SessionSummary>> {
-    return this.channel.call<Page<SessionSummary>>('list', [query]);
-  }
-
-  get(id: string): Promise<SessionSummary | undefined> {
-    return this.channel.call<SessionSummary | undefined>('get', [id]);
-  }
-
-  countActive(workspaceId: string): Promise<number> {
-    return this.channel.call<number>('countActive', [workspaceId]);
-  }
-}
diff --git a/packages/klient/src/transports/http/channel.ts b/packages/klient/src/transports/http/channel.ts
new file mode 100644
index 000000000..8f8f10179
--- /dev/null
+++ b/packages/klient/src/transports/http/channel.ts
@@ -0,0 +1,106 @@
+/**
+ * HTTP channel — one `POST /api/v2/[scope/]service/method` per call with the
+ * args tuple as the JSON body, unwrapping the server envelope. `listen` is
+ * delegated to a lazily created WS event bridge, so the transport exposes
+ * the full `KlientChannel` surface despite HTTP being request/response only.
+ */
+
+import type {
+  EventSourceRef,
+  IDisposable,
+  KlientChannel,
+  ScopeRef,
+} from '../../core/channel.js';
+import { RPCError } from '../../core/errors.js';
+import type { WsLikeCtor } from '../ws/wsSocket.js';
+import { WsEventBridge } from './eventBridge.js';
+
+interface Envelope<T> {
+  readonly code: number;
+  readonly msg: string;
+  readonly data: T;
+  readonly request_id: string;
+  readonly details?: unknown;
+}
+
+export interface HttpChannelOptions {
+  /** Server base URL, e.g. `http://127.0.0.1:58627`. */
+  readonly url: string;
+  readonly token?: string;
+  /** `fetch` implementation; defaults to the global `fetch`. */
+  readonly fetch?: typeof fetch;
+  /** WebSocket implementation for the lazy event bridge (Node ≥ 21 / browsers have one). */
+  readonly WebSocketImpl?: WsLikeCtor;
+}
+
+function scopePath(scope: ScopeRef): string {
+  let path = '';
+  if (scope.sessionId !== undefined) {
+    path += `/session/${encodeURIComponent(scope.sessionId)}`;
+  }
+  if (scope.agentId !== undefined) {
+    path += `/agent/${encodeURIComponent(scope.agentId)}`;
+  }
+  return path;
+}
+
+export class HttpChannel implements KlientChannel {
+  private readonly baseUrl: string;
+  private readonly url: string;
+  private readonly token?: string;
+  private readonly fetchImpl: typeof fetch;
+  private readonly WebSocketImpl?: WsLikeCtor;
+  private eventBridge: WsEventBridge | undefined;
+
+  constructor(options: HttpChannelOptions) {
+    this.url = options.url;
+    this.baseUrl = `${options.url.replace(/\/$/, '')}/api/v2`;
+    this.token = options.token;
+    // Bind the global fetch: browsers throw "Illegal invocation" when the
+    // native function is invoked with a non-Window receiver.
+    this.fetchImpl = options.fetch ?? fetch.bind(globalThis);
+    this.WebSocketImpl = options.WebSocketImpl;
+  }
+
+  async call(scope: ScopeRef, service: string, method: string, args: unknown[]): Promise<unknown> {
+    const headers: Record<string, string> = {};
+    let body: string | undefined;
+    if (args.length > 0) {
+      headers['content-type'] = 'application/json';
+      body = JSON.stringify(args);
+    }
+    if (this.token !== undefined) {
+      headers['authorization'] = `Bearer ${this.token}`;
+    }
+    const res = await this.fetchImpl(`${this.baseUrl}${scopePath(scope)}/${service}/${method}`, {
+      method: 'POST',
+      headers,
+      body,
+    });
+    const envelope = (await res.json()) as Envelope<unknown>;
+    if (envelope.code !== 0) {
+      throw new RPCError(envelope.code, envelope.msg, envelope.details);
+    }
+    return envelope.data;
+  }
+
+  listen(
+    scope: ScopeRef,
+    source: EventSourceRef,
+    handler: (data: unknown) => void,
+    onError?: (error: Error) => void,
+  ): IDisposable {
+    this.eventBridge ??= new WsEventBridge({
+      url: this.url,
+      token: this.token,
+      WebSocketImpl: this.WebSocketImpl,
+    });
+    return this.eventBridge.listen(scope, source, handler, onError);
+  }
+
+  close(): Promise<void> {
+    this.eventBridge?.close();
+    this.eventBridge = undefined;
+    return Promise.resolve();
+  }
+}
diff --git a/packages/klient/src/transports/http/eventBridge.ts b/packages/klient/src/transports/http/eventBridge.ts
new file mode 100644
index 000000000..de23e2543
--- /dev/null
+++ b/packages/klient/src/transports/http/eventBridge.ts
@@ -0,0 +1,63 @@
+/**
+ * Event bridge for the HTTP transport — HTTP has no push channel, so the
+ * first event subscription lazily opens one `/api/v2/ws` socket that carries
+ * every subscription from then on. The facade never sees this: events arrive
+ * exactly as they do over the ipc/memory transports. The socket is created
+ * on first use and torn down by `close()`.
+ */
+
+import type { EventSourceRef, IDisposable, ScopeRef } from '../../core/channel.js';
+import {
+  WsSocket,
+  type WsLikeCtor,
+  type WsScopeIds,
+  type WsScopeKind,
+} from '../ws/wsSocket.js';
+
+export interface WsEventBridgeOptions {
+  /** Server base URL (`http(s)://…`); the ws URL is derived from it. */
+  readonly url: string;
+  readonly token?: string;
+  readonly WebSocketImpl?: WsLikeCtor;
+}
+
+function scopeKindOf(scope: ScopeRef): WsScopeKind {
+  if (scope.agentId !== undefined) return 'agent';
+  if (scope.sessionId !== undefined) return 'session';
+  return 'core';
+}
+
+function scopeIdsOf(scope: ScopeRef): WsScopeIds {
+  return { sessionId: scope.sessionId, agentId: scope.agentId };
+}
+
+export class WsEventBridge {
+  private readonly socket: WsSocket;
+
+  constructor(options: WsEventBridgeOptions) {
+    this.socket = new WsSocket({
+      url: options.url,
+      token: options.token,
+      WebSocketImpl: options.WebSocketImpl,
+    });
+  }
+
+  listen(
+    scope: ScopeRef,
+    source: EventSourceRef,
+    handler: (data: unknown) => void,
+    onError?: (error: Error) => void,
+  ): IDisposable {
+    const kind = scopeKindOf(scope);
+    const ids = scopeIdsOf(scope);
+    if (source.kind === 'stream') {
+      // kap-server's eventMap binds service-less listens per scope.
+      return this.socket.listen(kind, source.name, ids, handler, undefined, onError);
+    }
+    return this.socket.listen(kind, source.event, ids, handler, source.service, onError);
+  }
+
+  close(): void {
+    this.socket.close();
+  }
+}
diff --git a/packages/klient/src/transports/http/index.ts b/packages/klient/src/transports/http/index.ts
new file mode 100644
index 000000000..92203a219
--- /dev/null
+++ b/packages/klient/src/transports/http/index.ts
@@ -0,0 +1,15 @@
+/**
+ * `createKlient` over HTTP(S) against kap-server's `/api/v2` surface. Event
+ * subscriptions transparently ride a lazily opened WebSocket — after
+ * initialization the klient behaves exactly like its ipc/memory siblings.
+ * Browser-safe: only `fetch` + an injectable `WebSocket` are required.
+ */
+
+import { createKlientFromChannel, type Klient, type KlientOptions } from '../../core/klient.js';
+import { HttpChannel, type HttpChannelOptions } from './channel.js';
+
+export interface HttpKlientOptions extends KlientOptions, HttpChannelOptions {}
+
+export function createKlient(options: HttpKlientOptions): Klient {
+  return createKlientFromChannel(new HttpChannel(options), options);
+}
diff --git a/packages/klient/src/transports/ipc/channel.ts b/packages/klient/src/transports/ipc/channel.ts
new file mode 100644
index 000000000..f5ec38024
--- /dev/null
+++ b/packages/klient/src/transports/ipc/channel.ts
@@ -0,0 +1,227 @@
+/**
+ * IPC client channel — connects to a `serveKlientIpc` host over a unix
+ * domain socket. Calls are correlated by client-chosen ids with a per-call
+ * deadline; event subscriptions are registered before the handshake
+ * completes and flushed once it does. There is no automatic reconnect: a
+ * broken socket rejects in-flight calls and stays closed (the WS transport
+ * owns the resumable-connection story).
+ */
+
+import { createConnection, type Socket } from 'node:net';
+
+import type {
+  EventSourceRef,
+  IDisposable,
+  KlientChannel,
+  ScopeRef,
+} from '../../core/channel.js';
+import { RPCError } from '../../core/errors.js';
+import { encodeFrame, NdjsonDecoder, type IpcFrame } from './codec.js';
+
+const DEFAULT_CALL_TIMEOUT_MS = 30_000;
+
+export interface IpcChannelOptions {
+  readonly socketPath: string;
+  readonly token?: string;
+  /** Per-call deadline (ms). Default `30000`; `0` disables. */
+  readonly callTimeoutMs?: number;
+}
+
+interface PendingCall {
+  readonly resolve: (data: unknown) => void;
+  readonly reject: (err: Error) => void;
+  readonly timer: ReturnType<typeof setTimeout> | undefined;
+}
+
+function scopeKindOf(scope: ScopeRef): 'core' | 'session' | 'agent' {
+  if (scope.agentId !== undefined) return 'agent';
+  if (scope.sessionId !== undefined) return 'session';
+  return 'core';
+}
+
+export class IpcChannel implements KlientChannel {
+  private readonly socket: Socket;
+  private readonly decoder = new NdjsonDecoder();
+  private readonly callTimeoutMs: number;
+  private readonly pending = new Map<string, PendingCall>();
+  private readonly listens = new Map<
+    string,
+    { handler: (data: unknown) => void; onError?: (error: Error) => void }
+  >();
+  private readonly ready: Promise<void>;
+  private closed = false;
+  private seq = 0;
+  private readonly idPrefix = `i${Date.now().toString(36)}`;
+
+  constructor(options: IpcChannelOptions) {
+    this.callTimeoutMs = options.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+    this.socket = createConnection(options.socketPath);
+    this.ready = new Promise<void>((resolve, reject) => {
+      const onError = (error: Error): void => {
+        reject(error);
+      };
+      this.socket.once('error', onError);
+      this.socket.once('connect', () => {
+        // The host sends `ready` immediately; answer with the handshake.
+        this.send({ type: 'hello', token: options.token });
+        this.socket.off('error', onError);
+        resolve();
+      });
+    });
+    // The promise is consumed lazily by call/listen; never let it reject unhandled.
+    this.ready.catch(() => {});
+
+    this.socket.on('data', (chunk) => {
+      for (const frame of this.decoder.push(chunk.toString('utf8'))) {
+        this.onFrame(frame);
+      }
+    });
+    this.socket.on('close', () => {
+      this.closed = true;
+      this.failAll(new Error('ipc closed'));
+      this.listens.clear();
+    });
+    this.socket.on('error', () => {
+      // 'close' always follows; teardown lives there.
+    });
+  }
+
+  async call(scope: ScopeRef, service: string, method: string, args: unknown[]): Promise<unknown> {
+    await this.ready;
+    if (this.closed) throw new Error('ipc closed');
+    const id = this.nextId();
+    const promise = new Promise<unknown>((resolve, reject) => {
+      const timer =
+        this.callTimeoutMs > 0
+          ? setTimeout(() => {
+              this.pending.delete(id);
+              reject(new RPCError(50001, `call timed out after ${this.callTimeoutMs}ms`));
+            }, this.callTimeoutMs)
+          : undefined;
+      this.pending.set(id, { resolve, reject, timer });
+    });
+    this.send({
+      type: 'call',
+      id,
+      scope: scopeKindOf(scope),
+      service,
+      method,
+      arg: args,
+      sessionId: scope.sessionId,
+      agentId: scope.agentId,
+    });
+    return promise;
+  }
+
+  listen(
+    scope: ScopeRef,
+    source: EventSourceRef,
+    handler: (data: unknown) => void,
+    onError?: (error: Error) => void,
+  ): IDisposable {
+    const id = this.nextId();
+    this.listens.set(id, { handler, onError });
+    const base = {
+      type: 'listen',
+      id,
+      scope: scopeKindOf(scope),
+      sessionId: scope.sessionId,
+      agentId: scope.agentId,
+    };
+    const frame: IpcFrame =
+      source.kind === 'stream'
+        ? { ...base, event: source.name }
+        : { ...base, service: source.service, event: source.event };
+    void this.ready.then(() => {
+      this.send(frame);
+    });
+    return {
+      dispose: () => {
+        if (!this.listens.delete(id)) return;
+        void this.ready.then(() => {
+          this.send({ type: 'unlisten', id });
+        });
+      },
+    };
+  }
+
+  close(): Promise<void> {
+    if (this.closed) return Promise.resolve();
+    this.closed = true;
+    this.failAll(new Error('ipc closed'));
+    this.listens.clear();
+    this.socket.end();
+    return Promise.resolve();
+  }
+
+  // -------------------------------------------------------------------------
+
+  private nextId(): string {
+    this.seq += 1;
+    return `${this.idPrefix}_${this.seq}`;
+  }
+
+  private onFrame(frame: IpcFrame): void {
+    const id = typeof frame.id === 'string' ? frame.id : '';
+    switch (frame.type) {
+      case 'ready':
+        return;
+      case 'result': {
+        const p = this.take(id);
+        p?.resolve(frame.data);
+        return;
+      }
+      case 'error': {
+        const error = new RPCError(
+          typeof frame.code === 'number' ? frame.code : 50001,
+          frame.msg ?? 'error',
+        );
+        const p = this.take(id);
+        if (p !== undefined) {
+          p.reject(error);
+          return;
+        }
+        const sub = this.listens.get(id);
+        if (sub !== undefined) {
+          this.listens.delete(id);
+          sub.onError?.(error);
+        }
+        return;
+      }
+      case 'listen_result':
+        return;
+      case 'event': {
+        this.listens.get(id)?.handler(frame.data);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+
+  private take(id: string): PendingCall | undefined {
+    const p = this.pending.get(id);
+    if (p !== undefined) {
+      this.pending.delete(id);
+      if (p.timer !== undefined) clearTimeout(p.timer);
+    }
+    return p;
+  }
+
+  private failAll(err: Error): void {
+    for (const p of this.pending.values()) {
+      if (p.timer !== undefined) clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+
+  private send(frame: IpcFrame): void {
+    if (this.closed || this.socket.destroyed) return;
+    try {
+      this.socket.write(encodeFrame(frame));
+    } catch {
+      // best-effort; the close handler handles teardown
+    }
+  }
+}
diff --git a/packages/klient/src/transports/ipc/codec.ts b/packages/klient/src/transports/ipc/codec.ts
new file mode 100644
index 000000000..5f905cd1c
--- /dev/null
+++ b/packages/klient/src/transports/ipc/codec.ts
@@ -0,0 +1,49 @@
+/**
+ * IPC wire framing — newline-delimited JSON over a `node:net` stream. The
+ * frame shapes deliberately mirror the `/api/v2/ws` protocol
+ * (`hello`/`call`/`listen`/`unlisten` ↔ `ready`/`result`/`error`/
+ * `listen_result`/`event`) so the two socket transports stay interchangeable;
+ * only the byte pipe differs.
+ */
+
+/** One NDJSON message. `type` discriminates; other fields depend on it. */
+export interface IpcFrame {
+  readonly type: string;
+  readonly id?: string;
+  readonly scope?: string;
+  readonly service?: string;
+  readonly method?: string;
+  readonly arg?: unknown;
+  readonly sessionId?: string;
+  readonly agentId?: string;
+  readonly event?: string;
+  readonly token?: string;
+  readonly code?: number;
+  readonly msg?: string;
+  readonly data?: unknown;
+}
+
+export function encodeFrame(frame: IpcFrame): string {
+  return `${JSON.stringify(frame)}\n`;
+}
+
+/** Incremental NDJSON decoder; malformed lines are dropped, mirroring the WS side. */
+export class NdjsonDecoder {
+  private buffer = '';
+
+  push(chunk: string): IpcFrame[] {
+    this.buffer += chunk;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() ?? '';
+    const frames: IpcFrame[] = [];
+    for (const line of lines) {
+      if (line.length === 0) continue;
+      try {
+        frames.push(JSON.parse(line) as IpcFrame);
+      } catch {
+        // drop malformed frames
+      }
+    }
+    return frames;
+  }
+}
diff --git a/packages/klient/src/transports/ipc/host.ts b/packages/klient/src/transports/ipc/host.ts
new file mode 100644
index 000000000..f4d67d89c
--- /dev/null
+++ b/packages/klient/src/transports/ipc/host.ts
@@ -0,0 +1,189 @@
+/**
+ * IPC host — serves one engine scope over a unix domain socket. Incoming
+ * frames are bridged to the shared in-process dispatcher (the same code the
+ * memory transport uses), so ipc and in-memory behavior are identical by
+ * construction; only serialization separates them.
+ */
+
+import { createServer, type Server, type Socket } from 'node:net';
+import { unlink } from 'node:fs/promises';
+
+import type { EventSourceRef, IDisposable, ScopeRef } from '../../core/channel.js';
+import { RPCError } from '../../core/errors.js';
+import { createMemoryDispatcher, type ScopeLike } from '../memory/dispatcher.js';
+import { encodeFrame, NdjsonDecoder, type IpcFrame } from './codec.js';
+
+const REQUEST_INVALID = 40001;
+const UNAUTHORIZED = 40100;
+
+export interface ServeKlientIpcOptions {
+  /** A bootstrapped engine app scope (same value `createKlient({ scope })` takes). */
+  readonly scope: ScopeLike;
+  /** Unix socket path to listen on. A stale file at the path is removed first. */
+  readonly socketPath: string;
+  /** Optional token; when set, the client's `hello` must carry the same token. */
+  readonly token?: string;
+}
+
+export interface KlientIpcHost {
+  readonly socketPath: string;
+  close(): Promise<void>;
+}
+
+function scopeRefFromFrame(frame: IpcFrame): ScopeRef {
+  const scope: { sessionId?: string; agentId?: string } = {};
+  if (typeof frame.sessionId === 'string') scope.sessionId = frame.sessionId;
+  if (typeof frame.agentId === 'string') scope.agentId = frame.agentId;
+  return scope;
+}
+
+function eventSourceFromFrame(frame: IpcFrame): EventSourceRef {
+  if (typeof frame.service === 'string' && typeof frame.event === 'string') {
+    return { kind: 'emitter', service: frame.service, event: frame.event };
+  }
+  if (typeof frame.event === 'string' && frame.event.length > 0) {
+    return { kind: 'stream', name: frame.event };
+  }
+  throw new RPCError(REQUEST_INVALID, `unknown event stream: ${String(frame.event)}`);
+}
+
+export async function serveKlientIpc(options: ServeKlientIpcOptions): Promise<KlientIpcHost> {
+  const dispatcher = createMemoryDispatcher(options.scope);
+
+  // Best-effort cleanup of a stale socket file; ignore everything but a real
+  // leftover (ENOENT = nothing to remove).
+  try {
+    await unlink(options.socketPath);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+
+  const connections = new Set<Socket>();
+
+  const server: Server = createServer((socket) => {
+    connections.add(socket);
+    const decoder = new NdjsonDecoder();
+    const listens = new Map<string, IDisposable>();
+    let helloDone = false;
+
+    const send = (frame: IpcFrame): void => {
+      if (!socket.destroyed) socket.write(encodeFrame(frame));
+    };
+    const sendError = (id: string, error: unknown): void => {
+      if (error instanceof RPCError) {
+        send({ type: 'error', id, code: error.code, msg: error.message });
+      } else {
+        send({
+          type: 'error',
+          id,
+          code: 50001,
+          msg: error instanceof Error ? error.message : String(error),
+        });
+      }
+    };
+
+    const handleFrame = (frame: IpcFrame): void => {
+      const id = typeof frame.id === 'string' ? frame.id : '';
+      switch (frame.type) {
+        case 'hello': {
+          if (options.token !== undefined && frame.token !== options.token) {
+            send({ type: 'error', id: 'hello', code: UNAUTHORIZED, msg: 'unauthorized' });
+            socket.end();
+            return;
+          }
+          helloDone = true;
+          return;
+        }
+        case 'call': {
+          if (!helloDone) {
+            sendError(id, new RPCError(REQUEST_INVALID, 'expected hello first'));
+            return;
+          }
+          const args = Array.isArray(frame.arg) ? frame.arg : frame.arg === undefined ? [] : [frame.arg];
+          dispatcher
+            .call(scopeRefFromFrame(frame), String(frame.service), String(frame.method), args)
+            .then((data) => {
+              send({ type: 'result', id, data });
+            })
+            .catch((error: unknown) => {
+              sendError(id, error);
+            });
+          return;
+        }
+        case 'listen': {
+          if (!helloDone) {
+            sendError(id, new RPCError(REQUEST_INVALID, 'expected hello first'));
+            return;
+          }
+          try {
+            const source = eventSourceFromFrame(frame);
+            const sub = dispatcher.listen(
+              scopeRefFromFrame(frame),
+              source,
+              (data) => {
+                send({ type: 'event', id, data });
+              },
+              (error) => {
+                sendError(id, error);
+              },
+            );
+            listens.set(id, sub);
+            send({ type: 'listen_result', id });
+          } catch (error) {
+            sendError(id, error);
+          }
+          return;
+        }
+        case 'unlisten': {
+          listens.get(id)?.dispose();
+          listens.delete(id);
+          return;
+        }
+        default:
+          return;
+      }
+    };
+
+    socket.on('data', (chunk) => {
+      for (const frame of decoder.push(chunk.toString('utf8'))) {
+        handleFrame(frame);
+      }
+    });
+    const teardown = (): void => {
+      for (const sub of listens.values()) sub.dispose();
+      listens.clear();
+      connections.delete(socket);
+    };
+    socket.on('close', teardown);
+    socket.on('error', teardown);
+
+    send({ type: 'ready' });
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(options.socketPath, resolve);
+  });
+
+  return {
+    socketPath: options.socketPath,
+    close: () => {
+      for (const socket of connections) {
+        socket.destroy();
+      }
+      connections.clear();
+      return new Promise<void>((resolve) => {
+        server.close(() => {
+          void unlink(options.socketPath).then(
+            () => {
+              resolve();
+            },
+            () => {
+              resolve();
+            },
+          );
+        });
+      });
+    },
+  };
+}
diff --git a/packages/klient/src/transports/ipc/index.ts b/packages/klient/src/transports/ipc/index.ts
new file mode 100644
index 000000000..58fe1e724
--- /dev/null
+++ b/packages/klient/src/transports/ipc/index.ts
@@ -0,0 +1,19 @@
+/**
+ * `createKlient` over a unix domain socket, plus the matching host
+ * (`serveKlientIpc`) for processes embedding the engine. Node-only.
+ */
+
+import { createKlientFromChannel, type Klient, type KlientOptions } from '../../core/klient.js';
+import { IpcChannel, type IpcChannelOptions } from './channel.js';
+
+export {
+  serveKlientIpc,
+  type KlientIpcHost,
+  type ServeKlientIpcOptions,
+} from './host.js';
+
+export interface IpcKlientOptions extends KlientOptions, IpcChannelOptions {}
+
+export function createKlient(options: IpcKlientOptions): Klient {
+  return createKlientFromChannel(new IpcChannel(options), options);
+}
diff --git a/packages/klient/src/transports/memory/dispatcher.ts b/packages/klient/src/transports/memory/dispatcher.ts
new file mode 100644
index 000000000..1cb04c5f5
--- /dev/null
+++ b/packages/klient/src/transports/memory/dispatcher.ts
@@ -0,0 +1,186 @@
+/**
+ * In-process dispatcher — resolves a wire triple `(service, method, args)`
+ * against a live engine scope and mirrors kap-server's dispatcher semantics
+ * (reflection call, non-function members are property reads, `main` agent
+ * auto-materialized via `ensureMainAgent`). Scope routing walks
+ * `ISessionLifecycleService` / `IAgentLifecycleService` exactly like the
+ * server's `resolveScope`. Every argument, result, and event payload passes
+ * through `wireClone` (a JSON round-trip), so consumers observe
+ * byte-identical data no matter whether the call crossed a socket or stayed
+ * in-process — and non-serializable leaks fail early.
+ *
+ * Shared by the memory transport and the IPC host, which guarantees ipc and
+ * memory behave identically by construction.
+ */
+
+import type { ServiceIdentifier } from '@moonshot-ai/agent-core-v2/_base/di/instantiation';
+import { ISessionLifecycleService } from '@moonshot-ai/agent-core-v2/app/sessionLifecycle/sessionLifecycle';
+import { IAgentLifecycleService } from '@moonshot-ai/agent-core-v2/session/agentLifecycle/agentLifecycle';
+import { ensureMainAgent } from '@moonshot-ai/agent-core-v2/session/agentLifecycle/mainAgent';
+import { ISessionInteractionService } from '@moonshot-ai/agent-core-v2/session/interaction/interaction';
+import { IEventBus } from '@moonshot-ai/agent-core-v2/app/event/eventBus';
+
+import type { EventSourceRef, IDisposable, ScopeRef } from '../../core/channel.js';
+import { RPCError } from '../../core/errors.js';
+import { IEventService, serviceTokens } from './serviceRegistry.js';
+
+/** Structural minimum of an engine `Scope` / `IScopeHandle`. */
+export interface ScopeLike {
+  readonly accessor: {
+    get<T>(id: ServiceIdentifier<T>): T;
+  };
+}
+
+/** JSON round-trip so in-process data matches wire data exactly. */
+export function wireClone<T>(value: T): T {
+  if (value === undefined) return value;
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+export interface MemoryDispatcher {
+  call(scope: ScopeRef, service: string, method: string, args: unknown[]): Promise<unknown>;
+  listen(
+    scope: ScopeRef,
+    source: EventSourceRef,
+    handler: (data: unknown) => void,
+    onError?: (error: Error) => void,
+  ): IDisposable;
+}
+
+const REQUEST_INVALID = 40001;
+const NOT_FOUND = 40404;
+
+type ScopeKind = 'core' | 'session' | 'agent';
+
+interface ResolvedScope {
+  readonly kind: ScopeKind;
+  readonly like: ScopeLike;
+}
+
+export function createMemoryDispatcher(root: ScopeLike): MemoryDispatcher {
+  /** Mirrors kap-server's `resolveScope`, incl. main-agent materialization. */
+  async function resolveScope(scope: ScopeRef): Promise<ResolvedScope> {
+    if (scope.sessionId === undefined) return { kind: 'core', like: root };
+    const session = root.accessor.get(ISessionLifecycleService).get(scope.sessionId);
+    if (session === undefined) {
+      throw new RPCError(NOT_FOUND, `session not found: ${scope.sessionId}`);
+    }
+    if (scope.agentId === undefined) return { kind: 'session', like: session };
+    if (scope.agentId === 'main') {
+      return { kind: 'agent', like: await ensureMainAgent(session) };
+    }
+    const agent = session.accessor.get(IAgentLifecycleService).get(scope.agentId);
+    if (agent === undefined) {
+      throw new RPCError(NOT_FOUND, `agent not found: ${scope.agentId}`);
+    }
+    return { kind: 'agent', like: agent };
+  }
+
+  function resolveService(resolved: ResolvedScope, service: string): Record<string, unknown> {
+    const token = serviceTokens[service];
+    if (token === undefined) {
+      throw new RPCError(REQUEST_INVALID, `unknown service: ${service}`);
+    }
+    return resolved.like.accessor.get(token) as Record<string, unknown>;
+  }
+
+  /** Mirrors kap-server's WS `eventMap` per scope kind. */
+  function subscribeStream(
+    resolved: ResolvedScope,
+    name: string,
+    handler: (data: unknown) => void,
+  ): IDisposable {
+    if (resolved.kind === 'core' && name === 'events') {
+      const bus = resolved.like.accessor.get(IEventService);
+      return bus.subscribe((event) => {
+        handler(wireClone(event));
+      });
+    }
+    if (resolved.kind === 'session' && name === 'interactions') {
+      const interaction = resolved.like.accessor.get(ISessionInteractionService);
+      return interaction.onDidChangePending(() => {
+        handler(wireClone(interaction.listPending()));
+      });
+    }
+    if (resolved.kind === 'session' && name === 'interactions:resolved') {
+      const interaction = resolved.like.accessor.get(ISessionInteractionService);
+      return interaction.onDidResolve((resolution) => {
+        handler(wireClone(resolution));
+      });
+    }
+    if (resolved.kind === 'agent' && name === 'events') {
+      const bus = resolved.like.accessor.get(IEventBus);
+      return bus.subscribe((event) => {
+        handler(wireClone(event));
+      });
+    }
+    throw new RPCError(REQUEST_INVALID, `unknown event stream: ${name} (${resolved.kind})`);
+  }
+
+  function subscribeSource(
+    resolved: ResolvedScope,
+    source: EventSourceRef,
+    handler: (data: unknown) => void,
+  ): IDisposable {
+    if (source.kind === 'stream') {
+      return subscribeStream(resolved, source.name, handler);
+    }
+    if (!/^on[A-Z]/.test(source.event)) {
+      throw new RPCError(REQUEST_INVALID, `not an event property: ${source.event}`);
+    }
+    const instance = resolveService(resolved, source.service);
+    const emitter = instance[source.event];
+    if (typeof emitter !== 'function') {
+      throw new RPCError(REQUEST_INVALID, `event not found: ${source.service}.${source.event}`);
+    }
+    return (emitter as (listener: (data: unknown) => void) => IDisposable).call(
+      instance,
+      (data) => {
+        handler(wireClone(data));
+      },
+    );
+  }
+
+  return {
+    async call(scope, service, method, args) {
+      const resolved = await resolveScope(scope);
+      const instance = resolveService(resolved, service);
+      const member = instance[method];
+      if (member === undefined) {
+        throw new RPCError(REQUEST_INVALID, `method not found: ${service}.${method}`);
+      }
+      if (typeof member !== 'function') {
+        return wireClone(member);
+      }
+      const clonedArgs = args.map(wireClone);
+      const result = await (member as (...a: unknown[]) => unknown).apply(instance, clonedArgs);
+      return wireClone(result);
+    },
+
+    listen(scope, source, handler, onError) {
+      // Scope resolution can be async (main-agent materialization); the
+      // subscription attaches once settled. Disposing early cancels it.
+      let inner: IDisposable | undefined;
+      let disposed = false;
+      void resolveScope(scope).then(
+        (resolved) => {
+          if (disposed) return;
+          try {
+            inner = subscribeSource(resolved, source, handler);
+          } catch (error) {
+            onError?.(error instanceof Error ? error : new Error(String(error)));
+          }
+        },
+        (error: unknown) => {
+          onError?.(error instanceof Error ? error : new Error(String(error)));
+        },
+      );
+      return {
+        dispose: () => {
+          disposed = true;
+          inner?.dispose();
+        },
+      };
+    },
+  };
+}
diff --git a/packages/klient/src/transports/memory/index.ts b/packages/klient/src/transports/memory/index.ts
new file mode 100644
index 000000000..f5f6eb3bf
--- /dev/null
+++ b/packages/klient/src/transports/memory/index.ts
@@ -0,0 +1,57 @@
+/**
+ * `createKlient` over an in-process engine scope — the host bootstraps the
+ * engine (`bootstrap()` from agent-core-v2) and passes the app scope (or its
+ * handle) in. Calls and events never leave the process, but everything the
+ * facade returns has crossed the same JSON round-trip as the networked
+ * transports, so behavior is indistinguishable.
+ */
+
+import type {
+  EventSourceRef,
+  IDisposable,
+  KlientChannel,
+  ScopeRef,
+} from '../../core/channel.js';
+import { createKlientFromChannel, type Klient, type KlientOptions } from '../../core/klient.js';
+import { createMemoryDispatcher, type ScopeLike } from './dispatcher.js';
+
+export type { ScopeLike } from './dispatcher.js';
+
+export interface MemoryKlientOptions extends KlientOptions {
+  /**
+   * A bootstrapped engine app scope (`bootstrap(...).app` or an
+   * `IAppScopeHandle`). The klient does NOT own its lifecycle — `close()`
+   * leaves the scope alone.
+   */
+  readonly scope: ScopeLike;
+}
+
+class MemoryChannel implements KlientChannel {
+  private readonly dispatcher;
+
+  constructor(scope: ScopeLike) {
+    this.dispatcher = createMemoryDispatcher(scope);
+  }
+
+  call(scope: ScopeRef, service: string, method: string, args: unknown[]): Promise<unknown> {
+    return this.dispatcher.call(scope, service, method, args);
+  }
+
+  listen(
+    scope: ScopeRef,
+    source: EventSourceRef,
+    handler: (data: unknown) => void,
+    onError?: (error: Error) => void,
+  ): IDisposable {
+    return this.dispatcher.listen(scope, source, handler, onError);
+  }
+
+  close(): Promise<void> {
+    // The scope belongs to the host; nothing transport-side to release.
+    return Promise.resolve();
+  }
+}
+
+export function createKlient(options: MemoryKlientOptions): Klient {
+  return createKlientFromChannel(new MemoryChannel(options.scope), options);
+}
diff --git a/packages/klient/src/transports/memory/serviceRegistry.ts b/packages/klient/src/transports/memory/serviceRegistry.ts
new file mode 100644
index 000000000..4191cc6f8
--- /dev/null
+++ b/packages/klient/src/transports/memory/serviceRegistry.ts
@@ -0,0 +1,55 @@
+/**
+ * Service name → DI token registry for the in-process dispatcher. Only leaf
+ * modules are imported (tokens + types) — never the engine root barrel, so
+ * hosting klient in-process does not force the full registration side effects
+ * beyond what the host already bootstrapped.
+ */
+
+import type { ServiceIdentifier } from '@moonshot-ai/agent-core-v2/_base/di/instantiation';
+import { ISessionIndex } from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
+import { IWorkspaceRegistry } from '@moonshot-ai/agent-core-v2/app/workspaceRegistry/workspaceRegistry';
+import { IConfigService } from '@moonshot-ai/agent-core-v2/app/config/config';
+import { IModelService } from '@moonshot-ai/agent-core-v2/app/model/model';
+import { IModelCatalogService } from '@moonshot-ai/agent-core-v2/app/modelCatalog/modelCatalog';
+import { IProviderService } from '@moonshot-ai/agent-core-v2/app/provider/provider';
+import {
+  IAuthSummaryService,
+  IOAuthService,
+} from '@moonshot-ai/agent-core-v2/app/auth/auth';
+import { IFlagService } from '@moonshot-ai/agent-core-v2/app/flag/flag';
+import { IPluginService } from '@moonshot-ai/agent-core-v2/app/plugin/plugin';
+import { IBootstrapService } from '@moonshot-ai/agent-core-v2/app/bootstrap/bootstrap';
+import { IEventService } from '@moonshot-ai/agent-core-v2/app/event/event';
+import { IHostFolderBrowser } from '@moonshot-ai/agent-core-v2/app/hostFolderBrowser/hostFolderBrowser';
+import { ISessionLifecycleService } from '@moonshot-ai/agent-core-v2/app/sessionLifecycle/sessionLifecycle';
+import { ISessionMetadata } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
+import { ISessionInteractionService } from '@moonshot-ai/agent-core-v2/session/interaction/interaction';
+import { ISessionApprovalService } from '@moonshot-ai/agent-core-v2/session/approval/approval';
+import { ISessionQuestionService } from '@moonshot-ai/agent-core-v2/session/question/question';
+import { IAgentRPCService } from '@moonshot-ai/agent-core-v2/agent/rpc/rpc';
+import { IAgentActivityView } from '@moonshot-ai/agent-core-v2/agent/activityView/activityView';
+
+/** Wire service name (decorator id string) → token. */
+export const serviceTokens: Readonly<Record<string, ServiceIdentifier<unknown>>> = {
+  sessionIndex: ISessionIndex,
+  workspaceRegistry: IWorkspaceRegistry,
+  configService: IConfigService,
+  modelService: IModelService,
+  modelCatalogService: IModelCatalogService,
+  providerService: IProviderService,
+  oauthService: IOAuthService,
+  authSummaryService: IAuthSummaryService,
+  flagService: IFlagService,
+  pluginService: IPluginService,
+  hostFolderBrowser: IHostFolderBrowser,
+  bootstrapService: IBootstrapService,
+  sessionLifecycleService: ISessionLifecycleService,
+  sessionMetadata: ISessionMetadata,
+  sessionInteractionService: ISessionInteractionService,
+  sessionApprovalService: ISessionApprovalService,
+  sessionQuestionService: ISessionQuestionService,
+  agentRPCService: IAgentRPCService,
+  agentActivityView: IAgentActivityView,
+};
+
+export { IEventService };
diff --git a/packages/klient/src/wsSocket.ts b/packages/klient/src/transports/ws/wsSocket.ts
similarity index 99%
rename from packages/klient/src/wsSocket.ts
rename to packages/klient/src/transports/ws/wsSocket.ts
index 5d6da792b..d345410dc 100644
--- a/packages/klient/src/wsSocket.ts
+++ b/packages/klient/src/transports/ws/wsSocket.ts
@@ -15,7 +15,7 @@
  * implementation can be injected for tests.
  */
 
-import { RPCError } from './errors.js';
+import { RPCError } from '../../core/errors.js';
 
 /** Wire scope kinds, mirroring kap-server's `ScopeKind`. */
 export type WsScopeKind = 'core' | 'session' | 'agent';
diff --git a/packages/klient/src/wsChannel.ts b/packages/klient/src/wsChannel.ts
deleted file mode 100644
index edc185381..000000000
--- a/packages/klient/src/wsChannel.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-/**
- * `WsChannel` — an `IChannel` bound to one Service that forwards `call`s over
- * the shared `/api/v2/ws` socket instead of HTTP. Same VS Code shape as
- * `HttpChannel` (the URL equivalent is the `{scope, service, ids}` triple the
- * socket puts on each frame), so the same `makeProxy` turns it into a typed
- * Service client. `listen` here takes a handler and returns a subscription
- * that survives reconnects until disposed.
- */
-
-import type { Event, IChannel } from './channel.js';
-import type { WsScopeIds, WsScopeKind, WsSocket } from './wsSocket.js';
-
-export interface WsChannelOptions {
-  readonly socket: WsSocket;
-  readonly scope: WsScopeKind;
-  /** Service channel name (the decorator id, `String(id)`). */
-  readonly service: string;
-  readonly sessionId?: string;
-  readonly agentId?: string;
-}
-
-interface SharedEvent {
-  readonly listeners: Set<{ listener: (data: unknown) => unknown; thisArg: unknown }>;
-  remote?: { dispose(): void };
-}
-
-export class WsChannel implements IChannel {
-  private readonly socket: WsSocket;
-  private readonly scope: WsScopeKind;
-  private readonly service: string;
-  private readonly ids: WsScopeIds;
-  private readonly events = new Map<string, SharedEvent>();
-
-  constructor(opts: WsChannelOptions) {
-    this.socket = opts.socket;
-    this.scope = opts.scope;
-    this.service = opts.service;
-    this.ids = { sessionId: opts.sessionId, agentId: opts.agentId };
-  }
-
-  call<T>(command: string, args: unknown[] = []): Promise<T> {
-    return this.socket.call(this.scope, this.service, command, args, this.ids);
-  }
-
-  listen<T>(event: string): Event<T> {
-    let shared = this.events.get(event);
-    if (shared === undefined) {
-      shared = { listeners: new Set() };
-      this.events.set(event, shared);
-    }
-    return (listener, thisArg, disposables) => {
-      const entry = { listener: listener as (data: unknown) => unknown, thisArg };
-      shared.listeners.add(entry);
-      shared.remote ??= this.socket.listen(
-        this.scope,
-        event,
-        this.ids,
-        (data) => {
-          for (const current of shared.listeners) current.listener.call(current.thisArg, data);
-        },
-        this.service,
-      );
-      let disposed = false;
-      const subscription = {
-        dispose: (): void => {
-          if (disposed) return;
-          disposed = true;
-          shared.listeners.delete(entry);
-          if (shared.listeners.size === 0) {
-            shared.remote?.dispose();
-            shared.remote = undefined;
-          }
-        },
-      };
-      disposables?.push(subscription);
-      return subscription;
-    };
-  }
-}
diff --git a/packages/klient/src/wsKlient.ts b/packages/klient/src/wsKlient.ts
deleted file mode 100644
index 89eba2862..000000000
--- a/packages/klient/src/wsKlient.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * `WsKlient` — the `/api/v2` scope-entry client over the WebSocket transport.
- *
- * Mirrors `Klient`'s three-level scope entry (`core` / `session` / `agent`),
- * but every Service call rides the shared `WsSocket`, and each scope level
- * also exposes `listen(event, handler)` for the server's event streams
- * (`core` → `events`; `session` → `interactions` / `interactions:resolved`;
- * `agent` → `events`):
- *
- *   const ws = new WsKlient({ url: 'http://127.0.0.1:58627', token });
- *   await ws.core(ISessionIndex).list({});
- *   const sub = ws.session('s1').agent('main').listen('events', (e) => ...);
- *   sub.dispose(); ws.close();
- *
- * Prefer `Klient#ws()` over constructing this directly so HTTP and WS share
- * one configured endpoint.
- */
-
-import type { ServiceIdentifier } from '@moonshot-ai/agent-core-v2/_base/di/instantiation';
-
-import { makeProxy } from './proxy.js';
-import { WsChannel } from './wsChannel.js';
-import {
-  WsSocket,
-  type WsSocketOptions,
-  type WsSocketState,
-  type WsSubscription,
-} from './wsSocket.js';
-
-export type WsKlientOptions = WsSocketOptions;
-
-export class WsKlient {
-  private readonly socket: WsSocket;
-
-  constructor(opts: WsKlientOptions) {
-    this.socket = new WsSocket(opts);
-  }
-
-  /** Core-scoped Service over WS, e.g. `ws.core(ISessionIndex)`. */
-  core<T extends object>(id: ServiceIdentifier<T>): T {
-    return makeProxy<T>(new WsChannel({ socket: this.socket, scope: 'core', service: String(id) }));
-  }
-
-  /** Session scope entry point. */
-  session(sessionId: string): WsSessionClient {
-    return new WsSessionClient(this.socket, sessionId);
-  }
-
-  /** Subscribe to a core-scoped event stream (e.g. `events`). */
-  listen(event: string, handler: (data: unknown) => void): WsSubscription {
-    return this.socket.listen('core', event, {}, handler);
-  }
-
-  get state(): WsSocketState {
-    return this.socket.currentState;
-  }
-
-  onDidChangeState(listener: (state: WsSocketState) => void): WsSubscription {
-    return this.socket.onDidChangeState(listener);
-  }
-
-  onDidListenError(listener: Parameters<WsSocket['onDidListenError']>[0]): WsSubscription {
-    return this.socket.onDidListenError(listener);
-  }
-
-  close(): void {
-    this.socket.close();
-  }
-}
-
-export class WsSessionClient {
-  constructor(
-    private readonly socket: WsSocket,
-    private readonly sessionId: string,
-  ) {}
-
-  /** Session-scoped Service over WS, e.g. `.service(ISessionMetadata)`. */
-  service<T extends object>(id: ServiceIdentifier<T>): T {
-    return makeProxy<T>(
-      new WsChannel({
-        socket: this.socket,
-        scope: 'session',
-        service: String(id),
-        sessionId: this.sessionId,
-      }),
-    );
-  }
-
-  /** Subscribe to a session-scoped event stream (e.g. `interactions`). */
-  listen(event: string, handler: (data: unknown) => void): WsSubscription {
-    return this.socket.listen('session', event, { sessionId: this.sessionId }, handler);
-  }
-
-  /** Agent scope entry point. */
-  agent(agentId: string): WsAgentClient {
-    return new WsAgentClient(this.socket, this.sessionId, agentId);
-  }
-}
-
-export class WsAgentClient {
-  constructor(
-    private readonly socket: WsSocket,
-    private readonly sessionId: string,
-    private readonly agentId: string,
-  ) {}
-
-  /** Agent-scoped Service over WS, e.g. `.service(IAgentProfileService)`. */
-  service<T extends object>(id: ServiceIdentifier<T>): T {
-    return makeProxy<T>(
-      new WsChannel({
-        socket: this.socket,
-        scope: 'agent',
-        service: String(id),
-        sessionId: this.sessionId,
-        agentId: this.agentId,
-      }),
-    );
-  }
-
-  /** Subscribe to an agent-scoped event stream (e.g. `events`). */
-  listen(event: string, handler: (data: unknown) => void): WsSubscription {
-    return this.socket.listen(
-      'agent',
-      event,
-      { sessionId: this.sessionId, agentId: this.agentId },
-      handler,
-    );
-  }
-}
diff --git a/packages/klient/test/client.test.ts b/packages/klient/test/client.test.ts
deleted file mode 100644
index 1f433b526..000000000
--- a/packages/klient/test/client.test.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { ISessionIndex } from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
-import { ISessionMetadata } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
-import { createDecorator } from '@moonshot-ai/agent-core-v2/_base/di/instantiation';
-
-import { Klient } from '../src/client.js';
-import { HttpChannel } from '../src/httpChannel.js';
-import { SessionIndexClient } from '../src/services/sessionIndex.js';
-
-interface IAgentProfileLike {
-  getModel(): Promise<unknown>;
-}
-const IAgentProfileLike = createDecorator<IAgentProfileLike>('agentProfileLike');
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { 'content-type': 'application/json' },
-  });
-}
-
-describe('HttpChannel', () => {
-  const fetchMock = vi.fn<typeof fetch>();
-  afterEach(() => {
-    fetchMock.mockReset();
-  });
-
-  it('POSTs the method name to the service URL and unwraps envelope data', async () => {
-    fetchMock.mockResolvedValue(
-      jsonResponse({ code: 0, msg: 'ok', data: { items: [] }, request_id: 'r1' }),
-    );
-    const channel = new HttpChannel({
-      baseUrl: 'http://127.0.0.1:58627/api/v2/sessionIndex',
-      fetch: fetchMock,
-    });
-
-    const data = await channel.call('list', [{ workspaceId: 'w1' }]);
-
-    expect(data).toEqual({ items: [] });
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [url, init] = fetchMock.mock.calls[0]!;
-    expect(url as string).toBe('http://127.0.0.1:58627/api/v2/sessionIndex/list');
-    expect(init?.method).toBe('POST');
-    expect(init?.body).toBe(JSON.stringify([{ workspaceId: 'w1' }]));
-    expect((init?.headers as Record<string, string>)['content-type']).toBe('application/json');
-  });
-
-  it('omits the body when no argument is given', async () => {
-    fetchMock.mockResolvedValue(jsonResponse({ code: 0, msg: 'ok', data: 3, request_id: 'r2' }));
-    const channel = new HttpChannel({ baseUrl: 'http://x/api/v2/sessionIndex', fetch: fetchMock });
-
-    await channel.call('countActive');
-
-    const [, init] = fetchMock.mock.calls[0]!;
-    expect(init?.body).toBeUndefined();
-  });
-
-  it('sends a bearer token when provided', async () => {
-    fetchMock.mockResolvedValue(jsonResponse({ code: 0, msg: 'ok', data: null, request_id: 'r3' }));
-    const channel = new HttpChannel({
-      baseUrl: 'http://x/api/v2/sessionIndex',
-      token: 't',
-      fetch: fetchMock,
-    });
-
-    await channel.call('list');
-
-    const [, init] = fetchMock.mock.calls[0]!;
-    expect((init?.headers as Record<string, string>)['authorization']).toBe('Bearer t');
-  });
-
-  it('throws RPCError on a non-zero envelope code', async () => {
-    fetchMock.mockResolvedValue(
-      jsonResponse({ code: 40001, msg: 'method not found', data: null, request_id: 'r4' }),
-    );
-    const channel = new HttpChannel({ baseUrl: 'http://x/api/v2/sessionIndex', fetch: fetchMock });
-
-    await expect(channel.call('nope')).rejects.toMatchObject({
-      name: 'RPCError',
-      code: 40001,
-    });
-  });
-});
-
-describe('Klient scope routing', () => {
-  it('routes core / session / agent scopes by decorator id', async () => {
-    const calls: string[] = [];
-    const fetchMock = vi.fn<typeof fetch>().mockImplementation((input) => {
-      calls.push(input as string);
-      return Promise.resolve(jsonResponse({ code: 0, msg: 'ok', data: null, request_id: 'r' }));
-    });
-    const client = new Klient({ url: 'http://127.0.0.1:58627', fetch: fetchMock });
-
-    await client.core(ISessionIndex).list({});
-    await client.session('s 1').service(ISessionMetadata).read();
-    await client.session('s 1').agent('a 1').service(IAgentProfileLike).getModel();
-
-    expect(calls).toEqual([
-      'http://127.0.0.1:58627/api/v2/sessionIndex/list',
-      'http://127.0.0.1:58627/api/v2/session/s%201/sessionMetadata/read',
-      'http://127.0.0.1:58627/api/v2/session/s%201/agent/a%201/agentProfileLike/getModel',
-    ]);
-  });
-});
-
-describe('SessionIndexClient (explicit implementation)', () => {
-  it('implements ISessionIndex over the channel', async () => {
-    const page = {
-      items: [{ id: 's1', workspaceId: 'w1', createdAt: 1, updatedAt: 2, archived: false }],
-    };
-    const fetchMock = vi
-      .fn<typeof fetch>()
-      .mockImplementation(() =>
-        Promise.resolve(jsonResponse({ code: 0, msg: 'ok', data: page, request_id: 'r' })),
-      );
-    const channel = new HttpChannel({ baseUrl: 'http://x/api/v2/sessionIndex', fetch: fetchMock });
-
-    const index: ISessionIndex = new SessionIndexClient(channel);
-    await expect(index.list({})).resolves.toEqual(page);
-    await index.get('s1');
-    await index.countActive('w1');
-
-    const urls = fetchMock.mock.calls.map((c) => c[0] as string);
-    expect(urls).toEqual([
-      'http://x/api/v2/sessionIndex/list',
-      'http://x/api/v2/sessionIndex/get',
-      'http://x/api/v2/sessionIndex/countActive',
-    ]);
-  });
-});
diff --git a/packages/klient/test/contract-parity.ts b/packages/klient/test/contract-parity.ts
new file mode 100644
index 000000000..b9ad1cbae
--- /dev/null
+++ b/packages/klient/test/contract-parity.ts
@@ -0,0 +1,542 @@
+/**
+ * Compile-time parity checks between klient wire schemas and the engine
+ * types they mirror. Plain `.ts` (not `.test.ts`) — vitest must not pick it
+ * up; `tsc -p tsconfig.json --noEmit` is the check.
+ *
+ * Wire shapes the engine imports from `@moonshot-ai/protocol` are reached
+ * through indexed access on the engine service interfaces, since klient does
+ * not depend on the protocol package directly.
+ */
+
+import type { z } from 'zod';
+
+import type {
+  ActivityLastTurnState,
+  ActivityRetryState,
+  ActivityTurnState,
+  ActivityViewLifecycle,
+  AgentActivityState,
+  ApprovalRef,
+  BackgroundRef,
+  ToolCallRef,
+  TurnPhase,
+} from '@moonshot-ai/agent-core-v2/agent/activityView/activityView';
+import type { AgentContextData } from '@moonshot-ai/agent-core-v2/agent/contextMemory/types';
+import type { TurnEndReason } from '@moonshot-ai/agent-core-v2/agent/loop/turnEvents';
+import type { PlanData } from '@moonshot-ai/agent-core-v2/agent/plan/plan';
+import type {
+  AgentAPI,
+  PromptPart,
+} from '@moonshot-ai/agent-core-v2/agent/rpc/core-api';
+import type { ISessionScopeHandle } from '@moonshot-ai/agent-core-v2/_base/di/scope';
+import type {
+  CreateChildSessionOptions,
+  CreateSessionOptions,
+  ForkSessionOptions,
+} from '@moonshot-ai/agent-core-v2/app/sessionLifecycle/sessionLifecycle';
+import type {
+  ApprovalRequest,
+  ApprovalResponse,
+} from '@moonshot-ai/agent-core-v2/session/approval/approval';
+import type {
+  Interaction,
+  InteractionResolution,
+} from '@moonshot-ai/agent-core-v2/session/interaction/interaction';
+import type {
+  QuestionAnswers,
+  QuestionItem,
+  QuestionOption,
+  QuestionRequest,
+  QuestionResponse,
+  QuestionResult,
+} from '@moonshot-ai/agent-core-v2/session/question/question';
+import type {
+  AgentMeta,
+  SessionMeta,
+  SessionMetadataChangedEvent,
+  SessionMetaPatch,
+} from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
+import type {
+  AuthStatus,
+  IOAuthService,
+} from '@moonshot-ai/agent-core-v2/app/auth/auth';
+import type { IBootstrapService } from '@moonshot-ai/agent-core-v2/app/bootstrap/bootstrap';
+import type {
+  ConfigDiagnostic,
+  ConfigInspectValue,
+  ConfigTarget,
+} from '@moonshot-ai/agent-core-v2/app/config/config';
+import type { ExperimentalFeatureState } from '@moonshot-ai/agent-core-v2/app/flag/flag';
+import type {
+  FsBrowseResponse,
+  FsHomeResponse,
+} from '@moonshot-ai/agent-core-v2/app/hostFolderBrowser/hostFolderBrowser';
+import type { ModelConfig } from '@moonshot-ai/agent-core-v2/app/model/model';
+import type {
+  IModelCatalogService,
+} from '@moonshot-ai/agent-core-v2/app/modelCatalog/modelCatalog';
+import type {
+  GetPluginInfoInput,
+  InstallPluginInput,
+  RemovePluginInput,
+  SetPluginEnabledInput,
+  SetPluginMcpServerEnabledInput,
+} from '@moonshot-ai/agent-core-v2/app/plugin/plugin';
+import type {
+  PluginCommandDef,
+  PluginDiagnostic,
+  PluginGithubMetadata,
+  PluginInfo,
+  PluginManifest,
+  PluginMcpServerInfo,
+  PluginSummary,
+  PluginUpdateStatus,
+  ReloadSummary,
+} from '@moonshot-ai/agent-core-v2/app/plugin/types';
+import type { ProviderConfig } from '@moonshot-ai/agent-core-v2/app/provider/provider';
+import type {
+  SessionListQuery,
+  SessionSummary,
+} from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
+import type {
+  Workspace,
+  WorkspaceUpdate,
+} from '@moonshot-ai/agent-core-v2/app/workspaceRegistry/workspaceRegistry';
+// Test-only: `@moonshot-ai/protocol` is a devDependency; importing its types
+// here (never in `src/`) strengthens parity for the agent event stream.
+import type {
+  AssistantDeltaEvent,
+  PromptAbortedEvent,
+  PromptCompletedEvent,
+  TaskInfo,
+  ThinkingDeltaEvent,
+  ToolCallStartedEvent,
+  ToolResultEvent,
+  TurnEndedEvent,
+  TurnStartedEvent,
+  WarningEvent,
+} from '@moonshot-ai/protocol';
+
+import {
+  activityLastTurnStateSchema,
+  activityRetryStateSchema,
+  activityTurnStateSchema,
+  activityViewLifecycleSchema,
+  agentActivityStateSchema,
+  approvalRefSchema,
+  backgroundRefSchema,
+  toolCallRefSchema,
+  turnEndReasonSchema,
+  turnPhaseSchema,
+} from '../src/contract/agent/activity.js';
+import {
+  agentContextDataSchema,
+  agentTaskInfoSchema,
+  cancelPayloadSchema,
+  cancelPlanPayloadSchema,
+  cancelShellCommandPayloadSchema,
+  emptyPayloadSchema,
+  getTaskOutputPayloadSchema,
+  getTasksPayloadSchema,
+  planDataSchema,
+  promptLaunchResultSchema,
+  promptPartSchema,
+  promptPayloadSchema,
+  runShellCommandPayloadSchema,
+  setModelPayloadSchema,
+  setModelResultSchema,
+  setPermissionPayloadSchema,
+  shellCommandResultSchema,
+  steerPayloadSchema,
+  stopTaskPayloadSchema,
+  tokenUsageSchema,
+  usageStatusSchema,
+} from '../src/contract/agent/rpc.js';
+import {
+  assistantDeltaEventSchema,
+  promptAbortedEventSchema,
+  promptCompletedEventSchema,
+  thinkingDeltaEventSchema,
+  toolCallStartedEventSchema,
+  toolResultEventSchema,
+  turnEndedEventSchema,
+  turnStartedEventSchema,
+  warningEventSchema,
+} from '../src/contract/agent/events.js';
+import {
+  approvalRequestSchema,
+  approvalResponseSchema,
+} from '../src/contract/session/approval.js';
+import {
+  createChildSessionOptionsSchema,
+  createSessionOptionsSchema,
+  forkSessionOptionsSchema,
+  handleWireSchema,
+} from '../src/contract/session/lifecycle.js';
+import {
+  interactionResolutionSchema,
+  interactionSchema,
+} from '../src/contract/session/interaction.js';
+import {
+  agentMetaSchema,
+  sessionMetaPatchSchema,
+  sessionMetaSchema,
+  sessionMetadataChangedEventSchema,
+} from '../src/contract/session/metadata.js';
+import {
+  questionAnswersSchema,
+  questionItemSchema,
+  questionOptionSchema,
+  questionRequestSchema,
+  questionResponseSchema,
+  questionResultSchema,
+} from '../src/contract/session/question.js';
+
+import {
+  authStatusSchema,
+  oAuthFlowSnapshotSchema,
+  oAuthFlowStartSchema,
+  oAuthLoginCancelResponseSchema,
+  oAuthLogoutResponseSchema,
+  refreshOAuthProviderModelsResponseSchema,
+} from '../src/contract/global/auth.js';
+import {
+  configDiagnosticSchema,
+  configInspectValueSchema,
+  configTargetSchema,
+} from '../src/contract/global/config.js';
+import {
+  modelCatalogItemSchema,
+  providerCatalogItemSchema,
+  refreshProviderModelsOptionsSchema,
+  refreshProviderModelsResponseSchema,
+  setDefaultModelResponseSchema,
+} from '../src/contract/global/catalog.js';
+import { experimentalFeatureStateSchema } from '../src/contract/global/flags.js';
+import {
+  fsBrowseResponseSchema,
+  fsHomeResponseSchema,
+} from '../src/contract/global/hostFs.js';
+import { modelConfigSchema } from '../src/contract/global/models.js';
+import {
+  getPluginInfoInputSchema,
+  installPluginInputSchema,
+  pluginCommandDefSchema,
+  pluginDiagnosticSchema,
+  pluginGithubMetadataSchema,
+  pluginInfoSchema,
+  pluginManifestSchema,
+  pluginMcpServerInfoSchema,
+  pluginSummarySchema,
+  pluginUpdateStatusSchema,
+  reloadSummarySchema,
+  removePluginInputSchema,
+  setPluginEnabledInputSchema,
+  setPluginMcpServerEnabledInputSchema,
+} from '../src/contract/global/plugins.js';
+import { providerConfigSchema } from '../src/contract/global/providers.js';
+import {
+  sessionListQuerySchema,
+  sessionSummarySchema,
+} from '../src/contract/global/sessions.js';
+import {
+  workspaceSchema,
+  workspaceUpdateSchema,
+} from '../src/contract/global/workspaces.js';
+
+import type { AssertWire, MutableDeep } from './helpers/typeAssert.js';
+
+/** One-directional: the engine type must be assignable TO the schema's infer. */
+type AssertEngineToWire<TSchema extends z.ZodType, TEngine> = [MutableDeep<TEngine>] extends [
+  z.infer<TSchema>,
+]
+  ? true
+  : never;
+
+/** One-directional: the schema's infer must be assignable TO the engine type. */
+type AssertWireToEngine<TSchema extends z.ZodType, TEngine> = [z.infer<TSchema>] extends [
+  MutableDeep<TEngine>,
+]
+  ? true
+  : never;
+
+// Protocol wire shapes, derived from the engine interfaces (no direct
+// `@moonshot-ai/protocol` dependency in klient).
+type OAuthFlowStart = Awaited<ReturnType<IOAuthService['startLogin']>>;
+type OAuthFlowSnapshot = NonNullable<ReturnType<IOAuthService['getFlow']>>;
+type OAuthLoginCancelResponse = Awaited<ReturnType<IOAuthService['cancelLogin']>>;
+type OAuthLogoutResponse = Awaited<ReturnType<IOAuthService['logout']>>;
+type RefreshOAuthProviderModelsResponse = Awaited<
+  ReturnType<IOAuthService['refreshOAuthProviderModels']>
+>;
+/** String-enum value union (`'user' | 'memory'`). */
+type ConfigTargetValues = `${ConfigTarget}`;
+
+// sessions.ts
+const _sessionSummary: AssertWire<typeof sessionSummarySchema, SessionSummary> = true;
+const _sessionListQuery: AssertWire<typeof sessionListQuerySchema, SessionListQuery> = true;
+
+// workspaces.ts
+const _workspace: AssertWire<typeof workspaceSchema, Workspace> = true;
+const _workspaceUpdate: AssertWire<typeof workspaceUpdateSchema, WorkspaceUpdate> = true;
+
+// config.ts
+// One-directional: the engine declares the `ConfigInspectValue` keys as
+// required with `| undefined` values, while the wire schema marks them
+// `.optional()`; optional → required is not assignable, so only the
+// engine → wire direction holds.
+const _configInspectValue: AssertEngineToWire<typeof configInspectValueSchema, ConfigInspectValue> =
+  true;
+const _configDiagnostic: AssertWire<typeof configDiagnosticSchema, ConfigDiagnostic> = true;
+const _configTarget: AssertWire<typeof configTargetSchema, ConfigTargetValues> = true;
+
+// providers.ts
+const _providerConfig: AssertWire<typeof providerConfigSchema, ProviderConfig> = true;
+
+// auth.ts
+const _oAuthFlowStart: AssertWire<typeof oAuthFlowStartSchema, OAuthFlowStart> = true;
+const _oAuthFlowSnapshot: AssertWire<typeof oAuthFlowSnapshotSchema, OAuthFlowSnapshot> = true;
+const _oAuthLoginCancelResponse: AssertWire<
+  typeof oAuthLoginCancelResponseSchema,
+  OAuthLoginCancelResponse
+> = true;
+const _oAuthLogoutResponse: AssertWire<typeof oAuthLogoutResponseSchema, OAuthLogoutResponse> =
+  true;
+const _authStatus: AssertWire<typeof authStatusSchema, AuthStatus> = true;
+const _refreshOAuthProviderModelsResponse: AssertWire<
+  typeof refreshOAuthProviderModelsResponseSchema,
+  RefreshOAuthProviderModelsResponse
+> = true;
+
+// flags.ts
+const _experimentalFeatureState: AssertWire<
+  typeof experimentalFeatureStateSchema,
+  ExperimentalFeatureState
+> = true;
+
+// hostFs.ts
+const _fsBrowseResponse: AssertWire<typeof fsBrowseResponseSchema, FsBrowseResponse> = true;
+const _fsHomeResponse: AssertWire<typeof fsHomeResponseSchema, FsHomeResponse> = true;
+
+// catalog.ts — protocol wire shapes derived through the catalog service interface.
+type ModelCatalogItem = Awaited<ReturnType<IModelCatalogService['listModels']>>[number];
+type ProviderCatalogItem = Awaited<ReturnType<IModelCatalogService['listProviders']>>[number];
+type SetDefaultModelResponse = Awaited<ReturnType<IModelCatalogService['setDefaultModel']>>;
+type RefreshProviderModelsOptions = NonNullable<
+  Parameters<IModelCatalogService['refreshProviderModels']>[0]
+>;
+type RefreshProviderModelsResponse = Awaited<
+  ReturnType<IModelCatalogService['refreshProviderModels']>
+>;
+const _modelCatalogItem: AssertWire<typeof modelCatalogItemSchema, ModelCatalogItem> = true;
+const _providerCatalogItem: AssertWire<typeof providerCatalogItemSchema, ProviderCatalogItem> =
+  true;
+const _setDefaultModelResponse: AssertWire<
+  typeof setDefaultModelResponseSchema,
+  SetDefaultModelResponse
+> = true;
+const _refreshProviderModelsOptions: AssertWire<
+  typeof refreshProviderModelsOptionsSchema,
+  RefreshProviderModelsOptions
+> = true;
+const _refreshProviderModelsResponse: AssertWire<
+  typeof refreshProviderModelsResponseSchema,
+  RefreshProviderModelsResponse
+> = true;
+
+// models.ts
+const _modelConfig: AssertWire<typeof modelConfigSchema, ModelConfig> = true;
+
+// plugins.ts
+const _pluginSummary: AssertWire<typeof pluginSummarySchema, PluginSummary> = true;
+const _pluginInfo: AssertWire<typeof pluginInfoSchema, PluginInfo> = true;
+const _pluginManifest: AssertWire<typeof pluginManifestSchema, PluginManifest> = true;
+const _pluginMcpServerInfo: AssertWire<typeof pluginMcpServerInfoSchema, PluginMcpServerInfo> =
+  true;
+const _pluginDiagnostic: AssertWire<typeof pluginDiagnosticSchema, PluginDiagnostic> = true;
+const _pluginGithubMetadata: AssertWire<typeof pluginGithubMetadataSchema, PluginGithubMetadata> =
+  true;
+const _reloadSummary: AssertWire<typeof reloadSummarySchema, ReloadSummary> = true;
+const _pluginUpdateStatus: AssertWire<typeof pluginUpdateStatusSchema, PluginUpdateStatus> = true;
+const _pluginCommandDef: AssertWire<typeof pluginCommandDefSchema, PluginCommandDef> = true;
+const _installPluginInput: AssertWire<typeof installPluginInputSchema, InstallPluginInput> = true;
+const _setPluginEnabledInput: AssertWire<
+  typeof setPluginEnabledInputSchema,
+  SetPluginEnabledInput
+> = true;
+const _setPluginMcpServerEnabledInput: AssertWire<
+  typeof setPluginMcpServerEnabledInputSchema,
+  SetPluginMcpServerEnabledInput
+> = true;
+const _removePluginInput: AssertWire<typeof removePluginInputSchema, RemovePluginInput> = true;
+const _getPluginInfoInput: AssertWire<typeof getPluginInfoInputSchema, GetPluginInfoInput> = true;
+
+// env.ts has no named schemas; `platform` narrows to `NodeJS.Platform` in the
+// engine — assert the bootstrap properties are all strings instead.
+type _bootstrapStringProps = AssertStringProps<
+  Pick<
+    IBootstrapService,
+    | 'platform'
+    | 'arch'
+    | 'cwd'
+    | 'osHomeDir'
+    | 'homeDir'
+    | 'configPath'
+    | 'clientVersion'
+    | 'sessionsDir'
+    | 'blobsDir'
+    | 'storeDir'
+    | 'cacheDir'
+    | 'logsDir'
+  >
+>;
+type AssertStringProps<T> = T extends Record<string, string> ? true : never;
+const _envProps: _bootstrapStringProps = true;
+
+// ── session scope ───────────────────────────────────────────────────────────
+
+// session/metadata.ts
+const _sessionMeta: AssertWire<typeof sessionMetaSchema, SessionMeta> = true;
+const _agentMeta: AssertWire<typeof agentMetaSchema, AgentMeta> = true;
+const _sessionMetaPatch: AssertWire<typeof sessionMetaPatchSchema, SessionMetaPatch> = true;
+const _sessionMetadataChangedEvent: AssertWire<
+  typeof sessionMetadataChangedEventSchema,
+  SessionMetadataChangedEvent
+> = true;
+
+// session/lifecycle.ts
+const _createSessionOptions: AssertWire<typeof createSessionOptionsSchema, CreateSessionOptions> =
+  true;
+const _forkSessionOptions: AssertWire<typeof forkSessionOptionsSchema, ForkSessionOptions> = true;
+const _createChildSessionOptions: AssertWire<
+  typeof createChildSessionOptionsSchema,
+  CreateChildSessionOptions
+> = true;
+// One-directional: the wire handle is `z.looseObject` — the in-process
+// `ISessionScopeHandle` carries an `accessor` and `dispose()` that JSON
+// drops, so only the engine → wire direction holds.
+const _handleWire: AssertEngineToWire<typeof handleWireSchema, ISessionScopeHandle> = true;
+
+// session/interaction.ts
+const _interaction: AssertWire<typeof interactionSchema, Interaction> = true;
+const _interactionResolution: AssertWire<
+  typeof interactionResolutionSchema,
+  InteractionResolution
+> = true;
+
+// session/approval.ts
+// One-directional: `display` is the protocol `ToolInputDisplay` union (huge)
+// and crosses the wire as `unknown`; the wire schema cannot be assignable
+// back to the engine type.
+const _approvalRequest: AssertEngineToWire<typeof approvalRequestSchema, ApprovalRequest> = true;
+const _approvalResponse: AssertWire<typeof approvalResponseSchema, ApprovalResponse> = true;
+
+// session/question.ts
+const _questionRequest: AssertWire<typeof questionRequestSchema, QuestionRequest> = true;
+const _questionItem: AssertWire<typeof questionItemSchema, QuestionItem> = true;
+const _questionOption: AssertWire<typeof questionOptionSchema, QuestionOption> = true;
+const _questionAnswers: AssertWire<typeof questionAnswersSchema, QuestionAnswers> = true;
+const _questionResponse: AssertWire<typeof questionResponseSchema, QuestionResponse> = true;
+const _questionResult: AssertWire<typeof questionResultSchema, QuestionResult> = true;
+
+// agent/activity.ts
+const _turnPhase: AssertWire<typeof turnPhaseSchema, TurnPhase> = true;
+const _approvalRef: AssertWire<typeof approvalRefSchema, ApprovalRef> = true;
+const _toolCallRef: AssertWire<typeof toolCallRefSchema, ToolCallRef> = true;
+const _activityRetryState: AssertWire<typeof activityRetryStateSchema, ActivityRetryState> = true;
+// One-directional: `origin` is the deep `PromptOrigin` union mirrored as
+// `unknown`; the wire schema cannot be assignable back to the engine type.
+const _activityTurnState: AssertEngineToWire<typeof activityTurnStateSchema, ActivityTurnState> =
+  true;
+const _turnEndReason: AssertWire<typeof turnEndReasonSchema, TurnEndReason> = true;
+const _activityLastTurnState: AssertWire<
+  typeof activityLastTurnStateSchema,
+  ActivityLastTurnState
+> = true;
+const _backgroundRef: AssertWire<typeof backgroundRefSchema, BackgroundRef> = true;
+const _activityViewLifecycle: AssertWire<typeof activityViewLifecycleSchema, ActivityViewLifecycle> =
+  true;
+const _agentActivityState: AssertEngineToWire<typeof agentActivityStateSchema, AgentActivityState> =
+  true;
+
+// ── agent scope (rpc.ts) ────────────────────────────────────────────────────
+// Payload/result types are reached through the `AgentAPI` interface so the
+// assertions track the exact methods the contract mirrors.
+type PromptPayload = Parameters<AgentAPI['prompt']>[0];
+type PromptLaunchResult = NonNullable<ReturnType<AgentAPI['prompt']>>;
+type SteerPayload = Parameters<AgentAPI['steer']>[0];
+type CancelPayload = Parameters<AgentAPI['cancel']>[0];
+type RunShellCommandPayload = Parameters<AgentAPI['runShellCommand']>[0];
+type ShellCommandResult = ReturnType<AgentAPI['runShellCommand']>;
+type CancelShellCommandPayload = Parameters<AgentAPI['cancelShellCommand']>[0];
+type SetModelPayload = Parameters<AgentAPI['setModel']>[0];
+type SetModelResult = ReturnType<AgentAPI['setModel']>;
+type SetPermissionPayload = Parameters<AgentAPI['setPermission']>[0];
+type UsageStatus = ReturnType<AgentAPI['getUsage']>;
+type TokenUsage = NonNullable<UsageStatus['total']>;
+type GetTasksPayload = Parameters<AgentAPI['getTasks']>[0];
+type StopTaskPayload = Parameters<AgentAPI['stopTask']>[0];
+type GetTaskOutputPayload = Parameters<AgentAPI['getTaskOutput']>[0];
+type CancelPlanPayload = Parameters<AgentAPI['cancelPlan']>[0];
+type EmptyPayload = Parameters<AgentAPI['getModel']>[0];
+
+const _emptyPayload: AssertWire<typeof emptyPayloadSchema, EmptyPayload> = true;
+const _promptPart: AssertWire<typeof promptPartSchema, PromptPart> = true;
+// One-directional (wire → engine): the engine's `PromptPayload.input` accepts
+// the full `ContentPart` union (also think/audio parts); the wire mirrors the
+// `PromptPart` subset clients may send, so the reverse direction fails.
+const _promptPayload: AssertWireToEngine<typeof promptPayloadSchema, PromptPayload> = true;
+const _steerPayload: AssertWireToEngine<typeof steerPayloadSchema, SteerPayload> = true;
+const _promptLaunchResult: AssertWire<typeof promptLaunchResultSchema, PromptLaunchResult> = true;
+const _cancelPayload: AssertWire<typeof cancelPayloadSchema, CancelPayload> = true;
+const _runShellCommandPayload: AssertWire<
+  typeof runShellCommandPayloadSchema,
+  RunShellCommandPayload
+> = true;
+const _shellCommandResult: AssertWire<typeof shellCommandResultSchema, ShellCommandResult> = true;
+const _cancelShellCommandPayload: AssertWire<
+  typeof cancelShellCommandPayloadSchema,
+  CancelShellCommandPayload
+> = true;
+const _setModelPayload: AssertWire<typeof setModelPayloadSchema, SetModelPayload> = true;
+const _setModelResult: AssertWire<typeof setModelResultSchema, SetModelResult> = true;
+const _setPermissionPayload: AssertWire<typeof setPermissionPayloadSchema, SetPermissionPayload> =
+  true;
+const _tokenUsage: AssertWire<typeof tokenUsageSchema, TokenUsage> = true;
+const _usageStatus: AssertWire<typeof usageStatusSchema, UsageStatus> = true;
+// One-directional: `history` entries are full `ContextMessage`s (deep
+// `Message`/`Tool`/`PromptOrigin` unions) mirrored as `unknown`.
+const _agentContextData: AssertEngineToWire<typeof agentContextDataSchema, AgentContextData> = true;
+const _planData: AssertWire<typeof planDataSchema, PlanData> = true;
+const _cancelPlanPayload: AssertWire<typeof cancelPlanPayloadSchema, CancelPlanPayload> = true;
+const _getTasksPayload: AssertWire<typeof getTasksPayloadSchema, GetTasksPayload> = true;
+// The wire task union mirrors the protocol `TaskInfo`; the engine's
+// declaration-merged `AgentTaskInfo` is structurally identical but depends on
+// tool-module augmentation, so parity is pinned to the protocol type.
+const _agentTaskInfo: AssertWire<typeof agentTaskInfoSchema, TaskInfo> = true;
+const _stopTaskPayload: AssertWire<typeof stopTaskPayloadSchema, StopTaskPayload> = true;
+const _getTaskOutputPayload: AssertWire<typeof getTaskOutputPayloadSchema, GetTaskOutputPayload> =
+  true;
+
+// ── agent scope (events.ts) ─────────────────────────────────────────────────
+// Parity against the protocol event types (the stream carries flat
+// `{ type, ... }` events; schemas keep the `type` literal). One-directional
+// where a field is mirrored as `unknown`.
+const _turnStartedEvent: AssertEngineToWire<typeof turnStartedEventSchema, TurnStartedEvent> = true;
+const _turnEndedEvent: AssertEngineToWire<typeof turnEndedEventSchema, TurnEndedEvent> = true;
+const _assistantDeltaEvent: AssertWire<typeof assistantDeltaEventSchema, AssistantDeltaEvent> =
+  true;
+const _thinkingDeltaEvent: AssertWire<typeof thinkingDeltaEventSchema, ThinkingDeltaEvent> = true;
+const _toolCallStartedEvent: AssertEngineToWire<
+  typeof toolCallStartedEventSchema,
+  ToolCallStartedEvent
+> = true;
+const _toolResultEvent: AssertWire<typeof toolResultEventSchema, ToolResultEvent> = true;
+const _promptCompletedEvent: AssertWire<typeof promptCompletedEventSchema, PromptCompletedEvent> =
+  true;
+const _promptAbortedEvent: AssertWire<typeof promptAbortedEventSchema, PromptAbortedEvent> = true;
+const _warningEvent: AssertWire<typeof warningEventSchema, WarningEvent> = true;
+// No parity assertions for `errorEventSchema`, `permissionApproval*Schema`,
+// and `agentStatusUpdatedEventSchema`: they are deliberately `z.looseObject`s
+// (index signature breaks both-ways assignability) — `permission.approval.*`
+// is not part of the protocol event union at all.
diff --git a/packages/klient/test/e2e/dual/01-prompt.test.ts b/packages/klient/test/e2e/dual/01-prompt.test.ts
new file mode 100644
index 000000000..8ddc3e3b9
--- /dev/null
+++ b/packages/klient/test/e2e/dual/01-prompt.test.ts
@@ -0,0 +1,38 @@
+/**
+ * Dual-backend rewrite of scenario `01-create-and-send`: create a session,
+ * run one prompt to completion, and assert the assistant replied — driven
+ * entirely through the klient facade + agent events, on both backends.
+ */
+import { expect, it } from 'vitest';
+
+import { DUAL_MODEL_ID, defineDualSuite, onceEvent } from '../../helpers/dual.js';
+
+defineDualSuite('prompt round-trip', { requiresModel: true }, ({ klient }) => {
+  it(
+    'creates a session, runs a prompt, and accumulates the assistant reply',
+    async () => {
+      const k = klient();
+      const session = await k.global.sessions.create({ workDir: process.cwd() });
+      const handle = k.session(session.id);
+      const agent = handle.agent('main');
+      await agent.setModel(DUAL_MODEL_ID);
+
+      const deltas: string[] = [];
+      agent.events.on('assistant.delta', (event) => {
+        deltas.push(event.delta);
+      });
+      const completed = onceEvent(agent.events, 'prompt.completed', 120_000);
+      const launched = await agent.prompt({
+        input: [{ type: 'text', text: 'Reply with the single word "OK" and nothing else.' }],
+      });
+      expect(launched).toBeTruthy();
+
+      await completed;
+      expect(deltas.join('')).toContain('OK');
+
+      await handle.archive();
+      expect((await k.global.sessions.get(session.id))?.archived).toBe(true);
+    },
+    180_000,
+  );
+});
diff --git a/packages/klient/test/e2e/dual/02-approval.test.ts b/packages/klient/test/e2e/dual/02-approval.test.ts
new file mode 100644
index 000000000..17d3e20e2
--- /dev/null
+++ b/packages/klient/test/e2e/dual/02-approval.test.ts
@@ -0,0 +1,56 @@
+/**
+ * Dual-backend rewrite of scenario `02-tool-call-with-approval`: a Bash tool
+ * call blocks on a manual approval; the client lists and approves it through
+ * the session facade, and the turn completes with the canary in the output.
+ */
+import { expect, it } from 'vitest';
+
+import { DUAL_MODEL_ID, defineDualSuite, onceEvent } from '../../helpers/dual.js';
+
+defineDualSuite('tool call approval', { requiresModel: true }, ({ klient }) => {
+  it(
+    'approval requested → listed → approved → prompt completes',
+    async () => {
+      const k = klient();
+      const canary = `DUAL_APPROVAL_${process.pid}_${Date.now()}`;
+      const session = await k.global.sessions.create({ workDir: process.cwd() });
+      const handle = k.session(session.id);
+      const agent = handle.agent('main');
+      await agent.setModel(DUAL_MODEL_ID);
+      await agent.setPermission('manual');
+
+      const outputs: string[] = [];
+      agent.events.on('tool.result', (event) => {
+        outputs.push(JSON.stringify(event.output));
+      });
+      const approvalRequested = onceEvent(agent.events, 'permission.approval.requested', 180_000);
+      const completed = onceEvent(agent.events, 'prompt.completed', 240_000);
+
+      await agent.prompt({
+        input: [
+          {
+            type: 'text',
+            text: `Use the Bash tool to run \`echo ${canary}\` and then report the output back.`,
+          },
+        ],
+      });
+
+      const requested = await approvalRequested;
+      expect(requested.toolName.length).toBeGreaterThan(0);
+
+      const pending = await handle.approvals.list();
+      expect(pending.length).toBeGreaterThan(0);
+      const target = pending[0]!;
+      await handle.approvals.decide(target.id ?? target.toolCallId ?? '', {
+        decision: 'approved',
+      });
+      expect(await handle.approvals.list()).toHaveLength(0);
+
+      await completed;
+      expect(outputs.join('\n')).toContain(canary);
+
+      await handle.archive();
+    },
+    300_000,
+  );
+});
diff --git a/packages/klient/test/e2e/dual/05-workspace.test.ts b/packages/klient/test/e2e/dual/05-workspace.test.ts
new file mode 100644
index 000000000..534362255
--- /dev/null
+++ b/packages/klient/test/e2e/dual/05-workspace.test.ts
@@ -0,0 +1,42 @@
+/**
+ * Dual-backend rewrite of scenario `05-workspace`: workspace registration,
+ * session creation rooted at the workspace, index linkage, and delete
+ * semantics — all through the global facade. No model required.
+ */
+import { mkdtemp, realpath, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { expect, it } from 'vitest';
+
+import { defineDualSuite } from '../../helpers/dual.js';
+
+defineDualSuite('workspace', {}, ({ klient }) => {
+  it('workspace + session lifecycle', async () => {
+    const k = klient();
+    const root = await realpath(await mkdtemp(join(tmpdir(), 'klient-dual-ws-')));
+    try {
+      const ws = await k.global.workspaces.createOrTouch({ root, name: 'dual-workspace' });
+      expect(ws.id.length).toBeGreaterThan(0);
+      expect(ws.name).toBe('dual-workspace');
+
+      const got = await k.global.workspaces.get(ws.id);
+      expect(got?.root).toBe(ws.root);
+
+      const session = await k.global.sessions.create({ workDir: ws.root });
+      expect(session.cwd).toBe(ws.root);
+
+      const listed = await k.global.sessions.list({ workspaceId: ws.id });
+      expect(listed.items.some((s) => s.id === session.id)).toBe(true);
+
+      await k.global.workspaces.delete(ws.id);
+      expect((await k.global.workspaces.list()).some((w) => w.id === ws.id)).toBe(false);
+
+      // Deleting the workspace does not delete the session.
+      expect((await k.session(session.id).get()).id).toBe(session.id);
+      await k.session(session.id).archive();
+    } finally {
+      await rm(root, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+    }
+  }, 30_000);
+});
diff --git a/packages/klient/test/e2e/dual/06-catalog.test.ts b/packages/klient/test/e2e/dual/06-catalog.test.ts
new file mode 100644
index 000000000..d8f9d8365
--- /dev/null
+++ b/packages/klient/test/e2e/dual/06-catalog.test.ts
@@ -0,0 +1,31 @@
+/**
+ * Dual-backend rewrite of scenario `06-model-catalog`: catalog and auth read
+ * models respond, a provider round-trips by id, and setting the default
+ * model echoes it back. No live model calls required.
+ */
+import { expect, it } from 'vitest';
+
+import { defineDualSuite } from '../../helpers/dual.js';
+
+defineDualSuite('model catalog', {}, ({ klient }) => {
+  it('catalog + auth read models respond', async () => {
+    const k = klient();
+
+    const models = await k.global.catalog.listModels();
+    const providers = await k.global.catalog.listProviders();
+    expect(Array.isArray(models)).toBe(true);
+    expect(Array.isArray(providers)).toBe(true);
+
+    if (providers.length > 0) {
+      const provider = await k.global.catalog.getProvider(providers[0]!.id);
+      expect(provider.id).toBe(providers[0]!.id);
+    }
+
+    expect(Array.isArray(await k.global.auth.summarize())).toBe(true);
+
+    if (models.length > 0) {
+      const result = await k.global.catalog.setDefaultModel(models[0]!.model);
+      expect(result.default_model).toBe(models[0]!.model);
+    }
+  }, 60_000);
+});
diff --git a/packages/klient/test/e2e/dual/07-children.test.ts b/packages/klient/test/e2e/dual/07-children.test.ts
new file mode 100644
index 000000000..cfd0b9b2f
--- /dev/null
+++ b/packages/klient/test/e2e/dual/07-children.test.ts
@@ -0,0 +1,38 @@
+/**
+ * Dual-backend rewrite of scenario `07-session-children`: child/grandchild
+ * creation markers and direct-children listing semantics, via the session
+ * facade's `createChild` and the session index's `childOf` query.
+ */
+import { expect, it } from 'vitest';
+
+import { defineDualSuite } from '../../helpers/dual.js';
+
+defineDualSuite('session children', {}, ({ klient }) => {
+  it('child markers, listing semantics, and missing-parent handling', async () => {
+    const k = klient();
+    const parent = await k.global.sessions.create({
+      workDir: process.cwd(),
+      title: 'dual-parent',
+    });
+
+    const child = await k.session(parent.id).createChild({ title: 'dual-child' });
+    expect(child.custom?.['parent_session_id']).toBe(parent.id);
+    expect(child.custom?.['child_session_kind']).toBe('child');
+
+    const grandchild = await k.session(child.id).createChild({ title: 'dual-grandchild' });
+
+    const parentChildren = await k.global.sessions.list({ childOf: parent.id });
+    expect(parentChildren.items.some((s) => s.id === child.id)).toBe(true);
+    expect(parentChildren.items.some((s) => s.id === grandchild.id)).toBe(false);
+
+    const childChildren = await k.global.sessions.list({ childOf: child.id });
+    expect(childChildren.items.some((s) => s.id === grandchild.id)).toBe(true);
+
+    const missing = await k.global.sessions.list({ childOf: 'sess_missing_dual_children' });
+    expect(missing.items).toEqual([]);
+
+    await k.session(grandchild.id).archive();
+    await k.session(child.id).archive();
+    await k.session(parent.id).archive();
+  }, 30_000);
+});
diff --git a/packages/klient/test/e2e/dual/08-pending.test.ts b/packages/klient/test/e2e/dual/08-pending.test.ts
new file mode 100644
index 000000000..7d295e854
--- /dev/null
+++ b/packages/klient/test/e2e/dual/08-pending.test.ts
@@ -0,0 +1,63 @@
+/**
+ * Dual-backend rewrite of scenario `08-pending-recovery`: pending approval
+ * and question interactions are listed and resolved through the session
+ * facade, letting the blocked prompts run to completion.
+ */
+import { expect, it } from 'vitest';
+
+import { DUAL_MODEL_ID, defineDualSuite, onceEvent, waitFor } from '../../helpers/dual.js';
+
+defineDualSuite('pending interaction recovery', { requiresModel: true }, ({ klient }) => {
+  it(
+    'approval pending → approve → completes; question pending → answer → completes',
+    async () => {
+      const k = klient();
+      const canary = `DUAL_PENDING_${process.pid}_${Date.now()}`;
+      const session = await k.global.sessions.create({ workDir: process.cwd() });
+      const handle = k.session(session.id);
+      const agent = handle.agent('main');
+      await agent.setModel(DUAL_MODEL_ID);
+      await agent.setPermission('manual');
+
+      // --- approval recovery ---
+      let completed = onceEvent(agent.events, 'prompt.completed', 240_000);
+      await agent.prompt({
+        input: [
+          { type: 'text', text: `Use the Bash tool to run \`echo ${canary}\` and report the output.` },
+        ],
+      });
+      await waitFor(() => handle.approvals.list().then((l) => l.length > 0), 180_000);
+      const approval = (await handle.approvals.list())[0]!;
+      await handle.approvals.decide(approval.id ?? approval.toolCallId ?? '', {
+        decision: 'approved',
+      });
+      expect(await handle.approvals.list()).toHaveLength(0);
+      await completed;
+
+      // --- question recovery ---
+      completed = onceEvent(agent.events, 'prompt.completed', 240_000);
+      await agent.prompt({
+        input: [
+          {
+            type: 'text',
+            text:
+              'Call the AskUserQuestion tool exactly once with one question ("Pick one") ' +
+              'and exactly two options ("Alpha", "Beta"), then stop and wait for the answer.',
+          },
+        ],
+      });
+      await waitFor(() => handle.questions.list().then((l) => l.length > 0), 180_000);
+      const question = (await handle.questions.list())[0]!;
+      const item = question.questions[0]!;
+      const firstLabel = item.options[0]!.label;
+      await handle.questions.answer(question.id ?? question.toolCallId ?? '', {
+        [item.question]: firstLabel,
+      });
+      expect(await handle.questions.list()).toHaveLength(0);
+      await completed;
+
+      await handle.archive();
+    },
+    480_000,
+  );
+});
diff --git a/packages/server-e2e/src/client.ts b/packages/klient/test/e2e/harness/client.ts
similarity index 98%
rename from packages/server-e2e/src/client.ts
rename to packages/klient/test/e2e/harness/client.ts
index 13fcb72c2..251a6025a 100644
--- a/packages/server-e2e/src/client.ts
+++ b/packages/klient/test/e2e/harness/client.ts
@@ -7,7 +7,7 @@
  *   - WS `server_hello` → `client_hello` → ack handshake
  *   - `subscribe` / `unsubscribe` ack correlation
  *   - Approval + question reverse-RPC auto-resolve via per-event handlers
- *   - `waitForFrame` / `waitForSessionStatus` convenience waits
+ *   - `waitForFrame` / `waitForSessionBusy` convenience waits
  *
  * **What it is NOT**: a server bootstrap helper. Connect to a server process
  * that's already running at `baseUrl` (default `http://127.0.0.1:58627`).
@@ -48,7 +48,6 @@ import type {
   Session,
   SessionChildCreate,
   SessionCreate,
-  SessionStatus,
   SessionUpdate,
   Terminal,
   UndoSessionRequest,
@@ -62,7 +61,7 @@ import { WebSocket as WsWebSocket } from 'ws';
 
 import { HttpClient } from './http.js';
 import { installReverseRpcHandler } from './reverse-rpc.js';
-import { DEFAULT_FRAME_TIMEOUT_MS, waitForSessionStatus } from './wait.js';
+import { DEFAULT_FRAME_TIMEOUT_MS, waitForSessionBusy } from './wait.js';
 import { type AnyFrame, WsClient } from './ws.js';
 
 export interface DaemonClientOptions {
@@ -242,7 +241,7 @@ export class DaemonClient {
   }
   listChildren(
     sid: string,
-    query?: { page_size?: number; before_id?: string; after_id?: string; status?: Session['status'] },
+    query?: { page_size?: number; before_id?: string; after_id?: string; busy?: boolean },
   ): Promise<{ items: Session[]; has_more: boolean }> {
     return this.http.listChildren(sid, query);
   }
@@ -472,13 +471,13 @@ export class DaemonClient {
     );
   }
 
-  /** Poll `/sessions/{sid}` until it reaches `status`. */
-  waitForSessionStatus(
+  /** Poll `/sessions/{sid}` until its aggregate work flag reaches `busy`. */
+  waitForSessionBusy(
     sid: string,
-    status: SessionStatus,
+    busy: boolean,
     opts?: { timeoutMs?: number; pollMs?: number },
   ): Promise<Session> {
-    return waitForSessionStatus(this.http, sid, status, opts);
+    return waitForSessionBusy(this.http, sid, busy, opts);
   }
 
   // ── Terminal WS controls ───────────────────────────────────────────────
diff --git a/packages/server-e2e/src/envelope.ts b/packages/klient/test/e2e/harness/envelope.ts
similarity index 100%
rename from packages/server-e2e/src/envelope.ts
rename to packages/klient/test/e2e/harness/envelope.ts
diff --git a/packages/server-e2e/src/http.ts b/packages/klient/test/e2e/harness/http.ts
similarity index 99%
rename from packages/server-e2e/src/http.ts
rename to packages/klient/test/e2e/harness/http.ts
index 458456cd4..f31e307eb 100644
--- a/packages/server-e2e/src/http.ts
+++ b/packages/klient/test/e2e/harness/http.ts
@@ -252,7 +252,7 @@ export class HttpClient {
   }
   listChildren(
     sid: string,
-    query?: { page_size?: number; before_id?: string; after_id?: string; status?: Session['status'] },
+    query?: { page_size?: number; before_id?: string; after_id?: string; busy?: boolean },
   ): Promise<{ items: Session[]; has_more: boolean }> {
     return this.request(
       'GET',
diff --git a/packages/server-e2e/src/index.ts b/packages/klient/test/e2e/harness/index.ts
similarity index 92%
rename from packages/server-e2e/src/index.ts
rename to packages/klient/test/e2e/harness/index.ts
index 0d111b80a..30ddb9178 100644
--- a/packages/server-e2e/src/index.ts
+++ b/packages/klient/test/e2e/harness/index.ts
@@ -12,7 +12,7 @@
  *   - `EnvelopeError`          — thrown on `code !== 0`
  *   - `fetchWithReport` / `writeHtmlReport` — report capture + rendering
  *   - `installReverseRpcHandler` — uniform helper for approval/question
- *   - `waitForFrame` / `waitForSessionStatus` — standalone wait helpers
+ *   - `waitForFrame` / `waitForSessionBusy` — standalone wait helpers
  *
  * Re-exports `@moonshot-ai/protocol` types are NOT bundled here — scenarios
  * that want them import from `@moonshot-ai/protocol` directly.
@@ -66,10 +66,9 @@ export type {
 export { installReverseRpcHandler } from './reverse-rpc.js';
 export type { ReverseRpcOptions } from './reverse-rpc.js';
 
-export { DEFAULT_FRAME_TIMEOUT_MS, waitForFrame, waitForSessionStatus } from './wait.js';
+export { DEFAULT_FRAME_TIMEOUT_MS, waitForFrame, waitForSessionBusy } from './wait.js';
 
 // ── server-v2 SDK (additive) ──────────────────────────────────────────────
 // A lark-style typed client for the `/api/v2` RPC + WS surface. Re-exported
 // here so consumers can `import { ServerClient } from '@moonshot-ai/server-e2e'`
 // alongside the legacy `DaemonClient`. Names are disjoint from the v1 surface.
-export * from './v2/index.js';
diff --git a/packages/server-e2e/src/report.ts b/packages/klient/test/e2e/harness/report.ts
similarity index 100%
rename from packages/server-e2e/src/report.ts
rename to packages/klient/test/e2e/harness/report.ts
diff --git a/packages/server-e2e/src/reverse-rpc.ts b/packages/klient/test/e2e/harness/reverse-rpc.ts
similarity index 100%
rename from packages/server-e2e/src/reverse-rpc.ts
rename to packages/klient/test/e2e/harness/reverse-rpc.ts
diff --git a/packages/server-e2e/src/wait.ts b/packages/klient/test/e2e/harness/wait.ts
similarity index 71%
rename from packages/server-e2e/src/wait.ts
rename to packages/klient/test/e2e/harness/wait.ts
index 8e4042711..e70cadb7a 100644
--- a/packages/server-e2e/src/wait.ts
+++ b/packages/klient/test/e2e/harness/wait.ts
@@ -3,7 +3,7 @@
  * `HttpClient.getSession`. Kept separate from `client.ts` so scenarios can
  * import them directly without dragging the whole `DaemonClient` class.
  */
-import type { Session, SessionStatus } from '@moonshot-ai/protocol';
+import type { Session } from '@moonshot-ai/protocol';
 
 import type { HttpClient } from './http.js';
 import type { AnyFrame, WsClient } from './ws.js';
@@ -24,15 +24,15 @@ export function waitForFrame(
 }
 
 /**
- * Poll `GET /sessions/{sid}` until `status` matches. Useful as a final
- * synchronization point — the server's `turn.ended` arrives before the
- * session row flips to `idle`, so scenarios that want a quiescent session
- * must poll.
+ * Poll `GET /sessions/{sid}` until aggregate `busy` matches. Useful as a
+ * final synchronization point — the server's `turn.ended` arrives before
+ * the session work projection flips to false, so scenarios that want a
+ * quiescent session must poll.
  */
-export async function waitForSessionStatus(
+export async function waitForSessionBusy(
   http: HttpClient,
   sid: string,
-  status: SessionStatus,
+  busy: boolean,
   opts?: { timeoutMs?: number; pollMs?: number },
 ): Promise<Session> {
   const timeoutMs = opts?.timeoutMs ?? DEFAULT_FRAME_TIMEOUT_MS;
@@ -42,12 +42,12 @@ export async function waitForSessionStatus(
   while (Date.now() < deadline) {
     const session = await http.getSession(sid);
     last = session;
-    if (session.status === status) return session;
+    if (session.busy === busy) return session;
     await sleep(pollMs);
   }
   throw new Error(
-    `session ${sid} did not reach status="${status}" within ${timeoutMs}ms ` +
-      `(last status="${last?.status ?? 'unknown'}")`,
+    `session ${sid} did not reach busy=${busy} within ${timeoutMs}ms ` +
+      `(last busy=${last?.busy ?? 'unknown'})`,
   );
 }
 
diff --git a/packages/server-e2e/src/ws.ts b/packages/klient/test/e2e/harness/ws.ts
similarity index 100%
rename from packages/server-e2e/src/ws.ts
rename to packages/klient/test/e2e/harness/ws.ts
diff --git a/packages/server-e2e/test/client.test.ts b/packages/klient/test/e2e/legacy/client.test.ts
similarity index 98%
rename from packages/server-e2e/test/client.test.ts
rename to packages/klient/test/e2e/legacy/client.test.ts
index feef159b4..7792d42bc 100644
--- a/packages/server-e2e/test/client.test.ts
+++ b/packages/klient/test/e2e/legacy/client.test.ts
@@ -25,8 +25,8 @@ import {
   type SessionStatusResponse,
 } from '@moonshot-ai/protocol';
 
-import { DaemonClient, EnvelopeError } from '../src/index.js';
-import { fetchWithReport } from '../src/report.js';
+import { DaemonClient, EnvelopeError } from '../harness/index.js';
+import { fetchWithReport } from '../harness/report.js';
 import { createCaseLogger, errorForLog } from './log.js';
 
 const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
@@ -496,7 +496,7 @@ describe('DaemonClient session action helpers', () => {
       }),
     ).resolves.toEqual(child);
     await expect(
-      client.listChildren('sess_parent', { page_size: 5, status: 'idle' }),
+      client.listChildren('sess_parent', { page_size: 5, busy: false }),
     ).resolves.toEqual({ items: [child], has_more: false });
     await expect(client.listPendingApprovals('sess_parent')).resolves.toEqual({ items: [] });
     await expect(client.listPendingQuestions('sess_parent')).resolves.toEqual({ items: [] });
@@ -508,7 +508,7 @@ describe('DaemonClient session action helpers', () => {
     log('fetch calls', calls);
     expect(calls.map((call) => [call.init.method, call.url])).toEqual([
       ['POST', 'http://server.example.test/api/v1/sessions/sess_parent/children'],
-      ['GET', 'http://server.example.test/api/v1/sessions/sess_parent/children?page_size=5&status=idle'],
+      ['GET', 'http://server.example.test/api/v1/sessions/sess_parent/children?page_size=5&busy=false'],
       ['GET', 'http://server.example.test/api/v1/sessions/sess_parent/approvals?status=pending'],
       ['GET', 'http://server.example.test/api/v1/sessions/sess_parent/questions?status=pending'],
       ['POST', 'http://server.example.test/api/v1/sessions/sess_parent/questions/question_1:dismiss'],
@@ -635,7 +635,7 @@ function testSession(overrides: Partial<Session> = {}): Session {
     title: 'Example session',
     created_at: '2026-06-09T00:00:00.000Z',
     updated_at: '2026-06-09T00:00:00.000Z',
-    status: 'idle',
+    busy: false,
     metadata: { cwd: '/tmp/example-server-e2e' },
     agent_config: { model: '' },
     usage: {
@@ -706,7 +706,7 @@ function testMessage(overrides: Partial<Message> = {}): Message {
 
 function testSessionStatus(): SessionStatusResponse {
   return {
-    status: 'idle',
+    busy: false,
     model: 'kimi-code/kimi-for-coding',
     thinking_level: 'off',
     permission: 'manual',
diff --git a/packages/klient/test/e2e/legacy/image-file-prompts.test.ts b/packages/klient/test/e2e/legacy/image-file-prompts.test.ts
new file mode 100644
index 000000000..71b8a2da2
--- /dev/null
+++ b/packages/klient/test/e2e/legacy/image-file-prompts.test.ts
@@ -0,0 +1,147 @@
+/**
+ * Live-server invariant for uploaded image files in prompt content (v1 REST
+ * surface only — file upload has no `/api/v2` equivalent):
+ *   - a missing prompt image `file_id` returns `FILE_NOT_FOUND`;
+ *   - a non-image uploaded file used as image content returns `VALIDATION_FAILED`;
+ *   - an uploaded PNG can be referenced by a prompt submission, and the
+ *     prompt can be aborted (or was already terminal).
+ *
+ * Converted from the retired scenario `09-image-file-prompts.ts`. Skips when
+ * no server is reachable at `KIMI_SERVER_URL`.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { ErrorCode } from '@moonshot-ai/protocol';
+
+import { DaemonClient, EnvelopeError } from '../harness/index.js';
+import { fetchWithReport } from '../harness/report.js';
+import { createCaseLogger } from './log.js';
+
+const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
+const API_PREFIX = '/api/v1';
+const SHORT_TIMEOUT_MS = 15_000;
+
+const ONE_BY_ONE_PNG = Buffer.from(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=',
+  'base64',
+);
+
+async function daemonReachable(): Promise<boolean> {
+  try {
+    const res = await fetchWithReport(`${BASE_URL}${API_PREFIX}/meta`, {
+      signal: AbortSignal.timeout(500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+const reachable = await daemonReachable();
+const describeLive = reachable ? describe : describe.skip;
+
+describeLive('legacy: image file prompts', () => {
+  it('missing/non-image files rejected, PNG accepted, prompt abortable', async () => {
+    const log = createCaseLogger('legacy: image file prompts');
+    const client = new DaemonClient({ baseUrl: BASE_URL });
+    const files: string[] = [];
+    let sid: string | undefined;
+
+    async function expectEnvelopeCode(
+      action: () => Promise<unknown>,
+      code: ErrorCode,
+      label: string,
+    ): Promise<void> {
+      let caught: unknown;
+      try {
+        await action();
+      } catch (error) {
+        caught = error;
+      }
+      expect(caught, label).toBeInstanceOf(EnvelopeError);
+      expect((caught as EnvelopeError).code, label).toBe(code);
+      log(label, { code: (caught as EnvelopeError).code });
+    }
+
+    try {
+      const session = await client.createSession({
+        title: 'klient-e2e image file prompts',
+        metadata: { cwd: process.cwd(), scenario: 'image-file-prompts' },
+      });
+      sid = session.id;
+      log('session created', { session_id: sid });
+
+      await expectEnvelopeCode(
+        () =>
+          client.submitPrompt(sid!, {
+            content: [{ type: 'image', source: { kind: 'file', file_id: 'file_missing_e2e' } }],
+          }),
+        ErrorCode.FILE_NOT_FOUND,
+        'missing prompt image file_id',
+      );
+
+      const textFile = await client.uploadFile({
+        name: 'not-an-image.txt',
+        data: 'not an image',
+        mediaType: 'text/plain',
+      });
+      files.push(textFile.id);
+      await expectEnvelopeCode(
+        () =>
+          client.submitPrompt(sid!, {
+            content: [{ type: 'image', source: { kind: 'file', file_id: textFile.id } }],
+          }),
+        ErrorCode.VALIDATION_FAILED,
+        'non-image prompt file_id',
+      );
+
+      const png = await client.uploadFile({
+        name: 'tiny.png',
+        data: ONE_BY_ONE_PNG,
+        mediaType: 'image/png',
+      });
+      files.push(png.id);
+      expect(png.media_type).toBe('image/png');
+      expect(png.size).toBe(ONE_BY_ONE_PNG.length);
+
+      const submit = await client.submitPrompt(sid, {
+        content: [
+          { type: 'text', text: 'Reply with the single word "OK" after reading this image.' },
+          { type: 'image', source: { kind: 'file', file_id: png.id } },
+        ],
+      });
+      expect(submit.prompt_id.length).toBeGreaterThan(0);
+      log('prompt submitted', { file_id: png.id, prompt_id: submit.prompt_id });
+
+      try {
+        await client.abortPrompt(sid, submit.prompt_id);
+        log('prompt aborted', { prompt_id: submit.prompt_id });
+      } catch (error) {
+        if (
+          error instanceof EnvelopeError &&
+          (error.code === ErrorCode.PROMPT_ALREADY_COMPLETED ||
+            error.code === ErrorCode.PROMPT_NOT_FOUND)
+        ) {
+          log('prompt already terminal before abort', { prompt_id: submit.prompt_id });
+        } else {
+          throw error;
+        }
+      }
+      await client.waitForSessionBusy(sid, false, { timeoutMs: SHORT_TIMEOUT_MS });
+    } finally {
+      for (const fileId of files.toReversed()) {
+        try {
+          await client.deleteFile(fileId);
+        } catch {
+          // ignore
+        }
+      }
+      try {
+        if (sid) await client.archiveSession(sid);
+      } catch {
+        // ignore
+      }
+      await client.close();
+    }
+  }, 120_000);
+});
diff --git a/packages/server-e2e/test/log.ts b/packages/klient/test/e2e/legacy/log.ts
similarity index 94%
rename from packages/server-e2e/test/log.ts
rename to packages/klient/test/e2e/legacy/log.ts
index 6771042cd..90cb23632 100644
--- a/packages/server-e2e/test/log.ts
+++ b/packages/klient/test/e2e/legacy/log.ts
@@ -1,6 +1,6 @@
 import { onTestFailed, onTestFinished } from 'vitest';
 
-import { recordReportEvent, setActiveReportCase } from '../src/report.js';
+import { recordReportEvent, setActiveReportCase } from '../harness/report.js';
 
 export function createCaseLogger(caseName: string): (label: string, value?: unknown) => void {
   setActiveReportCase(caseName);
diff --git a/packages/server-e2e/test/prompt-queue-steer.test.ts b/packages/klient/test/e2e/legacy/prompt-queue-steer.test.ts
similarity index 98%
rename from packages/server-e2e/test/prompt-queue-steer.test.ts
rename to packages/klient/test/e2e/legacy/prompt-queue-steer.test.ts
index 28455375c..1ce57ab2b 100644
--- a/packages/server-e2e/test/prompt-queue-steer.test.ts
+++ b/packages/klient/test/e2e/legacy/prompt-queue-steer.test.ts
@@ -14,8 +14,8 @@
  */
 import { afterEach, describe, expect, it } from 'vitest';
 
-import { DaemonClient, type AnyFrame } from '../src/index.js';
-import { fetchWithReport } from '../src/report.js';
+import { DaemonClient, type AnyFrame } from '../harness/index.js';
+import { fetchWithReport } from '../harness/report.js';
 import { createCaseLogger } from './log.js';
 
 const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
diff --git a/packages/server-e2e/test/refresh-replay.test.ts b/packages/klient/test/e2e/legacy/refresh-replay.test.ts
similarity index 98%
rename from packages/server-e2e/test/refresh-replay.test.ts
rename to packages/klient/test/e2e/legacy/refresh-replay.test.ts
index 6b906159d..6d6feb450 100644
--- a/packages/server-e2e/test/refresh-replay.test.ts
+++ b/packages/klient/test/e2e/legacy/refresh-replay.test.ts
@@ -29,8 +29,8 @@
 import { afterEach, describe, expect, it } from 'vitest';
 import { WebSocket as WsWebSocket } from 'ws';
 
-import { DaemonClient, WsClient, type AnyFrame } from '../src/index.js';
-import { fetchWithReport } from '../src/report.js';
+import { DaemonClient, WsClient, type AnyFrame } from '../harness/index.js';
+import { fetchWithReport } from '../harness/report.js';
 import { createCaseLogger } from './log.js';
 
 const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
diff --git a/packages/server-e2e/test/report.test.ts b/packages/klient/test/e2e/legacy/report.test.ts
similarity index 98%
rename from packages/server-e2e/test/report.test.ts
rename to packages/klient/test/e2e/legacy/report.test.ts
index 5efc68144..26d4a5764 100644
--- a/packages/server-e2e/test/report.test.ts
+++ b/packages/klient/test/e2e/legacy/report.test.ts
@@ -13,10 +13,10 @@ import {
   resetReportDir,
   setActiveReportCase,
   writeHtmlReport,
-} from '../src/report';
-import { DaemonClient } from '../src/client';
-import { HttpClient } from '../src/http';
-import { WsClient } from '../src/ws';
+} from '../harness/report.js';
+import { DaemonClient } from '../harness/client.js';
+import { HttpClient } from '../harness/http.js';
+import { WsClient } from '../harness/ws.js';
 import { createCaseLogger } from './log';
 
 const tmpDirs: string[] = [];
@@ -182,7 +182,7 @@ describe('server-e2e report', () => {
             title: 'New Session',
             created_at: '2026-06-09T00:00:00.000Z',
             updated_at: '2026-06-09T00:00:00.000Z',
-            status: 'idle',
+            busy: false,
             metadata: { cwd: '/tmp/workspace' },
             agent_config: { model: '' },
             usage: {
@@ -379,7 +379,7 @@ describe('server-e2e report', () => {
             title: 'New Session',
             created_at: '2026-06-09T00:00:00.000Z',
             updated_at: '2026-06-09T00:00:00.000Z',
-            status: 'idle',
+            busy: false,
             metadata: { cwd: '/tmp/workspace' },
             agent_config: { model: '' },
             usage: {
diff --git a/packages/server-e2e/test/report/vitest-reporter.ts b/packages/klient/test/e2e/legacy/report/vitest-reporter.ts
similarity index 97%
rename from packages/server-e2e/test/report/vitest-reporter.ts
rename to packages/klient/test/e2e/legacy/report/vitest-reporter.ts
index eeb9d793c..5745a3a9e 100644
--- a/packages/server-e2e/test/report/vitest-reporter.ts
+++ b/packages/klient/test/e2e/legacy/report/vitest-reporter.ts
@@ -6,7 +6,7 @@ import {
   recordReportEvent,
   resetReportDir,
   writeHtmlReport,
-} from '../../src/report.js';
+} from '../../harness/report.js';
 
 export default class DaemonE2eHtmlReporter implements Reporter {
   onTestRunStart(): void {
diff --git a/packages/server-e2e/test/send-and-cancel.test.ts b/packages/klient/test/e2e/legacy/send-and-cancel.test.ts
similarity index 99%
rename from packages/server-e2e/test/send-and-cancel.test.ts
rename to packages/klient/test/e2e/legacy/send-and-cancel.test.ts
index bfac78536..1ac48f9e0 100644
--- a/packages/server-e2e/test/send-and-cancel.test.ts
+++ b/packages/klient/test/e2e/legacy/send-and-cancel.test.ts
@@ -15,8 +15,8 @@
  */
 import { afterEach, describe, expect, it } from 'vitest';
 
-import { DaemonClient, EnvelopeError, type AnyFrame } from '../src/index.js';
-import { fetchWithReport } from '../src/report.js';
+import { DaemonClient, EnvelopeError, type AnyFrame } from '../harness/index.js';
+import { fetchWithReport } from '../harness/report.js';
 import { createCaseLogger, errorForLog } from './log.js';
 
 const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
diff --git a/packages/server-e2e/test/session-resume.test.ts b/packages/klient/test/e2e/legacy/session-resume.test.ts
similarity index 74%
rename from packages/server-e2e/test/session-resume.test.ts
rename to packages/klient/test/e2e/legacy/session-resume.test.ts
index a7c9bf55a..459969177 100644
--- a/packages/server-e2e/test/session-resume.test.ts
+++ b/packages/klient/test/e2e/legacy/session-resume.test.ts
@@ -1,5 +1,5 @@
 /**
- * Session-resume / status invariants — assertions for the two gaps the
+ * Session-resume / activity invariants — assertions for the two gaps the
  * "browser refresh" walkthrough flagged:
  *
  *   1. **Cold-session `GET /messages` must NOT 401.** Pre-fix, the
@@ -9,20 +9,17 @@
  *      `core.rpc.resumeSession({sessionId})` before `getContext`, so any
  *      session whose snapshot exists on disk is rehydrated transparently.
  *
- *   2. **`GET /sessions/{sid}.status` must reflect runtime state.** The
- *      protocol exposes `idle | running | awaiting_approval |
- *      awaiting_question | aborted` (`session.ts:36-42`); pre-fix,
- *      `toProtocolSession` (`services/src/session/session.ts:178`) hardcoded
- *      `status: 'idle'`; the v2 backend pulls real status, so this test
- *      asserts the live server transitions `idle → running → idle` across a
- *      prompt.
+ *   2. **`GET /sessions/{sid}.busy` must reflect runtime work.** Session
+ *      activity is aggregated from agent turns and background tasks, so this
+ *      test asserts the live server transitions `false → true → false` across
+ *      a prompt.
  *
  * Both tests gate on `daemonReachable()` so CI without a server stays green.
  */
 import { afterEach, describe, expect, it } from 'vitest';
 
-import { DaemonClient } from '../src/index.js';
-import { fetchWithReport } from '../src/report.js';
+import { DaemonClient } from '../harness/index.js';
+import { fetchWithReport } from '../harness/report.js';
 import { createCaseLogger } from './log.js';
 
 const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
@@ -60,7 +57,7 @@ afterEach(async () => {
   }
 });
 
-describeLive('session resume + status (live server required)', () => {
+describeLive('session resume + activity (live server required)', () => {
   // ── Gap 1: cold-session /messages ──────────────────────────────────────
   it(
     'GET /messages on a persisted session returns 200 (resumeSession injection)',
@@ -118,21 +115,18 @@ describeLive('session resume + status (live server required)', () => {
     PROMPT_TIMEOUT_MS + 30_000,
   );
 
-  // ── Gap 2: live status field ───────────────────────────────────────────
-  // Asserts the live server transitions `idle → running → idle` across a
-  // prompt. Historically gated behind `it.fails` pending v1's
-  // `toProtocolSession` hardcode (`services/src/session/session.ts:178`);
-  // the v2 backend pulls real status and the transition now passes, so the
-  // gate was removed.
+  // ── Gap 2: live busy field ─────────────────────────────────────────────
+  // Asserts the live server transitions `false → true → false` across a
+  // prompt, using the aggregate work fact exposed by both backends.
   it(
-    'GET /sessions/{sid}.status transitions idle → running → idle across a prompt',
+    'GET /sessions/{sid}.busy transitions false → true → false across a prompt',
     async () => {
-      const log = createCaseLogger('session status: live transition');
+      const log = createCaseLogger('session busy: live transition');
       const client = new DaemonClient({ baseUrl: BASE_URL });
       const session = await client.createSession({ metadata: { cwd: process.cwd() } });
       created.push({ client, sid: session.id });
       log('created session', session);
-      expect(session.status).toBe('idle');
+      expect(session.busy).toBe(false);
 
       await client.connect();
       await client.subscribe(session.id);
@@ -144,10 +138,10 @@ describeLive('session resume + status (live server required)', () => {
       });
       log('submit response', submit);
 
-      // Race the server: poll status quickly until we observe a non-idle
-      // value or `prompt.completed` lands. Either outcome ends the loop; we
-      // assert on the captured `seenRunning` flag afterward.
-      let seenRunning = false;
+      // Race the server: poll busy quickly until we observe active work or
+      // `prompt.completed` lands. Either outcome ends the loop; we
+      // assert on the captured `seenBusy` flag afterward.
+      let seenBusy = false;
       const ackPromise = client.waitForFrame(
         (f) => {
           if (f.type !== 'prompt.completed') return false;
@@ -157,29 +151,29 @@ describeLive('session resume + status (live server required)', () => {
         { timeoutMs: PROMPT_TIMEOUT_MS },
       );
       const deadline = Date.now() + 5_000;
-      const statusSamples: Array<{ at_ms: number; status: string; current_prompt_id?: string }> = [];
+      const busySamples: Array<{ at_ms: number; busy: boolean; current_prompt_id?: string }> = [];
       const startedAt = Date.now();
-      while (Date.now() < deadline && !seenRunning) {
+      while (Date.now() < deadline && !seenBusy) {
         const snap = await client.http.getSession(session.id);
-        statusSamples.push({
+        busySamples.push({
           at_ms: Date.now() - startedAt,
-          status: snap.status,
+          busy: snap.busy,
           current_prompt_id: snap.current_prompt_id,
         });
-        if (snap.status !== 'idle') {
-          seenRunning = true;
+        if (snap.busy) {
+          seenBusy = true;
           break;
         }
         await new Promise((r) => setTimeout(r, 50));
       }
       const completedFrame = await ackPromise;
-      log('status poll samples', statusSamples);
+      log('busy poll samples', busySamples);
       log('prompt completed frame', frameForLog(completedFrame));
       const after = await client.http.getSession(session.id);
       log('final session snapshot', after);
 
-      expect(seenRunning, 'expected at least one non-idle status reading during prompt').toBe(true);
-      expect(after.status).toBe('idle');
+      expect(seenBusy, 'expected at least one busy reading during prompt').toBe(true);
+      expect(after.busy).toBe(false);
     },
     PROMPT_TIMEOUT_MS + 30_000,
   );
@@ -197,7 +191,7 @@ function frameForLog(frame: { type: string; seq?: number; session_id?: string; p
 function sessionSummaryForLog(session: {
   id: string;
   title: string;
-  status: string;
+  busy: boolean;
   message_count: number;
   last_seq: number;
   metadata: Record<string, unknown>;
@@ -205,7 +199,7 @@ function sessionSummaryForLog(session: {
   return {
     id: session.id,
     title: session.title,
-    status: session.status,
+    busy: session.busy,
     message_count: session.message_count,
     last_seq: session.last_seq,
     cwd: session.metadata['cwd'],
diff --git a/packages/klient/test/e2e/legacy/terminal.test.ts b/packages/klient/test/e2e/legacy/terminal.test.ts
new file mode 100644
index 000000000..770ee714d
--- /dev/null
+++ b/packages/klient/test/e2e/legacy/terminal.test.ts
@@ -0,0 +1,172 @@
+/**
+ * Live-server invariant for the v1 terminal surface (REST + WS controls — no
+ * `/api/v2` equivalent): create/list/get a terminal, attach + input over WS,
+ * observe `terminal_output`, resize, close with `terminal_exit`.
+ *
+ * Converted from the retired scenario `11-terminal.ts`. Skips when no server
+ * is reachable at `KIMI_SERVER_URL`.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { DaemonClient, type AnyFrame } from '../harness/index.js';
+import { fetchWithReport } from '../harness/report.js';
+import { createCaseLogger } from './log.js';
+
+const BASE_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
+const API_PREFIX = '/api/v1';
+const TERMINAL_SHELL = process.env['KIMI_SERVER_E2E_TERMINAL_SHELL'] ?? '/bin/sh';
+const OUTPUT_TIMEOUT_MS = 20_000;
+const EXIT_TIMEOUT_MS = 5_000;
+const CANARY = `KIMI_KLIENT_E2E_TERMINAL_${process.pid}_${Date.now()}`;
+
+async function daemonReachable(): Promise<boolean> {
+  try {
+    const res = await fetchWithReport(`${BASE_URL}${API_PREFIX}/meta`, {
+      signal: AbortSignal.timeout(500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+const reachable = await daemonReachable();
+const describeLive = reachable ? describe : describe.skip;
+
+interface TerminalOutputPayload {
+  data: string;
+}
+
+function isTerminalOutputFor(frame: AnyFrame, sid: string, terminalId: string): boolean {
+  const terminalFrame = frame as AnyFrame & { terminal_id?: string };
+  return (
+    frame.type === 'terminal_output' &&
+    frame.session_id === sid &&
+    terminalFrame.terminal_id === terminalId
+  );
+}
+
+function isTerminalExitFor(sid: string, terminalId: string): (frame: AnyFrame) => boolean {
+  return (frame) => {
+    const terminalFrame = frame as AnyFrame & { terminal_id?: string };
+    return (
+      frame.type === 'terminal_exit' &&
+      frame.session_id === sid &&
+      terminalFrame.terminal_id === terminalId
+    );
+  };
+}
+
+function toShellOctalEscapes(value: string): string {
+  return Array.from(value)
+    .map((char) => `\\${char.codePointAt(0)!.toString(8).padStart(3, '0')}`)
+    .join('');
+}
+
+function payloadOf<T>(frame: AnyFrame): T {
+  if (frame.payload === undefined) throw new Error(`${frame.type} frame should carry payload`);
+  return frame.payload as T;
+}
+
+describeLive('legacy: terminal controls', () => {
+  it('terminal output, resize, and close round-trip', async () => {
+    const log = createCaseLogger('legacy: terminal controls');
+    const client = new DaemonClient({ baseUrl: BASE_URL });
+
+    let sid: string | undefined;
+    let terminalId: string | undefined;
+    let terminalClosed = false;
+
+    try {
+      const session = await client.createSession({
+        title: 'klient-e2e terminal',
+        metadata: { cwd: process.cwd(), scenario: 'terminal' },
+      });
+      sid = session.id;
+      const sessionId = session.id;
+      log('session created', { session_id: sessionId });
+
+      await client.connect();
+      await client.subscribe(sessionId);
+
+      const terminal = await client.createTerminal(sessionId, {
+        shell: TERMINAL_SHELL,
+        cols: 80,
+        rows: 24,
+      });
+      terminalId = terminal.id;
+      expect(terminal.session_id).toBe(sessionId);
+      expect(terminal.status).toBe('running');
+      expect(terminal.cols).toBe(80);
+      expect(terminal.rows).toBe(24);
+      log('terminal created', { id: terminal.id, shell: terminal.shell });
+
+      const listed = await client.listTerminals(sessionId);
+      expect(listed.items.some((item) => item.id === terminal.id)).toBe(true);
+
+      const observedOutput: string[] = [];
+      const unsubscribe = client.onFrame((frame) => {
+        if (!isTerminalOutputFor(frame, sessionId, terminal.id)) return;
+        observedOutput.push(payloadOf<TerminalOutputPayload>(frame).data);
+      });
+
+      try {
+        const attach = await client.attachTerminal(sessionId, terminal.id, { sinceSeq: 0 });
+        expect(attach.attached).toBe(true);
+        expect(typeof attach.replayed).toBe('number');
+        log('terminal attached', attach);
+
+        const input = `printf '%b\\n' '${toShellOctalEscapes(CANARY)}'\n`;
+        const inputAck = await client.writeTerminalInput(sessionId, terminal.id, input);
+        expect(inputAck).toEqual({ accepted: true });
+
+        const deadline = Date.now() + OUTPUT_TIMEOUT_MS;
+        let text = '';
+        while (Date.now() < deadline) {
+          text = observedOutput.join('');
+          if (text.includes(CANARY)) break;
+          await new Promise((resolve) => {
+            setTimeout(resolve, 25);
+          });
+        }
+        expect(text).toContain(CANARY);
+        log('terminal output observed', { matched: CANARY });
+
+        const resizeAck = await client.resizeTerminal(sessionId, terminal.id, 100, 31);
+        expect(resizeAck).toEqual({ resized: true });
+        const resized = await client.getTerminal(sessionId, terminal.id);
+        expect(resized.cols).toBe(100);
+        expect(resized.rows).toBe(31);
+        log('terminal resized', { cols: resized.cols, rows: resized.rows });
+
+        const exitFramePromise = client.waitForFrame(isTerminalExitFor(sessionId, terminal.id), {
+          timeoutMs: EXIT_TIMEOUT_MS,
+        });
+        const closeAck = await client.closeTerminalControl(sessionId, terminal.id);
+        terminalClosed = true;
+        expect(closeAck).toEqual({ closed: true });
+        await exitFramePromise;
+        log('terminal exit frame received', {});
+
+        const closed = await client.getTerminal(sessionId, terminal.id);
+        expect(closed.status).toBe('exited');
+      } finally {
+        unsubscribe();
+      }
+    } finally {
+      if (sid !== undefined && terminalId !== undefined && !terminalClosed) {
+        try {
+          await client.closeTerminal(sid, terminalId);
+        } catch {
+          // ignore
+        }
+      }
+      try {
+        if (sid) await client.archiveSession(sid);
+      } catch {
+        // ignore
+      }
+      await client.close();
+    }
+  }, 60_000);
+});
diff --git a/packages/server-e2e/test/v2/channelRegistry.test.ts b/packages/klient/test/e2e/v2/channelRegistry.test.ts
similarity index 100%
rename from packages/server-e2e/test/v2/channelRegistry.test.ts
rename to packages/klient/test/e2e/v2/channelRegistry.test.ts
diff --git a/packages/server-e2e/src/v2/token.ts b/packages/klient/test/e2e/v2/helpers/token.ts
similarity index 96%
rename from packages/server-e2e/src/v2/token.ts
rename to packages/klient/test/e2e/v2/helpers/token.ts
index 4d03de4b6..cd5599a8d 100644
--- a/packages/server-e2e/src/v2/token.ts
+++ b/packages/klient/test/e2e/v2/helpers/token.ts
@@ -38,9 +38,9 @@ export async function resolveKimiHome(homeDir?: string): Promise<string> {
   const envHome =
     typeof process !== 'undefined' ? process.env?.['KIMI_CODE_HOME'] : undefined;
   if (envHome !== undefined && envHome.length > 0) return envHome;
-  if (!isNode()) return `.${'kimi-code'}`;
+  if (!isNode()) return '.kimi-code';
   const [{ homedir }, path] = await Promise.all([import('node:os'), import('node:path')]);
-  return path.join(homedir(), `.${'kimi-code'}`);
+  return path.join(homedir(), '.kimi-code');
 }
 
 /** Absolute path of the persistent token file for a given home dir. */
@@ -66,8 +66,8 @@ export async function loadLocalServerToken(homeDir?: string): Promise<TokenResol
     const token = raw.trim();
     if (token.length === 0) return { token: undefined, source: 'none', tokenPath };
     return { token, source: 'file', tokenPath };
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') {
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
       return { token: undefined, source: 'none' };
     }
     return { token: undefined, source: 'none' };
diff --git a/packages/klient/test/e2e/v2/smoke.test.ts b/packages/klient/test/e2e/v2/smoke.test.ts
new file mode 100644
index 000000000..460f02fb5
--- /dev/null
+++ b/packages/klient/test/e2e/v2/smoke.test.ts
@@ -0,0 +1,205 @@
+/**
+ * Smoke test for the v2 wire surface — boots `server-v2` in-process (port 0).
+ *
+ * The global (app-scope) assertions go through the klient facade
+ * (`@moonshot-ai/klient/http`). Session/agent assertions call the `/api/v2`
+ * wire directly (fetch + raw WS frames) — TODO: move them to the klient
+ * session/agent facades when those land.
+ *
+ * Server state is arranged through the in-process `server.core` reference only
+ * where the RPC surface offers no way (creating the main agent, server-v2 gap
+ * G10); session creation goes through the legacy `/api/v1` REST surface.
+ */
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { ensureMainAgent, ISessionLifecycleService } from '@moonshot-ai/agent-core-v2';
+import { type RunningServer, startServer } from '@moonshot-ai/kap-server';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { createKlient } from '../../../src/transports/http/index.js';
+import type { Klient } from '../../../src/index.js';
+
+/** Direct `/api/v2` wire call (see TODO above). */
+async function v2Rpc<T>(
+  baseUrl: string,
+  token: string,
+  path: string,
+  args: unknown[],
+): Promise<T> {
+  const res = await fetch(`${baseUrl}/api/v2${path}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+    body: JSON.stringify(args),
+  });
+  const envelope = (await res.json()) as { code: number; msg: string; data: T };
+  if (envelope.code !== 0) {
+    throw new Error(`v2 ${path} failed: ${envelope.code} ${envelope.msg}`);
+  }
+  return envelope.data;
+}
+
+/** Session creation goes through the legacy `/api/v1` REST surface. */
+async function v1CreateSession(baseUrl: string, token: string, cwd: string): Promise<string> {
+  const res = await fetch(`${baseUrl}/api/v1/sessions`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+    body: JSON.stringify({ metadata: { cwd } }),
+  });
+  const envelope = (await res.json()) as { code: number; msg: string; data: { id: string } };
+  if (envelope.code !== 0) {
+    throw new Error(`v1 createSession failed: ${envelope.code} ${envelope.msg}`);
+  }
+  return envelope.data.id;
+}
+
+describe('Klient (server-v2 smoke)', () => {
+  let server: RunningServer | undefined;
+  let home: string | undefined;
+  let klient: Klient | undefined;
+  let baseUrl: string;
+  let token: string;
+
+  beforeEach(async () => {
+    home = await mkdtemp(join(tmpdir(), 'kimi-sdk-smoke-'));
+    server = await startServer({ host: '127.0.0.1', port: 0, homeDir: home, logLevel: 'silent' });
+    baseUrl = `http://127.0.0.1:${server.port}`;
+    token = server.authTokenService.getToken();
+    klient = createKlient({ url: baseUrl, token });
+  });
+
+  afterEach(async () => {
+    await klient?.close();
+    klient = undefined;
+    if (server) {
+      await server.close();
+      server = undefined;
+    }
+    if (home) {
+      await rm(home, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 } as never);
+      home = undefined;
+    }
+  });
+
+  async function createSession(cwd: string): Promise<string> {
+    return v1CreateSession(baseUrl, token, cwd);
+  }
+
+  async function createMainAgent(sessionId: string): Promise<void> {
+    const session = server!.core.accessor.get(ISessionLifecycleService).get(sessionId);
+    if (session === undefined) throw new Error(`session ${sessionId} not found`);
+    await ensureMainAgent(session);
+  }
+
+  it('lists sessions (global facade)', async () => {
+    await createSession(home as string);
+    const page = await klient!.global.sessions.list({ limit: 20 });
+    expect(page.items.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('creates and reads a workspace (global facade)', async () => {
+    const workspaces = klient!.global.workspaces;
+    const created = await workspaces.createOrTouch({ root: home as string });
+    expect(created.root).toBe(home);
+
+    const got = await workspaces.get(created.id);
+    expect(got?.root).toBe(home);
+  });
+
+  it('reads, renames, and archives a session (session scope, direct wire)', async () => {
+    const sid = await createSession(home as string);
+
+    const before = await v2Rpc<{ id: string; title?: string }>(
+      baseUrl,
+      token,
+      `/session/${sid}/sessionMetadata/read`,
+      [],
+    );
+    expect(before.id).toBe(sid);
+
+    await v2Rpc(baseUrl, token, `/session/${sid}/sessionMetadata/setTitle`, ['renamed']);
+    const after = await v2Rpc<{ title?: string }>(
+      baseUrl,
+      token,
+      `/session/${sid}/sessionMetadata/read`,
+      [],
+    );
+    expect(after.title).toBe('renamed');
+
+    const pending = await v2Rpc<unknown[]>(
+      baseUrl,
+      token,
+      `/session/${sid}/sessionInteractionService/listPending`,
+      [],
+    );
+    expect(pending).toEqual([]);
+
+    await v2Rpc(baseUrl, token, `/session/${sid}/sessionLifecycleService/archive`, [sid]);
+  });
+
+  it('submits a prompt and runs a shell command (agent scope, direct wire)', async () => {
+    const sid = await createSession(home as string);
+    await createMainAgent(sid);
+
+    const submitted = await v2Rpc<{ turn_id?: number } | undefined>(
+      baseUrl,
+      token,
+      `/session/${sid}/agent/main/agentRPCService/prompt`,
+      [{ input: [{ type: 'text', text: 'hello' }] }],
+    );
+    expect(typeof submitted?.turn_id).toBe('number');
+
+    const shell = await v2Rpc<{ stdout: string; stderr: string }>(
+      baseUrl,
+      token,
+      `/session/${sid}/agent/main/agentRPCService/runShellCommand`,
+      [{ command: 'printf hello' }],
+    );
+    expect(shell.stdout).toBe('hello');
+    expect(shell.stderr).toBe('');
+  });
+
+  it('streams agent events over ws (raw frames)', async () => {
+    const sid = await createSession(home as string);
+    await createMainAgent(sid);
+
+    const wsUrl = `${baseUrl.replace(/^http/, 'ws')}/api/v2/ws`;
+    const ws = new WebSocket(wsUrl, [`kimi-code.bearer.${token}`]);
+    const received: unknown[] = [];
+    ws.onmessage = (event) => {
+      const frame = JSON.parse(String(event.data)) as { type: string; data?: unknown };
+      if (frame.type === 'event') received.push(frame.data);
+    };
+    await new Promise<void>((resolve, reject) => {
+      ws.onopen = () => {
+        resolve();
+      };
+      ws.onerror = () => {
+        reject(new Error('ws connect failed'));
+      };
+    });
+    ws.send(JSON.stringify({ type: 'hello', token }));
+    ws.send(
+      JSON.stringify({
+        type: 'listen',
+        id: 'l1',
+        scope: 'agent',
+        sessionId: sid,
+        agentId: 'main',
+        event: 'events',
+      }),
+    );
+
+    await v2Rpc(baseUrl, token, `/session/${sid}/agent/main/agentRPCService/prompt`, [
+      { input: [{ type: 'text', text: 'hi' }] },
+    ]);
+
+    const deadline = Date.now() + 10_000;
+    while (received.length === 0 && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    ws.close();
+    expect(received.length).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/server-e2e/test/v2/token.test.ts b/packages/klient/test/e2e/v2/token.test.ts
similarity index 99%
rename from packages/server-e2e/test/v2/token.test.ts
rename to packages/klient/test/e2e/v2/token.test.ts
index 4be56daa9..b8b645160 100644
--- a/packages/server-e2e/test/v2/token.test.ts
+++ b/packages/klient/test/e2e/v2/token.test.ts
@@ -17,7 +17,7 @@ import {
   loadLocalServerToken,
   resolveKimiHome,
   serverTokenPath,
-} from '../../src/v2/token.js';
+} from './helpers/token.js';
 
 describe('local token discovery', () => {
   let home: string | undefined;
diff --git a/packages/klient/test/facade.test.ts b/packages/klient/test/facade.test.ts
new file mode 100644
index 000000000..2dc355956
--- /dev/null
+++ b/packages/klient/test/facade.test.ts
@@ -0,0 +1,208 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type {
+  EventSourceRef,
+  IDisposable,
+  KlientChannel,
+  ScopeRef,
+} from '../src/core/channel.js';
+import { createKlientFromChannel } from '../src/core/klient.js';
+import { KlientValidationError } from '../src/core/validation.js';
+
+const tick = (ms = 0): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** Records calls, replays scripted results, and captures listen subscriptions. */
+class FakeChannel implements KlientChannel {
+  readonly calls: Array<{ scope: ScopeRef; service: string; method: string; args: unknown[] }> = [];
+  readonly subscriptions: Array<{ source: EventSourceRef; dispose: ReturnType<typeof vi.fn> }> =
+    [];
+  result: unknown;
+  /** Keyed `${service}.${method}` result overrides. */
+  readonly results = new Map<string, unknown>();
+  private readonly handlers = new Map<number, (data: unknown) => void>();
+  private nextSub = 0;
+
+  call(scope: ScopeRef, service: string, method: string, args: unknown[]): Promise<unknown> {
+    this.calls.push({ scope, service, method, args });
+    const key = `${service}.${method}`;
+    return Promise.resolve(this.results.has(key) ? this.results.get(key) : this.result);
+  }
+
+  listen(_scope: ScopeRef, source: EventSourceRef, handler: (data: unknown) => void): IDisposable {
+    const id = this.nextSub;
+    this.nextSub += 1;
+    this.handlers.set(id, handler);
+    const dispose = vi.fn(() => {
+      this.handlers.delete(id);
+    });
+    this.subscriptions.push({ source, dispose });
+    return { dispose };
+  }
+
+  /** Push a raw payload into the Nth subscription (0-based). */
+  emit(index: number, data: unknown): void {
+    this.handlers.get(index)?.(data);
+  }
+
+  close(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+const SUMMARY = {
+  id: 's1',
+  workspaceId: 'w1',
+  createdAt: 1,
+  updatedAt: 2,
+  archived: false,
+};
+
+describe('facade routing', () => {
+  it('reshapes single-object params into positional wire args', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+
+    channel.result = { id: 'w1', root: '/x', name: 'n', createdAt: 1, lastOpenedAt: 2 };
+    await klient.global.workspaces.createOrTouch({ root: '/x', name: 'n' });
+    expect(channel.calls[0]).toMatchObject({
+      service: 'workspaceRegistry',
+      method: 'createOrTouch',
+      args: ['/x', 'n'],
+    });
+
+    channel.result = undefined; // void output
+    await klient.global.plugins.setMcpServerEnabled({ id: 'p', server: 's', enabled: true });
+    expect(channel.calls[1]).toMatchObject({
+      service: 'pluginService',
+      method: 'setPluginMcpServerEnabled',
+      args: [{ id: 'p', server: 's', enabled: true }],
+    });
+
+    channel.results.set('oauthService.status', { loggedIn: false });
+    await klient.global.auth.status();
+    expect(channel.calls[2]).toMatchObject({
+      service: 'oauthService',
+      method: 'status',
+      args: [undefined],
+    });
+  });
+
+  it('env() fans out property reads and merges them', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    channel.result = 'v';
+    const env = await klient.global.env();
+    expect(env.platform).toBe('v');
+    expect(env.logsDir).toBe('v');
+    expect(channel.calls).toHaveLength(12);
+    expect(channel.calls.every((call) => call.service === 'bootstrapService')).toBe(true);
+  });
+
+  it('env() resolves once and serves repeats from the cache', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    channel.result = 'v';
+    await klient.global.env();
+    expect(channel.calls).toHaveLength(12);
+
+    const again = await klient.global.env();
+    expect(again.platform).toBe('v');
+    expect(channel.calls).toHaveLength(12);
+  });
+});
+
+describe('contract validation', () => {
+  it('rejects invalid input before the call leaves the client', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    await expect(
+      klient.global.sessions.list({ limit: '20' as unknown as number }),
+    ).rejects.toBeInstanceOf(KlientValidationError);
+    expect(channel.calls).toHaveLength(0);
+  });
+
+  it('rejects drifted output payloads', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    channel.result = { id: 's1' }; // missing required SessionSummary fields
+    await expect(klient.global.sessions.get('s1')).rejects.toBeInstanceOf(KlientValidationError);
+  });
+
+  it('passes valid payloads through and returns parsed output', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    channel.result = SUMMARY;
+    await expect(klient.global.sessions.get('s1')).resolves.toEqual(SUMMARY);
+  });
+
+  it('validate:false skips both directions', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel, { validate: false });
+    channel.result = { anything: true };
+    await expect(
+      klient.global.sessions.list({ limit: '20' as unknown as number }),
+    ).resolves.toEqual({ anything: true });
+  });
+});
+
+describe('event hub', () => {
+  it('maps public names to emitter sources and validates payloads', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    const seen: unknown[] = [];
+    const errors: Error[] = [];
+    klient.events.onError((error) => {
+        errors.push(error);
+      });
+
+    klient.events.on('providers.changed', (event) => seen.push(event));
+    expect(channel.subscriptions[0]?.source).toEqual({
+      kind: 'emitter',
+      service: 'providerService',
+      event: 'onDidChangeProviders',
+    });
+
+    channel.emit(0, { added: ['p1'], removed: [], changed: [] });
+    channel.emit(0, { added: 'not-an-array' });
+    await tick();
+    expect(seen).toEqual([{ added: ['p1'], removed: [], changed: [] }]);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toBeInstanceOf(KlientValidationError);
+  });
+
+  it('shares one bus subscription across bus-derived events and filters by type', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    const archived: unknown[] = [];
+    const catalog: unknown[] = [];
+
+    const subA = klient.events.on('session.archived', (event) => archived.push(event));
+    const subB = klient.events.on('catalog.changed', (event) => catalog.push(event));
+    expect(channel.subscriptions).toHaveLength(1);
+    expect(channel.subscriptions[0]?.source).toEqual({ kind: 'stream', name: 'events' });
+
+    channel.emit(0, { type: 'event.session.archived', payload: { sessionId: 's1' } });
+    channel.emit(0, { type: 'event.model_catalog.changed', payload: { changed: [], unchanged: [], failed: [] } });
+    channel.emit(0, { type: 'unrelated.type', payload: {} });
+    await tick();
+    expect(archived).toEqual([{ sessionId: 's1' }]);
+    expect(catalog).toEqual([{ changed: [], unchanged: [], failed: [] }]);
+
+    subA.dispose();
+    expect(channel.subscriptions[0]?.dispose).not.toHaveBeenCalled();
+    subB.dispose();
+    expect(channel.subscriptions[0]?.dispose).toHaveBeenCalledTimes(1);
+  });
+
+  it('disposes the emitter subscription when the last listener detaches', async () => {
+    const channel = new FakeChannel();
+    const klient = createKlientFromChannel(channel);
+    const a = klient.events.on('config.changed', () => undefined);
+    const b = klient.events.on('config.changed', () => undefined);
+    expect(channel.subscriptions).toHaveLength(1);
+    a.dispose();
+    expect(channel.subscriptions[0]?.dispose).not.toHaveBeenCalled();
+    b.dispose();
+    expect(channel.subscriptions[0]?.dispose).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/packages/klient/test/helpers/conformance.ts b/packages/klient/test/helpers/conformance.ts
new file mode 100644
index 000000000..a2d8d8d73
--- /dev/null
+++ b/packages/klient/test/helpers/conformance.ts
@@ -0,0 +1,171 @@
+/**
+ * Shared conformance suite — the guarantee that the http, ipc, and memory
+ * transports are interchangeable. Every transport test file runs the exact
+ * same assertions against a real backend (in-process engine for memory/ipc,
+ * a booted kap-server for http); only the `before` setup differs per file.
+ */
+
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import type { Klient } from '../../src/index.js';
+
+export interface KlientConformanceTarget {
+  readonly klient: Klient;
+  cleanup(): Promise<void>;
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (predicate()) return;
+    await new Promise((resolve) => {
+      setTimeout(resolve, 25);
+    });
+  }
+  throw new Error(`waitFor timed out after ${timeoutMs}ms`);
+}
+
+export function defineKlientConformance(
+  transport: string,
+  makeTarget: () => Promise<KlientConformanceTarget>,
+): void {
+  describe(`klient conformance: ${transport}`, () => {
+    let target: KlientConformanceTarget;
+
+    beforeAll(async () => {
+      target = await makeTarget();
+    });
+
+    afterAll(async () => {
+      await target.cleanup();
+    });
+
+    it('env() aggregates the host snapshot', async () => {
+      const env = await target.klient.global.env();
+      expect(env.platform).toBe(process.platform);
+      expect(env.homeDir.length).toBeGreaterThan(0);
+      expect(env.clientVersion.length).toBeGreaterThan(0);
+    });
+
+    it('workspaces round-trip through create/get/update/list/delete', async () => {
+      const workspaces = target.klient.global.workspaces;
+      const created = await workspaces.createOrTouch({ root: process.cwd(), name: 'conformance' });
+      expect(created.id.length).toBeGreaterThan(0);
+
+      const fetched = await workspaces.get(created.id);
+      expect(fetched?.name).toBe('conformance');
+
+      const updated = await workspaces.update({ id: created.id, patch: { name: 'conformance-2' } });
+      expect(updated?.name).toBe('conformance-2');
+
+      const list = await workspaces.list();
+      expect(list.some((w) => w.id === created.id)).toBe(true);
+
+      await workspaces.delete(created.id);
+      expect(await workspaces.get(created.id)).toBeUndefined();
+    });
+
+    it('sessions index responds with a page shape', async () => {
+      const page = await target.klient.global.sessions.list({});
+      expect(Array.isArray(page.items)).toBe(true);
+      const count = await target.klient.global.sessions.countActive('no-such-workspace');
+      expect(typeof count).toBe('number');
+    });
+
+    it('providers.set/get/delete works and emits providers.changed', async () => {
+      const events: Array<{
+        added: readonly string[];
+        removed: readonly string[];
+        changed: readonly string[];
+      }> = [];
+      const errors: Error[] = [];
+      target.klient.events.onError((error) => {
+        errors.push(error);
+      });
+      const sub = target.klient.events.on('providers.changed', (event) => {
+        events.push(event);
+      });
+      // Give the subscription a wire round-trip (memory is synchronous; ipc
+      // and http's lazy WS need a frame exchange).
+      await new Promise((resolve) => {
+        setTimeout(resolve, 300);
+      });
+
+      const name = '__klient_conformance__';
+      try {
+        await target.klient.global.providers.set({ name, config: { apiKey: 'conf-key' } });
+        const got = await target.klient.global.providers.get(name);
+        expect(got?.apiKey).toBe('conf-key');
+
+        await waitFor(
+          () => events.some((event) => [...event.added, ...event.changed].includes(name)),
+          5_000,
+        );
+      } finally {
+        await target.klient.global.providers.delete(name);
+        sub.dispose();
+      }
+      expect(errors).toEqual([]);
+    });
+
+    it('config reads respond', async () => {
+      const all = await target.klient.global.config.getAll();
+      expect(typeof all).toBe('object');
+      expect(Array.isArray(await target.klient.global.config.diagnostics())).toBe(true);
+    });
+
+    it('hostFs.home() returns the host home and recent roots', async () => {
+      const home = await target.klient.global.hostFs.home();
+      expect(home.home.length).toBeGreaterThan(0);
+      expect(Array.isArray(home.recent_roots)).toBe(true);
+
+      const browse = await target.klient.global.hostFs.browse(home.home);
+      expect(browse.path).toBe(home.home);
+      expect(Array.isArray(browse.entries)).toBe(true);
+    });
+
+    it('catalog lists models/providers and models registry round-trips', async () => {
+      const catalog = target.klient.global.catalog;
+      expect(Array.isArray(await catalog.listModels())).toBe(true);
+      expect(Array.isArray(await catalog.listProviders())).toBe(true);
+
+      const models = target.klient.global.models;
+      const events: Array<{
+        added: readonly string[];
+        removed: readonly string[];
+        changed: readonly string[];
+      }> = [];
+      const sub = target.klient.events.on('models.changed', (event) => {
+        events.push(event);
+      });
+      // See providers.changed above — give the subscription a wire round-trip.
+      await new Promise((resolve) => {
+        setTimeout(resolve, 300);
+      });
+
+      const id = '__klient_conformance__';
+      try {
+        await models.set({ id, config: { name: 'conf-model', model: 'conf-model' } });
+        const got = await models.get(id);
+        expect(got?.name).toBe('conf-model');
+
+        await waitFor(
+          () => events.some((event) => [...event.added, ...event.changed].includes(id)),
+          5_000,
+        );
+      } finally {
+        await models.delete(id);
+        sub.dispose();
+      }
+    });
+
+    it('flags / plugins / auth read models respond', async () => {
+      expect(Array.isArray(await target.klient.global.flags.list())).toBe(true);
+      expect(Array.isArray(await target.klient.global.flags.enabledIds())).toBe(true);
+      expect(typeof await target.klient.global.flags.snapshot()).toBe('object');
+      expect(Array.isArray(await target.klient.global.plugins.list())).toBe(true);
+      const status = await target.klient.global.auth.status();
+      expect(typeof status.loggedIn).toBe('boolean');
+    });
+  });
+}
diff --git a/packages/klient/test/helpers/dual.ts b/packages/klient/test/helpers/dual.ts
new file mode 100644
index 000000000..f4cf8dbb1
--- /dev/null
+++ b/packages/klient/test/helpers/dual.ts
@@ -0,0 +1,164 @@
+/**
+ * Dual-backend session/agent suite helper — runs the exact same test body
+ * against an in-memory engine and an in-process kap-server, one nested
+ * `describe` per backend. Model-requiring suites are skipped unless the
+ * model env is present (self-contained: the model is seeded into each
+ * backend's temp home through the klient facade itself).
+ *
+ * Env:
+ *   KIMI_E2E_MODEL     — model id the gateway serves (e.g. `kimi-k2`)
+ *   KIMI_E2E_API_KEY   — API key for the gateway
+ *   KIMI_E2E_BASE_URL  — optional base URL (OpenAI-compatible endpoint)
+ *   KIMI_E2E_PROTOCOL  — optional wire protocol (default `openai`)
+ */
+
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, beforeAll, describe } from 'vitest';
+
+import { bootstrap, logSeed, resolveLoggingConfig } from '@moonshot-ai/agent-core-v2';
+import { startServer, type RunningServer } from '@moonshot-ai/kap-server';
+
+import type { Klient } from '../../src/index.js';
+import type { KlientEvents } from '../../src/core/events/hub.js';
+import type { ModelConfig } from '@moonshot-ai/agent-core-v2/app/model/model';
+import { createKlient as createMemoryKlient } from '../../src/transports/memory/index.js';
+import { createKlient as createHttpKlient } from '../../src/transports/http/index.js';
+
+export type DualBackend = 'memory' | 'http';
+
+export interface DualTarget {
+  readonly klient: Klient;
+  cleanup(): Promise<void>;
+}
+
+export interface ModelEnv {
+  readonly model: string;
+  readonly apiKey: string;
+  readonly baseUrl?: string;
+  readonly protocol?: ModelConfig['protocol'];
+}
+
+export function modelEnv(): ModelEnv | undefined {
+  const model = process.env['KIMI_E2E_MODEL'];
+  const apiKey = process.env['KIMI_E2E_API_KEY'];
+  if (model === undefined || apiKey === undefined) return undefined;
+  return {
+    model,
+    apiKey,
+    baseUrl: process.env['KIMI_E2E_BASE_URL'],
+    protocol: process.env['KIMI_E2E_PROTOCOL'] as ModelConfig['protocol'],
+  };
+}
+
+/** Model id registered in the backend for the suite; agents `setModel` to it. */
+export const DUAL_MODEL_ID = 'e2e-dual-model';
+
+async function makeTarget(backend: DualBackend, model: ModelEnv | undefined): Promise<DualTarget> {
+  const homeDir = await mkdtemp(join(tmpdir(), `klient-dual-${backend}-`));
+  let app: ReturnType<typeof bootstrap>['app'] | undefined;
+  let server: RunningServer | undefined;
+  let klient: Klient;
+  if (backend === 'memory') {
+    ({ app } = bootstrap({ homeDir }, [
+      ...logSeed(resolveLoggingConfig({ homeDir, env: process.env })),
+    ]));
+    klient = createMemoryKlient({ scope: app });
+  } else {
+    server = await startServer({ host: '127.0.0.1', port: 0, homeDir, logLevel: 'silent' });
+    klient = createHttpKlient({
+      url: `http://127.0.0.1:${server.port}`,
+      token: server.authTokenService.getToken(),
+    });
+  }
+  if (model !== undefined) {
+    await klient.global.models.set({
+      id: DUAL_MODEL_ID,
+      config: {
+        model: model.model,
+        apiKey: model.apiKey,
+        baseUrl: model.baseUrl,
+        protocol: model.protocol ?? 'openai',
+        maxContextSize: 262_144,
+      },
+    });
+  }
+  return {
+    klient,
+    cleanup: async () => {
+      await klient.close();
+      if (server !== undefined) await server.close();
+      app?.dispose();
+      await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+    },
+  };
+}
+
+export interface DualSuiteOptions {
+  /** Suite needs a working model; skipped when the env above is absent. */
+  readonly requiresModel?: boolean;
+}
+
+/** Poll an async predicate until it holds (or throw). */
+export async function waitFor(
+  predicate: () => Promise<boolean> | boolean,
+  timeoutMs: number,
+  intervalMs = 100,
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await predicate()) return;
+    await new Promise((resolve) => {
+      setTimeout(resolve, intervalMs);
+    });
+  }
+  throw new Error(`waitFor timed out after ${timeoutMs}ms`);
+}
+
+/** Resolve with the first payload of `name` (or reject on timeout). */
+export function onceEvent<TPayloadMap extends object, E extends keyof TPayloadMap & string>(
+  events: KlientEvents<TPayloadMap>,
+  name: E,
+  timeoutMs = 60_000,
+): Promise<TPayloadMap[E]> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      sub.dispose();
+      reject(new Error(`timed out waiting for event ${name}`));
+    }, timeoutMs);
+    const sub = events.on(name, (payload) => {
+      clearTimeout(timer);
+      sub.dispose();
+      resolve(payload);
+    });
+  });
+}
+
+/**
+ * `body` registers `it`s for BOTH backends; it receives a `klient` accessor
+ * valid inside tests (setup happens in `beforeAll`).
+ */
+export function defineDualSuite(
+  name: string,
+  options: DualSuiteOptions,
+  body: (ctx: { readonly backend: DualBackend; klient: () => Klient }) => void,
+): void {
+  const model = modelEnv();
+  const skip = options.requiresModel === true && model === undefined;
+  describe.skipIf(skip)(`dual: ${name}`, () => {
+    for (const backend of ['memory', 'http'] as const) {
+      describe(backend, () => {
+        let target: DualTarget;
+        beforeAll(async () => {
+          target = await makeTarget(backend, model);
+        });
+        afterAll(async () => {
+          await target.cleanup();
+        });
+        body({ backend, klient: () => target.klient });
+      });
+    }
+  });
+}
diff --git a/packages/klient/test/helpers/engine.ts b/packages/klient/test/helpers/engine.ts
new file mode 100644
index 000000000..bdb2904a4
--- /dev/null
+++ b/packages/klient/test/helpers/engine.ts
@@ -0,0 +1,26 @@
+/**
+ * Shared engine bootstrap for klient integration tests. Mirrors what
+ * kap-server does: `bootstrap()` plus the `ILogOptions` seed the
+ * Session-scoped log writer needs (bare `bootstrap({ homeDir })` leaves
+ * `logOptions` unregistered and any eager service depending on `ILogService`
+ * fails to instantiate).
+ */
+
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { bootstrap, logSeed, resolveLoggingConfig } from '@moonshot-ai/agent-core-v2';
+
+export interface TestEngine {
+  readonly homeDir: string;
+  readonly app: ReturnType<typeof bootstrap>['app'];
+}
+
+export async function makeEngine(prefix = 'klient-test-engine-'): Promise<TestEngine> {
+  const homeDir = await mkdtemp(join(tmpdir(), prefix));
+  const { app } = bootstrap({ homeDir }, [
+    ...logSeed(resolveLoggingConfig({ homeDir, env: process.env })),
+  ]);
+  return { homeDir, app };
+}
diff --git a/packages/klient/test/helpers/typeAssert.ts b/packages/klient/test/helpers/typeAssert.ts
new file mode 100644
index 000000000..f734368b1
--- /dev/null
+++ b/packages/klient/test/helpers/typeAssert.ts
@@ -0,0 +1,15 @@
+import type { z } from 'zod';
+
+export type MutableDeep<T> = T extends readonly (infer U)[]
+  ? MutableDeep<U>[]
+  : T extends object
+    ? { -readonly [K in keyof T]: MutableDeep<T[K]> }
+    : T;
+
+/** Both-ways assignability between a zod schema's infer and an engine type. */
+export type AssertWire<TSchema extends z.ZodType, TEngine> = ([
+  z.infer<TSchema>,
+] extends [MutableDeep<TEngine>]
+  ? true
+  : never) &
+  ([MutableDeep<TEngine>] extends [z.infer<TSchema>] ? true : never);
diff --git a/packages/klient/test/http-conformance.test.ts b/packages/klient/test/http-conformance.test.ts
new file mode 100644
index 000000000..285eb8299
--- /dev/null
+++ b/packages/klient/test/http-conformance.test.ts
@@ -0,0 +1,36 @@
+/**
+ * The http leg of the transport conformance suite — boots a real kap-server
+ * in-process (port 0) and runs the shared `defineKlientConformance`
+ * assertions over the http transport (events riding the lazy WS bridge).
+ * The memory/ipc legs live in `memory.test.ts` / `ipc.test.ts`.
+ */
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { startServer } from '@moonshot-ai/kap-server';
+
+import { createKlient } from '../src/transports/http/index.js';
+import { defineKlientConformance } from './helpers/conformance.js';
+
+defineKlientConformance('http', async () => {
+  const homeDir = await mkdtemp(join(tmpdir(), 'klient-conformance-http-'));
+  const server = await startServer({
+    host: '127.0.0.1',
+    port: 0,
+    homeDir,
+    logLevel: 'silent',
+  });
+  const klient = createKlient({
+    url: `http://127.0.0.1:${server.port}`,
+    token: server.authTokenService.getToken(),
+  });
+  return {
+    klient,
+    cleanup: async () => {
+      await klient.close();
+      await server.close();
+      await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+    },
+  };
+});
diff --git a/packages/klient/test/http.test.ts b/packages/klient/test/http.test.ts
new file mode 100644
index 000000000..57b95a1d9
--- /dev/null
+++ b/packages/klient/test/http.test.ts
@@ -0,0 +1,209 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createKlient } from '../src/transports/http/index.js';
+import type { WsLike, WsLikeCtor } from '../src/transports/ws/wsSocket.js';
+import { KlientValidationError } from '../src/core/validation.js';
+
+const tick = (ms = 0): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+type Listener = (event: never) => void;
+
+/** Minimal fake WS endpoint: records frames and lets the test push events. */
+class FakeWsServer {
+  readonly frames: Record<string, unknown>[] = [];
+  lastUrl = '';
+  lastProtocols: string[] | undefined;
+  private socket: FakeSocket | undefined;
+
+  attach(socket: FakeSocket): void {
+    this.socket = socket;
+    queueMicrotask(() => {
+      socket.readyState = FakeSocket.OPEN;
+      socket.fire('open');
+      this.send({ type: 'ready' });
+    });
+  }
+
+  receive(raw: string): void {
+    const frame = JSON.parse(raw) as Record<string, unknown>;
+    this.frames.push(frame);
+    if (frame['type'] === 'listen') {
+      this.send({ type: 'listen_result', id: frame['id'] });
+    }
+  }
+
+  pushEvent(data: unknown): void {
+    const listen = this.frames.find((frame) => frame['type'] === 'listen')!;
+    this.send({ type: 'event', id: listen['id'], data });
+  }
+
+  private send(frame: Record<string, unknown>): void {
+    this.socket?.deliver(frame);
+  }
+}
+
+class FakeSocket implements WsLike {
+  static readonly OPEN = 1;
+  readyState = 0;
+  private readonly handlers = new Map<string, Set<Listener>>();
+
+  constructor(
+    private readonly server: FakeWsServer,
+    url: string,
+    protocols?: string | string[],
+  ) {
+    server.lastUrl = url;
+    server.lastProtocols = Array.isArray(protocols) ? protocols : protocols ? [protocols] : undefined;
+    server.attach(this);
+  }
+
+  addEventListener(type: string, listener: Listener): void {
+    const set = this.handlers.get(type) ?? new Set<Listener>();
+    set.add(listener);
+    this.handlers.set(type, set);
+  }
+
+  send(data: string): void {
+    this.server.receive(data);
+  }
+
+  close(): void {
+    this.readyState = 3;
+    this.fire('close');
+  }
+
+  fire(type: string): void {
+    for (const handler of this.handlers.get(type) ?? []) handler(undefined as never);
+  }
+
+  deliver(frame: Record<string, unknown>): void {
+    queueMicrotask(() => {
+      for (const handler of this.handlers.get('message') ?? []) {
+        handler({ data: JSON.stringify(frame) } as never);
+      }
+    });
+  }
+}
+
+function fakeCtor(server: FakeWsServer): WsLikeCtor {
+  class BoundFakeSocket extends FakeSocket {
+    constructor(url: string, protocols?: string | string[]) {
+      super(server, url, protocols);
+    }
+  }
+  return BoundFakeSocket as unknown as WsLikeCtor;
+}
+
+function jsonResponse(envelope: Record<string, unknown>): Response {
+  return { json: () => Promise.resolve(envelope) } as unknown as Response;
+}
+
+function okEnvelope(data: unknown): Record<string, unknown> {
+  return { code: 0, msg: '', data, request_id: 'r1' };
+}
+
+describe('http transport', () => {
+  it('POSTs the args tuple to the scope service/method URL with the bearer header', async () => {
+    const fetchMock = vi.fn(() =>
+      Promise.resolve(
+        jsonResponse(
+          okEnvelope({
+            id: 's1',
+            workspaceId: 'w1',
+            createdAt: 1,
+            updatedAt: 2,
+            archived: false,
+          }),
+        ),
+      ),
+    );
+    const klient = createKlient({
+      url: 'http://127.0.0.1:58627/',
+      token: 'tok',
+      fetch: fetchMock as unknown as typeof fetch,
+    });
+
+    const summary = await klient.global.sessions.get('s1');
+    expect(summary?.id).toBe('s1');
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
+    expect(url).toBe('http://127.0.0.1:58627/api/v2/sessionIndex/get');
+    expect(init.method).toBe('POST');
+    expect((init.headers as Record<string, string>)['authorization']).toBe('Bearer tok');
+    expect(JSON.parse(init.body as string)).toEqual(['s1']);
+    await klient.close();
+  });
+
+  it('omits the body for zero-arg calls', async () => {
+    const fetchMock = vi.fn(() => Promise.resolve(jsonResponse(okEnvelope({}))));
+    const klient = createKlient({
+      url: 'http://127.0.0.1:58627',
+      fetch: fetchMock as unknown as typeof fetch,
+    });
+    await klient.global.config.getAll();
+    const [, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
+    expect(init.body).toBeUndefined();
+    await klient.close();
+  });
+
+  it('unwraps a non-zero envelope code into RPCError', async () => {
+    const fetchMock = vi.fn(() =>
+      Promise.resolve(jsonResponse({ code: 40001, msg: 'workspace not found', data: null, request_id: 'r' })),
+    );
+    const klient = createKlient({
+      url: 'http://127.0.0.1:58627',
+      fetch: fetchMock as unknown as typeof fetch,
+    });
+    await expect(klient.global.workspaces.get('nope')).rejects.toMatchObject({
+      name: 'RPCError',
+      code: 40001,
+    });
+    await klient.close();
+  });
+
+  it('rejects drifted output with KlientValidationError', async () => {
+    const fetchMock = vi.fn(() => Promise.resolve(jsonResponse(okEnvelope({ id: 42 }))));
+    const klient = createKlient({
+      url: 'http://127.0.0.1:58627',
+      fetch: fetchMock as unknown as typeof fetch,
+    });
+    await expect(klient.global.sessions.get('s1')).rejects.toBeInstanceOf(KlientValidationError);
+    await klient.close();
+  });
+
+  it('lazily opens one WS for events, sends emitter listen frames, and validates payloads', async () => {
+    const server = new FakeWsServer();
+    const fetchMock = vi.fn(() => Promise.resolve(jsonResponse(okEnvelope({}))));
+    const klient = createKlient({
+      url: 'http://127.0.0.1:58627',
+      token: 'tok',
+      fetch: fetchMock as unknown as typeof fetch,
+      WebSocketImpl: fakeCtor(server),
+    });
+
+    const seen: unknown[] = [];
+    const errors: Error[] = [];
+    klient.events.onError((error) => {
+        errors.push(error);
+      });
+    klient.events.on('providers.changed', (event) => seen.push(event));
+    await tick(10);
+
+    expect(server.lastUrl).toBe('ws://127.0.0.1:58627/api/v2/ws');
+    expect(server.lastProtocols).toEqual(['kimi-code.bearer.tok']);
+    const listen = server.frames.find((frame) => frame['type'] === 'listen')!;
+    expect(listen).toMatchObject({
+      scope: 'core',
+      service: 'providerService',
+      event: 'onDidChangeProviders',
+    });
+
+    server.pushEvent({ added: ['p1'], removed: [], changed: [] });
+    server.pushEvent({ added: 1 });
+    await tick(10);
+    expect(seen).toEqual([{ added: ['p1'], removed: [], changed: [] }]);
+    expect(errors).toHaveLength(1);
+
+    await klient.close();
+  });
+});
diff --git a/packages/klient/test/ipc.test.ts b/packages/klient/test/ipc.test.ts
new file mode 100644
index 000000000..0019acc77
--- /dev/null
+++ b/packages/klient/test/ipc.test.ts
@@ -0,0 +1,74 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { describe, expect, it } from 'vitest';
+
+import { defineKlientConformance } from './helpers/conformance.js';
+import { createKlient, serveKlientIpc, type KlientIpcHost } from '../src/transports/ipc/index.js';
+import { makeEngine, type TestEngine } from './helpers/engine.js';
+
+defineKlientConformance('ipc', async () => {
+  const { homeDir, app } = await makeEngine();
+  const socketPath = join(homeDir, 'klient.sock');
+  const host = await serveKlientIpc({ scope: app, socketPath });
+  const klient = createKlient({ socketPath });
+  return {
+    klient,
+    cleanup: async () => {
+      await klient.close();
+      await host.close();
+      app.dispose();
+      await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+    },
+  };
+});
+
+describe('ipc transport specifics', () => {
+  let homeDir: string;
+  let app: TestEngine['app'];
+  let host: KlientIpcHost | undefined;
+
+  async function setup(opts: { token?: string } = {}): Promise<string> {
+    ({ homeDir, app } = await makeEngine());
+    const socketPath = join(homeDir, 'klient.sock');
+    host = await serveKlientIpc({ scope: app, socketPath, token: opts.token });
+    return socketPath;
+  }
+
+  async function teardown(): Promise<void> {
+    await host?.close();
+    host = undefined;
+    app.dispose();
+    await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+  }
+
+  it('rejects calls when the socket path does not exist', async () => {
+    const klient = createKlient({ socketPath: join(tmpdir(), 'klient-no-such.sock') });
+    await expect(klient.global.env()).rejects.toThrow();
+    await klient.close();
+  });
+
+  it('rejects calls made after close', async () => {
+    const socketPath = await setup();
+    const klient = createKlient({ socketPath });
+    await klient.global.env();
+    await klient.close();
+    // env() is served from its frozen-snapshot cache after the first call, so
+    // probe the closed channel with an uncached method instead.
+    await expect(klient.global.workspaces.list()).rejects.toThrow('ipc closed');
+    await teardown();
+  });
+
+  it('drops clients whose hello token mismatches', async () => {
+    const socketPath = await setup({ token: 'right' });
+    const klient = createKlient({ socketPath, token: 'wrong' });
+    await expect(klient.global.env()).rejects.toThrow();
+    await klient.close();
+
+    const ok = createKlient({ socketPath, token: 'right' });
+    await expect(ok.global.env()).resolves.toMatchObject({ platform: process.platform });
+    await ok.close();
+    await teardown();
+  });
+});
diff --git a/packages/klient/test/memory.test.ts b/packages/klient/test/memory.test.ts
new file mode 100644
index 000000000..074d5e865
--- /dev/null
+++ b/packages/klient/test/memory.test.ts
@@ -0,0 +1,71 @@
+import { rm } from 'node:fs/promises';
+
+import { describe, expect, it } from 'vitest';
+
+import { defineKlientConformance } from './helpers/conformance.js';
+import { createKlient } from '../src/transports/memory/index.js';
+import { createMemoryDispatcher } from '../src/transports/memory/dispatcher.js';
+import { RPCError } from '../src/core/errors.js';
+import { makeEngine } from './helpers/engine.js';
+
+defineKlientConformance('memory', async () => {
+  const { homeDir, app } = await makeEngine();
+  const klient = createKlient({ scope: app });
+  return {
+    klient,
+    cleanup: async () => {
+      await klient.close();
+      app.dispose();
+      await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+    },
+  };
+});
+
+describe('memory dispatcher specifics', () => {
+  it('rejects unknown services and methods with RPCError(40001)', async () => {
+    const { homeDir, app } = await makeEngine();
+    const dispatcher = createMemoryDispatcher(app);
+    await expect(dispatcher.call({}, 'noSuchService', 'get', [])).rejects.toMatchObject({
+      name: 'RPCError',
+      code: 40001,
+    });
+    await expect(dispatcher.call({}, 'sessionIndex', 'noSuchMethod', [])).rejects.toMatchObject({
+      name: 'RPCError',
+      code: 40001,
+    });
+    app.dispose();
+    await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+  });
+
+  it('reads non-function members as properties', async () => {
+    const { homeDir, app } = await makeEngine();
+    const dispatcher = createMemoryDispatcher(app);
+    await expect(dispatcher.call({}, 'bootstrapService', 'platform', [])).resolves.toBe(
+      process.platform,
+    );
+    app.dispose();
+    await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+  });
+
+  it('rejects session/agent scopes for now', async () => {
+    const { homeDir, app } = await makeEngine();
+    const dispatcher = createMemoryDispatcher(app);
+    await expect(
+      dispatcher.call({ sessionId: 's1' }, 'sessionIndex', 'list', [{}]),
+    ).rejects.toBeInstanceOf(RPCError);
+    app.dispose();
+    await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+  });
+
+  it('delivers wire-cloned payloads (no live object identity)', async () => {
+    const { homeDir, app } = await makeEngine();
+    const klient = createKlient({ scope: app });
+    const list = await klient.global.workspaces.list();
+    // Mutating the result must not affect what a second call returns.
+    (list as unknown[]).push({ id: 'polluted' });
+    const again = await klient.global.workspaces.list();
+    expect(again.some((w) => w.id === 'polluted')).toBe(false);
+    app.dispose();
+    await rm(homeDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+  });
+});
diff --git a/packages/klient/test/ws.test.ts b/packages/klient/test/wsSocket.test.ts
similarity index 64%
rename from packages/klient/test/ws.test.ts
rename to packages/klient/test/wsSocket.test.ts
index 6da4ebd63..3de5f980a 100644
--- a/packages/klient/test/ws.test.ts
+++ b/packages/klient/test/wsSocket.test.ts
@@ -1,11 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
-import { ISessionIndex } from '@moonshot-ai/agent-core-v2/app/sessionIndex/sessionIndex';
-import { ISessionMetadata } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetadata';
-
-import { Klient } from '../src/client.js';
-import { WsKlient } from '../src/wsKlient.js';
-import type { WsLike, WsLikeCtor, WsSocketState } from '../src/wsSocket.js';
+import type { WsLike, WsLikeCtor, WsSocketState } from '../src/transports/ws/wsSocket.js';
+import { WsSocket } from '../src/transports/ws/wsSocket.js';
 
 const tick = (ms = 0): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -154,55 +150,55 @@ function fakeCtor(server: FakeServer): WsLikeCtor {
   return BoundFakeSocket as unknown as WsLikeCtor;
 }
 
-async function openKlient(server: FakeServer, opts: { token?: string } = {}): Promise<WsKlient> {
-  const ws = new WsKlient({
+async function openSocket(server: FakeServer, opts: { token?: string } = {}): Promise<WsSocket> {
+  const socket = new WsSocket({
     url: 'http://127.0.0.1:58627',
     token: opts.token,
     WebSocketImpl: fakeCtor(server),
     reconnectDelayMs: 10,
   });
   await tick(5);
-  return ws;
+  return socket;
 }
 
-describe('WsKlient', () => {
+describe('WsSocket', () => {
   it('routes calls by scope / service / method with scope ids', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
+    const socket = await openSocket(server);
 
-    const core = await ws.core(ISessionIndex).list({ workspaceId: 'w1' });
-    const session = await ws.session('s1').service(ISessionMetadata).read();
-    const agent = await ws.session('s1').agent('a1').service(ISessionMetadata).read();
+    const core = await socket.call('core', 'sessionIndex', 'list', [{ workspaceId: 'w1' }]);
+    const agent = await socket.call('agent', 'sessionMetadata', 'read', undefined, {
+      sessionId: 's1',
+      agentId: 'a1',
+    });
 
     expect(core).toMatchObject({ scope: 'core', service: 'sessionIndex', method: 'list' });
-    expect(session).toMatchObject({ scope: 'session', service: 'sessionMetadata', sessionId: 's1' });
     expect(agent).toMatchObject({
       scope: 'agent',
       service: 'sessionMetadata',
       sessionId: 's1',
       agentId: 'a1',
     });
-    ws.close();
+    socket.close();
   });
 
   it('rejects calls with RPCError on error frames', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
-    const meta = ws.session('s1').service(ISessionMetadata) as unknown as {
-      boom(): Promise<unknown>;
-    };
-    await expect(meta.boom()).rejects.toMatchObject({
+    const socket = await openSocket(server);
+    await expect(socket.call('core', 'sessionMetadata', 'boom')).rejects.toMatchObject({
       name: 'RPCError',
       code: 40001,
     });
-    ws.close();
+    socket.close();
   });
 
   it('delivers events to listen handlers and sends unlisten on dispose', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
+    const socket = await openSocket(server);
     const seen: unknown[] = [];
-    const sub = ws.session('s1').listen('interactions', (data) => seen.push(data));
+    const sub = socket.listen('session', 'interactions', { sessionId: 's1' }, (data) =>
+      seen.push(data),
+    );
     await tick(5);
     const listenId = [...server.listens][0]!;
     server.pushEvent(listenId, [{ id: 'a1' }]);
@@ -211,20 +207,22 @@ describe('WsKlient', () => {
 
     sub.dispose();
     expect(server.listens.size).toBe(0);
-    ws.close();
+    socket.close();
   });
 
-  it('proxies Service events with one remote subscription for first/last listeners', async () => {
+  it('subscribes service emitters with the service name on the frame', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
-    const service = ws.session('s1').service(ISessionMetadata);
-    const first: unknown[] = [];
-    const second: unknown[] = [];
-    const a = service.onDidChangeMetadata((event) => first.push(event));
-    const b = service.onDidChangeMetadata((event) => second.push(event));
+    const socket = await openSocket(server);
+    const seen: unknown[] = [];
+    const sub = socket.listen(
+      'session',
+      'onDidChangeMetadata',
+      { sessionId: 's1' },
+      (data) => seen.push(data),
+      'sessionMetadata',
+    );
     await tick(5);
 
-    expect(server.listens.size).toBe(1);
     const listen = server.frames.find((frame) => frame['type'] === 'listen')!;
     expect(listen).toMatchObject({
       scope: 'session',
@@ -234,41 +232,31 @@ describe('WsKlient', () => {
     });
     server.pushEvent(listen['id'] as string, { title: 'updated' });
     await tick(5);
-    expect(first).toEqual([{ title: 'updated' }]);
-    expect(second).toEqual([{ title: 'updated' }]);
-
-    a.dispose();
-    expect(server.listens.size).toBe(1);
-    b.dispose();
-    expect(server.listens.size).toBe(0);
-    ws.close();
+    expect(seen).toEqual([{ title: 'updated' }]);
+    sub.dispose();
+    socket.close();
   });
 
   it('reports asynchronous subscription errors and terminates the subscription', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
+    const socket = await openSocket(server);
     const errors: string[] = [];
-    ws.onDidListenError((event) => errors.push(event.error.message));
-    const service = ws.session('s1').service(ISessionMetadata);
-    service.onDidChangeMetadata(() => undefined);
+    socket.onDidListenError((event) => errors.push(event.error.message));
+    socket.listen('session', 'onDidChangeMetadata', { sessionId: 's1' }, () => undefined, 'sessionMetadata');
     await tick(5);
     const id = [...server.listens][0]!;
     server.pushError(id, 'payload is not serializable');
     await tick(5);
     expect(errors).toEqual(['payload is not serializable']);
-    ws.close();
+    socket.close();
   });
 
   it('waits for onWill listener work and aborts it on server cancel', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
-    const service = ws.session('s1').service(ISessionMetadata) as unknown as {
-      onWillSave(listener: (event: { signal: AbortSignal; waitUntil(p: Promise<unknown>): void }) => void): {
-        dispose(): void;
-      };
-    };
+    const socket = await openSocket(server);
     let aborted = false;
-    service.onWillSave((event) => {
+    socket.listen('session', 'onWillSave', { sessionId: 's1' }, (raw) => {
+      const event = raw as { signal: AbortSignal; waitUntil(p: Promise<unknown>): void };
       event.signal.addEventListener('abort', () => {
         aborted = true;
       });
@@ -283,34 +271,34 @@ describe('WsKlient', () => {
     await tick(5);
     expect(aborted).toBe(true);
     expect(server.frames.some((frame) => frame['type'] === 'event_result')).toBe(false);
-    ws.close();
+    socket.close();
   });
 
   it('answers heartbeat pings with pong', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
+    const socket = await openSocket(server);
     server.ping();
     await tick(5);
     expect(server.pongs).toBe(1);
-    ws.close();
+    socket.close();
   });
 
   it('reconnects after a drop: calls reject, listens re-subscribe, state is observable', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
+    const socket = await openSocket(server);
     const states: WsSocketState[] = [];
-    ws.onDidChangeState((s) => states.push(s));
+    socket.onDidChangeState((s) => states.push(s));
     const seen: unknown[] = [];
-    ws.session('s1').agent('a1').listen('events', (data) => seen.push(data));
+    socket.listen('agent', 'events', { sessionId: 's1', agentId: 'a1' }, (data) => seen.push(data));
     await tick(5);
 
-    const inFlight = ws.core(ISessionIndex).countActive('w1');
+    const inFlight = socket.call('core', 'sessionIndex', 'countActive', ['w1']);
     server.drop();
     await expect(inFlight).rejects.toThrow('ws closed');
-    expect(ws.state).toBe('connecting');
+    expect(socket.currentState).toBe('connecting');
 
     await tick(50); // backoff 10ms → reconnect
-    expect(ws.state).toBe('open');
+    expect(socket.currentState).toBe('open');
     expect(server.helloCount).toBe(2);
     expect(server.listens.size).toBe(1);
 
@@ -319,52 +307,26 @@ describe('WsKlient', () => {
     await tick(5);
     expect(seen).toEqual([{ type: 'turn.started' }]);
 
-    const data = await ws.core(ISessionIndex).countActive('w1');
+    const data = await socket.call('core', 'sessionIndex', 'countActive', ['w1']);
     expect(data).toMatchObject({ method: 'countActive' });
     expect(states).toContain('connecting');
-    ws.close();
-    expect(ws.state).toBe('closed');
+    socket.close();
+    expect(socket.currentState).toBe('closed');
   });
 
-  it('Klient.ws() is a lazy singleton deriving the ws URL and bearer subprotocol', async () => {
+  it('derives the ws URL and presents the bearer subprotocol', async () => {
     const server = new FakeServer();
-    const client = new Klient({
-      url: 'http://127.0.0.1:58627',
-      token: 'tok',
-      WebSocketImpl: fakeCtor(server),
-    });
-    const ws = client.ws();
-    expect(client.ws()).toBe(ws);
+    const socket = await openSocket(server, { token: 'tok' });
     await tick(5);
     expect(server.lastUrl).toBe('ws://127.0.0.1:58627/api/v2/ws');
     expect(server.lastProtocols).toEqual(['kimi-code.bearer.tok']);
-    const data = await ws.core(ISessionIndex).list({});
-    expect(data).toMatchObject({ service: 'sessionIndex' });
-    ws.close();
+    socket.close();
   });
 
   it('rejects calls made after close', async () => {
     const server = new FakeServer();
-    const ws = await openKlient(server);
-    ws.close();
-    await expect(ws.core(ISessionIndex).list({})).rejects.toThrow('ws closed');
-  });
-
-  it('Klient.ws() recreates a fresh socket after the previous one was closed', async () => {
-    const server = new FakeServer();
-    const client = new Klient({
-      url: 'http://127.0.0.1:58627',
-      WebSocketImpl: fakeCtor(server),
-    });
-    const first = client.ws();
-    await tick(5);
-    first.close();
-    const second = client.ws();
-    expect(second).not.toBe(first);
-    await tick(5);
-    expect(second.state).toBe('open');
-    const data = await second.core(ISessionIndex).list({});
-    expect(data).toMatchObject({ service: 'sessionIndex' });
-    second.close();
+    const socket = await openSocket(server);
+    socket.close();
+    await expect(socket.call('core', 'sessionIndex', 'list', [{}])).rejects.toThrow('ws closed');
   });
 });
diff --git a/packages/klient/tsconfig.examples.json b/packages/klient/tsconfig.examples.json
new file mode 100644
index 000000000..3272f041c
--- /dev/null
+++ b/packages/klient/tsconfig.examples.json
@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["examples/**/*.ts", "../agent-core-v2/src"]
+}
diff --git a/packages/klient/tsconfig.json b/packages/klient/tsconfig.json
index ef502e89c..dca1267d5 100644
--- a/packages/klient/tsconfig.json
+++ b/packages/klient/tsconfig.json
@@ -1,4 +1,4 @@
 {
   "extends": "../../tsconfig.json",
-  "include": ["src", "test"]
+  "include": ["src", "test", "scenarios", "scripts", "../agent-core-v2/src/env.d.ts"]
 }
diff --git a/packages/klient/tsdown.config.ts b/packages/klient/tsdown.config.ts
index b27e00afd..2388b63e5 100644
--- a/packages/klient/tsdown.config.ts
+++ b/packages/klient/tsdown.config.ts
@@ -1,7 +1,12 @@
 import { defineConfig } from 'tsdown';
 
 export default defineConfig({
-  entry: ['./src/index.ts'],
+  entry: [
+    './src/index.ts',
+    './src/transports/http/index.ts',
+    './src/transports/ipc/index.ts',
+    './src/transports/memory/index.ts',
+  ],
   format: ['esm'],
   dts: false,
   outDir: 'dist',
diff --git a/packages/klient/vitest.config.ts b/packages/klient/vitest.config.ts
index 02890dfb7..b5a71f285 100644
--- a/packages/klient/vitest.config.ts
+++ b/packages/klient/vitest.config.ts
@@ -4,5 +4,6 @@ export default defineConfig({
   test: {
     name: 'klient',
     include: ['test/**/*.test.ts'],
+    reporters: ['default', './test/e2e/legacy/report/vitest-reporter.ts'],
   },
 });
diff --git a/packages/kosong/src/errors.ts b/packages/kosong/src/errors.ts
index 44aa24937..9f0862e75 100644
--- a/packages/kosong/src/errors.ts
+++ b/packages/kosong/src/errors.ts
@@ -43,18 +43,27 @@ export class APIStatusError extends ChatProviderError {
    * exponential delay.
    */
   readonly retryAfterMs: number | null;
+  /**
+   * Provider trace identifier from the `x-trace-id` response header
+   * (Kimi/KFC only), or `null` when the error response did not carry one.
+   * A failed request usually still returns response headers, so hosts can
+   * attribute the failure to its server-side request.
+   */
+  readonly traceId: string | null;
 
   constructor(
     statusCode: number,
     message: string,
     requestId?: string | null,
     retryAfterMs?: number | null,
+    traceId?: string | null,
   ) {
     super(message);
     this.name = 'APIStatusError';
     this.statusCode = statusCode;
     this.requestId = requestId ?? null;
     this.retryAfterMs = retryAfterMs ?? null;
+    this.traceId = traceId ?? null;
   }
 }
 
@@ -68,8 +77,9 @@ export class APIContextOverflowError extends APIStatusError {
     message: string,
     requestId?: string | null,
     retryAfterMs?: number | null,
+    traceId?: string | null,
   ) {
-    super(statusCode, message, requestId, retryAfterMs);
+    super(statusCode, message, requestId, retryAfterMs, traceId);
     this.name = 'APIContextOverflowError';
   }
 }
@@ -86,8 +96,9 @@ export class APIRequestTooLargeError extends APIStatusError {
     message: string,
     requestId?: string | null,
     retryAfterMs?: number | null,
+    traceId?: string | null,
   ) {
-    super(statusCode, message, requestId, retryAfterMs);
+    super(statusCode, message, requestId, retryAfterMs, traceId);
     this.name = 'APIRequestTooLargeError';
   }
 }
@@ -97,8 +108,13 @@ export class APIRequestTooLargeError extends APIStatusError {
  * request.
  */
 export class APIProviderRateLimitError extends APIStatusError {
-  constructor(message: string, requestId?: string | null, retryAfterMs?: number | null) {
-    super(429, message, requestId, retryAfterMs);
+  constructor(
+    message: string,
+    requestId?: string | null,
+    retryAfterMs?: number | null,
+    traceId?: string | null,
+  ) {
+    super(429, message, requestId, retryAfterMs, traceId);
     this.name = 'APIProviderRateLimitError';
   }
 }
@@ -329,26 +345,52 @@ export function normalizeAPIStatusError(
   message: string,
   requestId?: string | null,
   retryAfterMs?: number | null,
+  traceId?: string | null,
 ): APIStatusError {
   if (statusCode === 429) {
-    return new APIProviderRateLimitError(message, requestId, retryAfterMs);
+    return new APIProviderRateLimitError(message, requestId, retryAfterMs, traceId);
   }
   // Context overflow first: Vertex returns prompt-too-long as a 413, and a
   // token overflow must keep routing to compaction even on that status.
   if (isContextOverflowStatusError(statusCode, message)) {
-    return new APIContextOverflowError(statusCode, message, requestId, retryAfterMs);
+    return new APIContextOverflowError(statusCode, message, requestId, retryAfterMs, traceId);
   }
   if (isRequestTooLargeStatusError(statusCode, message)) {
-    return new APIRequestTooLargeError(statusCode, message, requestId, retryAfterMs);
+    return new APIRequestTooLargeError(statusCode, message, requestId, retryAfterMs, traceId);
   }
   return new APIStatusError(
     statusCode,
     appendThinkingEffortConfigHint(statusCode, message),
     requestId,
     retryAfterMs,
+    traceId,
   );
 }
 
+/**
+ * Read a single response header from an unknown headers-like object (anything
+ * exposing a `get(name)` method, e.g. the Fetch `Headers` the SDKs carry on
+ * their errors). Returns `null` when the object is not headers-like or the
+ * header is absent.
+ */
+function readResponseHeader(headers: unknown, name: string): string | null {
+  return headers !== null &&
+    typeof headers === 'object' &&
+    typeof (headers as { get?: unknown }).get === 'function'
+    ? (headers as { get(name: string): string | null }).get(name)
+    : null;
+}
+
+/**
+ * Parse the provider trace identifier from the `x-trace-id` response header
+ * (Kimi/KFC only). Returns `null` when the header is absent or empty.
+ */
+export function parseTraceId(headers: unknown): string | null {
+  const raw = readResponseHeader(headers, 'x-trace-id');
+  if (raw === null || raw === undefined || raw.length === 0) return null;
+  return raw;
+}
+
 /**
  * Parse a `retry-after` response header into milliseconds. Only integer
  * seconds is honored; an HTTP-date (or any non-integer / missing value)
@@ -357,12 +399,7 @@ export function normalizeAPIStatusError(
  * backoff directive.
  */
 export function parseRetryAfterMs(headers: unknown): number | null {
-  const raw =
-    headers !== null &&
-    typeof headers === 'object' &&
-    typeof (headers as { get?: unknown }).get === 'function'
-      ? (headers as { get(name: string): string | null }).get('retry-after')
-      : null;
+  const raw = readResponseHeader(headers, 'retry-after');
   if (raw === null || raw === undefined) return null;
   const seconds = Number.parseInt(raw, 10);
   if (!Number.isFinite(seconds) || seconds < 0) return null;
diff --git a/packages/kosong/src/generate.ts b/packages/kosong/src/generate.ts
index 5d6a90608..626dc3073 100644
--- a/packages/kosong/src/generate.ts
+++ b/packages/kosong/src/generate.ts
@@ -39,6 +39,11 @@ export interface GenerateResult {
    * `null` if the provider did not emit one.
    */
   readonly rawFinishReason: string | null;
+  /**
+   * Provider trace identifier from the `x-trace-id` response header
+   * (Kimi/KFC only), or `null` when the provider does not report one.
+   */
+  readonly traceId?: string | null;
 }
 
 export interface GenerateCallbacks {
@@ -113,6 +118,12 @@ export async function generate(
 
   options?.onRequestStart?.();
   const stream = await provider.generate(systemPrompt, wireTools, history, options);
+  // Early capture: the trace id arrives with the response headers, before the
+  // stream body — and before any mid-stream abort — so hosts can attribute
+  // even a cancelled stream to its server-side request.
+  if (stream.traceId !== undefined) {
+    options?.onTraceId?.(stream.traceId);
+  }
 
   // Post-await abort check: `provider.generate()` may have resolved before
   // noticing a mid-flight abort. Reject immediately rather than draining
@@ -241,13 +252,17 @@ export async function generate(
     }
   }
 
-  return {
+  const result: GenerateResult = {
     id: stream.id,
     message,
     usage: stream.usage,
     finishReason: stream.finishReason,
     rawFinishReason: stream.rawFinishReason,
   };
+  if (stream.traceId !== undefined) {
+    return { ...result, traceId: stream.traceId };
+  }
+  return result;
 }
 
 type CancelableStream = StreamedMessage & {
diff --git a/packages/kosong/src/provider.ts b/packages/kosong/src/provider.ts
index ddcc30f87..905b12c15 100644
--- a/packages/kosong/src/provider.ts
+++ b/packages/kosong/src/provider.ts
@@ -110,6 +110,14 @@ export interface StreamedMessage {
    * `null` if the provider did not emit a finish_reason.
    */
   readonly rawFinishReason: string | null;
+  /**
+   * Provider trace identifier read from the `x-trace-id` response header
+   * (Kimi/KFC only). Available as soon as the response headers arrive —
+   * before the stream body is drained — so hosts can attribute even an
+   * interrupted stream to its server-side request. `null` when the provider
+   * does not report one.
+   */
+  readonly traceId?: string | null;
 }
 
 /**
@@ -156,6 +164,14 @@ export interface GenerateOptions {
    * attribute latency to the client vs. the API server.
    */
   onRequestSent?: () => void;
+  /**
+   * Host-side instrumentation hook fired as soon as the provider response
+   * headers arrive (before the stream body is drained), carrying the
+   * provider trace identifier from the `x-trace-id` header, or `null` when
+   * the provider does not report one. Firing early lets hosts attribute a
+   * stream that is cancelled mid-flight to its server-side request.
+   */
+  onTraceId?: (traceId: string | null) => void;
   /**
    * Host-side instrumentation hook fired after the provider stream is fully
    * drained, before post-processing the assembled response. Receives the
diff --git a/packages/kosong/src/providers/anthropic-profile.ts b/packages/kosong/src/providers/anthropic-profile.ts
new file mode 100644
index 000000000..0650bd8fb
--- /dev/null
+++ b/packages/kosong/src/providers/anthropic-profile.ts
@@ -0,0 +1,154 @@
+/**
+ * Anthropic effort and thinking profiles, matched from model identifiers.
+ * Keep this matrix aligned with:
+ * https://platform.claude.com/docs/en/build-with-claude/effort
+ * https://platform.claude.com/docs/en/build-with-claude/extended-thinking
+ */
+
+export type AnthropicThinkingMode = 'budget' | 'adaptive';
+
+export interface AnthropicModelProfile {
+  readonly mode: AnthropicThinkingMode;
+  readonly efforts: readonly string[];
+  readonly supportsEffortParam: boolean;
+  readonly canDisableThinking: boolean;
+}
+
+export type AnthropicModelFamily = 'opus' | 'sonnet' | 'haiku' | 'fable' | 'mythos';
+
+export interface AnthropicModelVersion {
+  readonly family: AnthropicModelFamily;
+  readonly major: number;
+  readonly minor: number | null;
+}
+
+export const BUDGET_THINKING_EFFORTS = ['low', 'medium', 'high'] as const;
+const ADAPTIVE_MAX_EFFORTS = ['low', 'medium', 'high', 'max'] as const;
+export const LATEST_OPUS_THINKING_EFFORTS = [
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+] as const;
+
+const BUDGET_PROFILE: AnthropicModelProfile = {
+  mode: 'budget',
+  efforts: BUDGET_THINKING_EFFORTS,
+  supportsEffortParam: false,
+  canDisableThinking: true,
+};
+
+const OPUS_45_PROFILE: AnthropicModelProfile = {
+  ...BUDGET_PROFILE,
+  supportsEffortParam: true,
+};
+
+const ADAPTIVE_MAX_PROFILE: AnthropicModelProfile = {
+  mode: 'adaptive',
+  efforts: ADAPTIVE_MAX_EFFORTS,
+  supportsEffortParam: true,
+  canDisableThinking: true,
+};
+
+export const LATEST_OPUS_PROFILE: AnthropicModelProfile = {
+  mode: 'adaptive',
+  efforts: LATEST_OPUS_THINKING_EFFORTS,
+  supportsEffortParam: true,
+  canDisableThinking: true,
+};
+
+const ALWAYS_ADAPTIVE_PROFILE: AnthropicModelProfile = {
+  ...LATEST_OPUS_PROFILE,
+  canDisableThinking: false,
+};
+
+const ALWAYS_ADAPTIVE_MAX_PROFILE: AnthropicModelProfile = {
+  ...ADAPTIVE_MAX_PROFILE,
+  canDisableThinking: false,
+};
+
+const FAMILY_FIRST_RE =
+  /(opus|sonnet|haiku|fable|mythos)[-._](\d{1,2})(?!\d)(?:[-._](\d{1,2})(?!\d))?/;
+const VERSION_FIRST_RE = /(\d{1,2})[-._](\d{1,2})[-._](opus|sonnet|haiku)/;
+const BARE_FAMILY_RE = /(\d{1,2})[-._](opus|sonnet|haiku)/;
+
+export function parseAnthropicModelVersion(
+  model: string,
+  requireClaudeMarker = false,
+): AnthropicModelVersion | null {
+  const normalized = model.toLowerCase();
+  if (requireClaudeMarker && !normalized.includes('claude')) return null;
+
+  const familyFirst = FAMILY_FIRST_RE.exec(normalized);
+  if (familyFirst !== null) {
+    return {
+      family: familyFirst[1] as AnthropicModelFamily,
+      major: Number.parseInt(familyFirst[2]!, 10),
+      minor: familyFirst[3] !== undefined ? Number.parseInt(familyFirst[3], 10) : null,
+    };
+  }
+
+  const versionFirst = VERSION_FIRST_RE.exec(normalized);
+  if (versionFirst !== null) {
+    return {
+      major: Number.parseInt(versionFirst[1]!, 10),
+      minor: Number.parseInt(versionFirst[2]!, 10),
+      family: versionFirst[3] as AnthropicModelFamily,
+    };
+  }
+
+  const bare = BARE_FAMILY_RE.exec(normalized);
+  if (bare !== null) {
+    return {
+      major: Number.parseInt(bare[1]!, 10),
+      minor: null,
+      family: bare[2] as AnthropicModelFamily,
+    };
+  }
+
+  return null;
+}
+
+export function matchKnownAnthropicModelProfile(
+  model: string,
+): AnthropicModelProfile | undefined {
+  const normalized = model.toLowerCase();
+  if (/mythos[-._]preview/.test(normalized)) return ALWAYS_ADAPTIVE_MAX_PROFILE;
+
+  const version = parseAnthropicModelVersion(model);
+  if (version === null) return undefined;
+
+  switch (version.family) {
+    case 'opus':
+      if (version.major === 4 && (version.minor === 7 || version.minor === 8)) {
+        return LATEST_OPUS_PROFILE;
+      }
+      if (version.major === 4 && version.minor === 6) return ADAPTIVE_MAX_PROFILE;
+      if (version.major === 4 && version.minor === 5) return OPUS_45_PROFILE;
+      if (version.major < 4 || (version.major === 4 && (version.minor ?? 0) < 5)) {
+        return BUDGET_PROFILE;
+      }
+      return undefined;
+    case 'sonnet':
+      if (version.major === 5) return LATEST_OPUS_PROFILE;
+      if (version.major === 4 && version.minor === 6) return ADAPTIVE_MAX_PROFILE;
+      if (version.major < 4 || (version.major === 4 && (version.minor ?? 0) <= 5)) {
+        return BUDGET_PROFILE;
+      }
+      return undefined;
+    case 'haiku':
+      if (version.major < 4 || (version.major === 4 && (version.minor ?? 0) <= 5)) {
+        return BUDGET_PROFILE;
+      }
+      return undefined;
+    case 'fable':
+      return version.major === 5 ? ALWAYS_ADAPTIVE_PROFILE : undefined;
+    case 'mythos':
+      return version.major === 5 ? ALWAYS_ADAPTIVE_PROFILE : undefined;
+  }
+}
+
+export function inferAnthropicModelProfile(model: string): AnthropicModelProfile {
+  return matchKnownAnthropicModelProfile(model) ?? LATEST_OPUS_PROFILE;
+}
diff --git a/packages/kosong/src/providers/anthropic.ts b/packages/kosong/src/providers/anthropic.ts
index d538d11ac..43e4d7ca8 100644
--- a/packages/kosong/src/providers/anthropic.ts
+++ b/packages/kosong/src/providers/anthropic.ts
@@ -41,6 +41,14 @@ import type {
   ToolUseBlockParam,
 } from '@anthropic-ai/sdk/resources/messages/messages.js';
 
+import {
+  BUDGET_THINKING_EFFORTS,
+  inferAnthropicModelProfile,
+  matchKnownAnthropicModelProfile,
+  parseAnthropicModelVersion,
+  type AnthropicModelProfile,
+  type AnthropicModelVersion,
+} from './anthropic-profile';
 import { mergeConsecutiveUserMessages } from './merge-user-messages';
 import { mergeRequestHeaders, resolveAuthBackedClient } from './request-auth';
 import {
@@ -96,6 +104,12 @@ export interface AnthropicOptions {
    * encode a parseable Claude version. Leave undefined to infer from the name.
    */
   adaptiveThinking?: boolean | undefined;
+  /**
+   * Concrete thinking efforts declared by the model catalog. When omitted,
+   * the provider infers a Claude profile from the model name and falls back to
+   * the latest Opus profile for unrecognized Anthropic-compatible models.
+   */
+  supportEfforts?: readonly string[] | undefined;
   kimiThinking?: boolean | undefined;
   /**
    * Use the Anthropic **beta** Messages API (`client.beta.messages.create`,
@@ -133,9 +147,6 @@ interface AnthropicContextManagement {
 const INTERLEAVED_THINKING_BETA = 'interleaved-thinking-2025-05-14';
 const CONTEXT_MANAGEMENT_BETA = 'context-management-2025-06-27';
 const CLEAR_THINKING_EDIT = 'clear_thinking_20251015';
-const ADAPTIVE_MIN_VERSION = { major: 4, minor: 6 } as const;
-const THINKING_EFFORT_CONFIG_DOCS_URL =
-  'https://moonshotai.github.io/kimi-code/en/configuration/config-files.html#thinking';
 const ANTHROPIC_TOOL_CALL_ID_POLICY: ToolCallIdPolicy = {
   normalize: (id) => sanitizeToolCallId(id, 64),
   maxLength: 64,
@@ -178,6 +189,7 @@ function applyResponseFormat(
 const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
   // Claude Fable 5 documents a 128k output ceiling.
   'fable-5': 128000,
+  'mythos-5': 128000,
   // Claude Opus per minor version. 4.6 through 4.8 document a 128k cap;
   // 4.5 ships at 64k; 4.1 and the dated 4.0 release stay at 32k.
   'opus-4-8': 128000,
@@ -187,8 +199,9 @@ const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
   'opus-4-1': 32000,
   'opus-4-0': 32000,
   'opus-4': 32000,
-  // Claude Sonnet 4.x: 4.0 / 4.5 / 4.6 all document a 64k ceiling.
-  'sonnet-4-6': 64000,
+  // Claude Sonnet 5 and 4.6 document a 128k ceiling; older 4.x stays at 64k.
+  'sonnet-5': 128000,
+  'sonnet-4-6': 128000,
   'sonnet-4-5': 64000,
   'sonnet-4-0': 64000,
   'sonnet-4': 64000,
@@ -207,87 +220,9 @@ const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
   'haiku-3': 4096,
 };
 
-const FALLBACK_MAX_TOKENS = 32000;
+const FALLBACK_MAX_TOKENS = 128000;
 
-type ClaudeFamily = 'opus' | 'sonnet' | 'haiku' | 'fable';
-
-interface ClaudeVersion {
-  family: ClaudeFamily;
-  major: number;
-  minor: number | null;
-}
-
-// Family-first form: "opus-4-7", "sonnet-4.6", "haiku-4-5-20251001",
-// "fable-5" (single version component — Fable ids carry no minor).
-// Version numbers are capped at 1–2 digits with a non-digit lookahead so
-// 8-digit date suffixes (e.g. `-20251001`) don't get consumed as version
-// components.
-const FAMILY_FIRST_RE =
-  /(opus|sonnet|haiku|fable)[-._](\d{1,2})(?!\d)(?:[-._](\d{1,2})(?!\d))?/;
-// Legacy version-first form: "3-5-sonnet", "3.7.opus" — used by older
-// Anthropic model ids and Bedrock variants of Claude 3.x.
-const VERSION_FIRST_RE = /(\d{1,2})[-._](\d{1,2})[-._](opus|sonnet|haiku)/;
-// Bare family form for base Claude 3 (no minor): "3-opus", "3.haiku".
-const BARE_FAMILY_RE = /(\d{1,2})[-._](opus|sonnet|haiku)/;
-
-/**
- * Extract Claude family + version from a model id.
- *
- * Designed to survive the naming variants we see across vendors:
- * vendor prefixes (`anthropic.`, `aws/`, `openrouter/`,
- * `online-`), suffixes (date stamps like `-20251001`, build tags
- * like `-construct`, `-v1:0`), and `.` vs `-` separators between
- * the family and version components.
- *
- * Returns `null` when the id contains no Claude marker or no
- * recognizable family/version, in which case the resolver should fall
- * back to the override or {@link FALLBACK_MAX_TOKENS}.
- */
-function parseClaudeVersion(model: string): ClaudeVersion | null {
-  return parseClaudeFamilyVersion(model, true);
-}
-
-function parseClaudeAliasVersion(model: string): ClaudeVersion | null {
-  return parseClaudeFamilyVersion(model, false);
-}
-
-function parseClaudeFamilyVersion(model: string, requireClaudeMarker: boolean): ClaudeVersion | null {
-  const normalized = model.toLowerCase();
-  // Guard against false positives on non-Claude models that happen to
-  // contain an `opus-4-7`-like substring (e.g. fine-tunes named after a
-  // checkpoint). The Anthropic provider might still be configured for
-  // non-Claude endpoints, so without this guard we'd quietly apply
-  // Claude ceilings to unrelated models.
-  if (requireClaudeMarker && !normalized.includes('claude')) return null;
-
-  const familyFirst = FAMILY_FIRST_RE.exec(normalized);
-  if (familyFirst !== null) {
-    return {
-      family: familyFirst[1] as ClaudeFamily,
-      major: Number.parseInt(familyFirst[2]!, 10),
-      minor: familyFirst[3] !== undefined ? Number.parseInt(familyFirst[3], 10) : null,
-    };
-  }
-  const versionFirst = VERSION_FIRST_RE.exec(normalized);
-  if (versionFirst !== null) {
-    return {
-      major: Number.parseInt(versionFirst[1]!, 10),
-      minor: Number.parseInt(versionFirst[2]!, 10),
-      family: versionFirst[3] as ClaudeFamily,
-    };
-  }
-  const bare = BARE_FAMILY_RE.exec(normalized);
-  if (bare !== null) {
-    return {
-      major: Number.parseInt(bare[1]!, 10),
-      minor: null,
-      family: bare[2] as ClaudeFamily,
-    };
-  }
-  return null;
-}
-
-function lookupClaudeCeiling(version: ClaudeVersion): number | undefined {
+function lookupClaudeCeiling(version: AnthropicModelVersion): number | undefined {
   const { family, major, minor } = version;
   if (minor !== null) {
     // Exact minor first, then walk down to the nearest catalogued minor:
@@ -319,7 +254,7 @@ function lookupClaudeCeiling(version: ClaudeVersion): number | undefined {
  *      {@link FALLBACK_MAX_TOKENS}.
  */
 export function resolveDefaultMaxTokens(model: string, override?: number): number {
-  const parsed = parseClaudeVersion(model);
+  const parsed = parseAnthropicModelVersion(model, true);
   const ceiling = parsed === null ? undefined : lookupClaudeCeiling(parsed);
   if (ceiling === undefined) {
     return override ?? FALLBACK_MAX_TOKENS;
@@ -327,55 +262,56 @@ export function resolveDefaultMaxTokens(model: string, override?: number): numbe
   return override === undefined ? ceiling : Math.min(override, ceiling);
 }
 
-function versionAtLeast(
-  version: { major: number; minor: number },
-  minimum: { major: number; minor: number },
-): boolean {
-  return (
-    version.major > minimum.major ||
-    (version.major === minimum.major && version.minor >= minimum.minor)
+function requiresAdaptiveThinking(efforts: readonly string[]): boolean {
+  return efforts.some(
+    (effort) => effort !== 'low' && effort !== 'medium' && effort !== 'high',
   );
 }
 
-function supportsAdaptiveThinking(model: string): boolean {
-  const version = parseClaudeAliasVersion(model);
-  if (version === null) {
-    return false;
+function resolveThinkingProfile(
+  model: string,
+  supportEfforts: readonly string[] | undefined,
+  adaptiveThinking: boolean | undefined,
+): AnthropicModelProfile {
+  const inferred = inferAnthropicModelProfile(model);
+  if (adaptiveThinking === false) {
+    return {
+      ...inferred,
+      mode: 'budget',
+      efforts: supportEfforts ?? BUDGET_THINKING_EFFORTS,
+      // Opting out of adaptive also opts out of the effort param: budget
+      // efforts must go out as pure `budget_tokens` payloads instead of
+      // inheriting `supportsEffortParam` from an adaptive inferred profile.
+      supportsEffortParam: false,
+    };
   }
-  // A missing minor is a bare family-major id: "claude-fable-5" (5.0 ≥ 4.6,
-  // adaptive-only) or "claude-opus-4" (4.0 < 4.6, budget-based).
-  return versionAtLeast(
-    { major: version.major, minor: version.minor ?? 0 },
-    ADAPTIVE_MIN_VERSION,
-  );
+
+  if (adaptiveThinking === true) {
+    return {
+      ...inferred,
+      mode: 'adaptive',
+      efforts: supportEfforts ?? inferred.efforts,
+      supportsEffortParam: true,
+    };
+  }
+
+  if (supportEfforts === undefined) {
+    return inferred;
+  }
+  return {
+    ...inferred,
+    mode: requiresAdaptiveThinking(supportEfforts) ? 'adaptive' : inferred.mode,
+    efforts: supportEfforts,
+    supportsEffortParam:
+      requiresAdaptiveThinking(supportEfforts) || inferred.supportsEffortParam,
+  };
 }
 
-function isFableModel(model: string): boolean {
-  return parseClaudeAliasVersion(model)?.family === 'fable';
-}
-
-function supportsEffortParam(model: string, adaptive: boolean): boolean {
-  if (adaptive) {
-    return true;
-  }
-  const normalized = model.toLowerCase();
-  return normalized.includes('opus-4-5') || normalized.includes('opus-4.5');
-}
-
-function budgetTokensForEffort(effort: ThinkingEffort): number {
-  switch (effort) {
-    case 'low':
-      return 1024;
-    case 'medium':
-      return 4096;
-    case 'on':
-    case 'high':
-      return 32_000;
-    default:
-      throw new Error(
-        `Anthropic budget-based thinking cannot express effort "${effort}". Use low, medium, or high, or configure an adaptive / effort-param-capable model. See ${THINKING_EFFORT_CONFIG_DOCS_URL}`,
-      );
-  }
+function budgetTokensForEffort(effort: ThinkingEffort): number | undefined {
+  if (effort === 'low') return 1024;
+  if (effort === 'medium') return 4096;
+  if (effort === 'on' || effort === 'high') return 32_000;
+  return undefined;
 }
 
 const CACHE_CONTROL = { type: 'ephemeral' as const };
@@ -383,7 +319,10 @@ const CACHE_CONTROL = { type: 'ephemeral' as const };
 type CacheableBlock = ContentBlockParam & { cache_control?: { type: 'ephemeral' } };
 
 function shouldPreserveUnsignedThinking(model: string): boolean {
-  return parseClaudeAliasVersion(model) === null;
+  return (
+    parseAnthropicModelVersion(model) === null &&
+    matchKnownAnthropicModelProfile(model) === undefined
+  );
 }
 
 /**
@@ -637,6 +576,11 @@ function convertMessage(message: Message, model: string): MessageParam {
 
   return { role: role, content: blocks };
 }
+
+function shouldKeepConvertedMessage(message: MessageParam): boolean {
+  return message.role !== 'assistant' || message.content.length > 0;
+}
+
 export function convertAnthropicError(error: unknown): ChatProviderError {
   // Check timeout before connection (APIConnectionTimeoutError extends APIConnectionError)
   if (error instanceof AnthropicTimeoutError) {
@@ -833,7 +777,7 @@ class AnthropicStreamedMessage implements StreamedMessage {
               yield { type: 'text', text: block.text };
               break;
             case 'thinking':
-              yield { type: 'think', think: block.thinking };
+              yield { type: 'think', think: block.thinking ?? '' };
               break;
             case 'redacted_thinking':
               yield {
@@ -866,7 +810,7 @@ class AnthropicStreamedMessage implements StreamedMessage {
               yield { type: 'text', text: delta.text };
               break;
             case 'thinking_delta':
-              yield { type: 'think', think: delta.thinking };
+              yield { type: 'think', think: delta.thinking ?? '' };
               break;
             case 'input_json_delta':
               yield {
@@ -950,6 +894,7 @@ export class AnthropicChatProvider implements ChatProvider {
   private _defaultHeaders: Record<string, string | null> | undefined;
   private _clientFactory: ((auth: ProviderRequestAuth) => Anthropic) | undefined;
   private _adaptiveThinking: boolean | undefined;
+  private readonly _supportEfforts: readonly string[] | undefined;
   private readonly _kimiThinking: boolean;
   private _betaApi: boolean;
   private _explicitMaxTokens: boolean;
@@ -959,6 +904,7 @@ export class AnthropicChatProvider implements ChatProvider {
     this._stream = options.stream ?? true;
     this._metadata = options.metadata;
     this._adaptiveThinking = options.adaptiveThinking;
+    this._supportEfforts = options.supportEfforts;
     this._kimiThinking = options.kimiThinking ?? false;
     this._betaApi = options.betaApi ?? false;
     this._apiKey =
@@ -1036,9 +982,9 @@ export class AnthropicChatProvider implements ChatProvider {
         // garbage `<system></system>` user turn). See isToolDeclarationOnlyMessage.
         history.filter((msg) => !isToolDeclarationOnlyMessage(msg)),
         ANTHROPIC_TOOL_CALL_ID_POLICY,
-      ).map((msg) =>
-        convertMessage(msg, this._model),
-      ),
+      )
+        .map((msg) => convertMessage(msg, this._model))
+        .filter(shouldKeepConvertedMessage),
       {
         isUser: (message) => message.role === 'user',
         isToolResultOnly,
@@ -1070,12 +1016,8 @@ export class AnthropicChatProvider implements ChatProvider {
     if (this._generationKwargs.top_p !== undefined) {
       kwargs['top_p'] = this._generationKwargs.top_p;
     }
-    // Fable rejects an explicit `disabled` thinking config (HTTP 400, unlike
-    // Opus 4.7/4.8 which accept it), so omit the field instead. Note thinking
-    // cannot actually be turned off on Fable: adaptive thinking is always on,
-    // and an omitted `thinking` field still runs with it.
     const thinking = this._generationKwargs.thinking;
-    if (thinking !== undefined && !(thinking.type === 'disabled' && isFableModel(this._model))) {
+    if (thinking !== undefined) {
       kwargs['thinking'] = thinking;
     }
     if (this._generationKwargs.output_config !== undefined) {
@@ -1241,9 +1183,11 @@ export class AnthropicChatProvider implements ChatProvider {
   }
 
   withThinking(effort: ThinkingEffort): AnthropicChatProvider {
-    // Resolve once: an explicit `adaptiveThinking` option overrides the
-    // model-name version inference, so custom-named endpoints can opt in/out.
-    const adaptive = this._adaptiveThinking ?? supportsAdaptiveThinking(this._model);
+    const profile = resolveThinkingProfile(
+      this._model,
+      this._supportEfforts,
+      this._kimiThinking ? true : this._adaptiveThinking,
+    );
     let thinking: MessageCreateParams['thinking'];
     let outputConfig: MessageCreateParams['output_config'] | undefined;
 
@@ -1253,22 +1197,26 @@ export class AnthropicChatProvider implements ChatProvider {
       thinking = { type: 'enabled' } as MessageCreateParams['thinking'];
       outputConfig =
         effort === 'on' ? undefined : ({ effort } as MessageCreateParams['output_config']);
-    } else if (adaptive) {
+    } else if (profile.mode === 'adaptive') {
       thinking = { type: 'adaptive', display: 'summarized' };
       outputConfig =
         effort === 'on'
           ? undefined
           : ({ effort } as MessageCreateParams['output_config']);
     } else {
-      thinking = { type: 'enabled', budget_tokens: budgetTokensForEffort(effort) };
+      const budgetTokens = budgetTokensForEffort(effort);
+      thinking =
+        budgetTokens === undefined
+          ? ({ type: 'enabled' } as MessageCreateParams['thinking'])
+          : { type: 'enabled', budget_tokens: budgetTokens };
       outputConfig =
-        supportsEffortParam(this._model, adaptive) && effort !== 'on'
+        (profile.supportsEffortParam || budgetTokens === undefined) && effort !== 'on'
           ? ({ effort } as MessageCreateParams['output_config'])
           : undefined;
     }
 
     let newBetas = [...(this._generationKwargs.betaFeatures ?? [])];
-    if (adaptive) {
+    if (profile.mode === 'adaptive') {
       newBetas = newBetas.filter((b) => b !== INTERLEAVED_THINKING_BETA);
     }
     const clone = this._withGenerationKwargs({
diff --git a/packages/kosong/src/providers/google-genai.ts b/packages/kosong/src/providers/google-genai.ts
index ad69fc0c5..88a26e6e0 100644
--- a/packages/kosong/src/providers/google-genai.ts
+++ b/packages/kosong/src/providers/google-genai.ts
@@ -163,14 +163,18 @@ function toolCallIdToName(toolCallId: string, toolNameById: Map<string, string>)
   const name = toolNameById.get(toolCallId);
   if (name !== undefined) return name;
   // Fallback: ids produced by this provider follow the format
-  // "{tool_name}_{id_suffix}" where `tool_name` may itself contain
-  // underscores (e.g. `fetch_image`) and `id_suffix` is a single trailing
-  // token without underscores (e.g. a random hex / UUID fragment). We strip
-  // the last "_<suffix>" segment by matching it explicitly — splitting on
-  // the first underscore would truncate multi-word tool names like
-  // `fetch_image_<id>` to just `fetch`.
-  const match = /^(.+)_[^_]+$/.exec(toolCallId);
-  return match?.[1] ?? toolCallId;
+  // "{tool_name}_{upstream_id}_{entropy}" where `tool_name` may itself
+  // contain underscores (e.g. `fetch_image`) and `entropy` is the fixed
+  // 8-hex-char suffix this provider appends for cross-turn uniqueness. Strip
+  // the entropy suffix first, then the trailing "_<upstream_id>" segment by
+  // matching it explicitly — splitting on the first underscore would truncate
+  // multi-word tool names like `fetch_image_<id>` to just `fetch`. (Pre-entropy
+  // ids of the form "{tool_name}_{id_suffix}" still parse: a trailing 8-hex
+  // segment is indistinguishable from the entropy suffix, and stripping it
+  // recovers the same name the old single-suffix shape did.)
+  const withoutEntropy = toolCallId.replace(/_[0-9a-f]{8}$/, '');
+  const match = /^(.+)_[^_]+$/.exec(withoutEntropy);
+  return match?.[1] ?? withoutEntropy;
 }
 
 /**
@@ -588,8 +592,14 @@ export class GoogleGenAIStreamedMessage implements StreamedMessage {
           const fc = (p['functionCall'] ?? p['function_call']) as Record<string, unknown>;
           const name = fc['name'] as string;
           if (!name) continue;
+          // The upstream function-call id is only unique within its own
+          // response (some backends re-issue small ids like "0" every turn),
+          // so `${name}_${id}` collided across turns — two AgentSwarm calls in
+          // different turns both became `AgentSwarm_0` and the web client
+          // merged their member lists into one card. Append entropy so ids
+          // stay unique across the whole session.
           const id_ = (fc['id'] as string) ?? crypto.randomUUID();
-          const toolCallId = `${name}_${id_}`;
+          const toolCallId = `${name}_${id_}_${crypto.randomUUID().replaceAll('-', '').slice(0, 8)}`;
           const thoughtSigB64 = p['thoughtSignature'] ?? p['thought_signature'];
           const toolCall: ToolCall = {
             type: 'function',
diff --git a/packages/kosong/src/providers/kimi.ts b/packages/kosong/src/providers/kimi.ts
index d11420195..0bd6a14eb 100644
--- a/packages/kosong/src/providers/kimi.ts
+++ b/packages/kosong/src/providers/kimi.ts
@@ -1,4 +1,5 @@
 import { normalizeKimiToolSchema } from './kimi-schema';
+import { parseTraceId } from '#/errors';
 import type { ContentPart, Message, StreamedMessagePart, ToolCall } from '#/message';
 import type {
   ChatProvider,
@@ -255,6 +256,7 @@ class KimiStreamedMessage implements StreamedMessage {
   constructor(
     response: OpenAI.Chat.ChatCompletion | AsyncIterable<OpenAI.Chat.ChatCompletionChunk>,
     isStream: boolean,
+    private readonly _traceId: string | null,
   ) {
     if (isStream) {
       this._iter = this._convertStreamResponse(
@@ -281,6 +283,10 @@ class KimiStreamedMessage implements StreamedMessage {
     return this._rawFinishReason;
   }
 
+  get traceId(): string | null {
+    return this._traceId;
+  }
+
   async *[Symbol.asyncIterator](): AsyncIterator<StreamedMessagePart> {
     yield* this._iter;
   }
@@ -537,11 +543,22 @@ export class KimiChatProvider implements ChatProvider {
       // Use type assertion via unknown because we pass the Moonshot-proprietary
       // `thinking` field (via extra_body) that doesn't exist in the OpenAI type definitions.
       options?.onRequestSent?.();
-      const response = (await client.chat.completions.create(
-        createParams as unknown as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming,
-        options?.signal ? { signal: options.signal } : undefined,
-      )) as unknown as OpenAI.Chat.ChatCompletion | AsyncIterable<OpenAI.Chat.ChatCompletionChunk>;
-      return new KimiStreamedMessage(response, this._stream);
+      // `withResponse()` resolves as soon as the response headers arrive
+      // (before the stream body), so the KFC `x-trace-id` header is available
+      // even for a stream the caller later cancels mid-flight.
+      const { data, response } = await client.chat.completions
+        .create(
+          createParams as unknown as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming,
+          options?.signal ? { signal: options.signal } : undefined,
+        )
+        .withResponse();
+      return new KimiStreamedMessage(
+        data as unknown as
+          | OpenAI.Chat.ChatCompletion
+          | AsyncIterable<OpenAI.Chat.ChatCompletionChunk>,
+        this._stream,
+        parseTraceId(response.headers),
+      );
     } catch (error: unknown) {
       throw convertOpenAIError(error);
     }
diff --git a/packages/kosong/src/providers/openai-common.ts b/packages/kosong/src/providers/openai-common.ts
index 5bf9be7fa..bc3e18cdd 100644
--- a/packages/kosong/src/providers/openai-common.ts
+++ b/packages/kosong/src/providers/openai-common.ts
@@ -5,6 +5,7 @@ import {
   classifyBaseApiError,
   normalizeAPIStatusError,
   parseRetryAfterMs,
+  parseTraceId,
 } from '#/errors';
 import { extractText } from '#/message';
 import type { ContentPart, Message } from '#/message';
@@ -109,6 +110,7 @@ export function convertOpenAIError(error: unknown): ChatProviderError {
       error.message,
       reqId,
       parseRetryAfterMs(error.headers),
+      parseTraceId(error.headers),
     );
   }
   // Base APIError with no status and no body => transport-layer failure.
diff --git a/packages/kosong/src/providers/openai-legacy.ts b/packages/kosong/src/providers/openai-legacy.ts
index 98e109e89..02c5e5f1a 100644
--- a/packages/kosong/src/providers/openai-legacy.ts
+++ b/packages/kosong/src/providers/openai-legacy.ts
@@ -482,7 +482,7 @@ export class OpenAILegacyChatProvider implements ChatProvider {
   private _baseUrl: string | undefined;
   private _defaultHeaders: Record<string, string> | undefined;
   private _reasoningKey: string | undefined;
-  private _reasoningEffort: string | undefined;
+  private _thinkingEffort: ThinkingEffort | undefined;
   private _generationKwargs: OpenAILegacyGenerationKwargs;
   private _toolMessageConversion: ToolMessageConversion;
   private _client: OpenAI | undefined;
@@ -505,7 +505,7 @@ export class OpenAILegacyChatProvider implements ChatProvider {
       normalizedReasoningKey !== undefined && normalizedReasoningKey.length > 0
         ? normalizedReasoningKey
         : undefined;
-    this._reasoningEffort = undefined;
+    this._thinkingEffort = undefined;
     this._generationKwargs =
       options.maxTokens !== undefined ? completionTokenKwargs(this._model, options.maxTokens) : {};
     this._toolMessageConversion = options.toolMessageConversion ?? null;
@@ -520,8 +520,7 @@ export class OpenAILegacyChatProvider implements ChatProvider {
   }
 
   get thinkingEffort(): ThinkingEffort | null {
-    if (this._reasoningEffort === undefined) return null;
-    return this._reasoningEffort === 'none' ? 'off' : this._reasoningEffort;
+    return this._thinkingEffort ?? null;
   }
 
   get modelParameters(): Record<string, unknown> {
@@ -555,16 +554,27 @@ export class OpenAILegacyChatProvider implements ChatProvider {
       this._generationKwargs,
     );
 
-    // Determine reasoning_effort
-    let reasoningEffort: string | undefined = this._reasoningEffort;
+    // Determine reasoning_effort. 'off' and 'on' have no wire encoding on
+    // chat-completions APIs, so they send no reasoning_effort field; only a
+    // concrete effort (low/medium/high/...) is passed through verbatim.
+    const effort = this._thinkingEffort;
+    let reasoningEffort: string | undefined =
+      effort === undefined || effort === 'off' || effort === 'on' ? undefined : effort;
 
     // Auto-enable reasoning_effort when the history contains ThinkPart but reasoning
     // was not explicitly configured. This prevents server validation errors from APIs
     // (e.g. One API) that require reasoning_effort when messages contain reasoning_content.
     // Skip when the caller already pinned reasoning_effort via withGenerationKwargs —
-    // their value would otherwise be silently overwritten below.
+    // their value would otherwise be silently overwritten below. An explicit 'off'
+    // from withThinking is honored as well: with thinking turned off the
+    // auto-enable must not silently switch reasoning back on (or leak the field
+    // to models that reject it).
     // See: https://github.com/MoonshotAI/kimi-code/issues/1616
-    if (reasoningEffort === undefined && kwargs['reasoning_effort'] === undefined) {
+    if (
+      reasoningEffort === undefined &&
+      effort !== 'off' &&
+      kwargs['reasoning_effort'] === undefined
+    ) {
       const hasThinkPart = history.some((message) =>
         message.content.some((part) => part.type === 'think'),
       );
@@ -618,9 +628,11 @@ export class OpenAILegacyChatProvider implements ChatProvider {
   }
 
   withThinking(effort: ThinkingEffort): OpenAILegacyChatProvider {
-    const reasoningEffort = effort === 'off' || effort === 'on' ? undefined : effort;
     const clone = this._clone();
-    clone._reasoningEffort = reasoningEffort;
+    // Store the requested effort verbatim; the wire encoding is derived per
+    // request so an explicit 'off' stays distinguishable from "never
+    // configured" (which the history-based auto-enable relies on).
+    clone._thinkingEffort = effort;
     return clone;
   }
 
diff --git a/packages/kosong/test/anthropic.test.ts b/packages/kosong/test/anthropic.test.ts
index d4d5ab7f6..012aa701d 100644
--- a/packages/kosong/test/anthropic.test.ts
+++ b/packages/kosong/test/anthropic.test.ts
@@ -1,6 +1,13 @@
+/**
+ * Scenario: Anthropic request serialization and response streaming across native and compatible models.
+ * Responsibilities: preserve provider wire contracts, thinking semantics, tool calls, and request options.
+ * Wiring: real Anthropic adapter with only the remote SDK client boundary replaced by mocks.
+ * Run: pnpm exec vitest run packages/kosong/test/anthropic.test.ts
+ */
 import { ChatProviderError } from '#/errors';
 import type { ContentPart, Message, StreamedMessagePart, ToolCall } from '#/message';
 import { AnthropicChatProvider, resolveDefaultMaxTokens } from '#/providers/anthropic';
+import { matchKnownAnthropicModelProfile } from '#/providers/anthropic-profile';
 import type { GenerateOptions } from '#/provider';
 import type { Tool } from '#/tool';
 import { describe, it, expect, vi } from 'vitest';
@@ -39,6 +46,43 @@ function createStreamProvider(model: string = 'k25'): AnthropicChatProvider {
   });
 }
 
+const UNSIGNED_THINKING_ONLY_HISTORY: Message[] = [
+  { role: 'user', content: [{ type: 'text', text: 'Start' }], toolCalls: [] },
+  {
+    role: 'assistant',
+    content: [{ type: 'think', think: 'Partial reasoning' }],
+    toolCalls: [],
+  },
+  { role: 'user', content: [{ type: 'text', text: 'Continue' }], toolCalls: [] },
+];
+
+describe('Anthropic model profile matching', () => {
+  it.each([
+    ['claude-opus-4-5', 'budget', ['low', 'medium', 'high'], true, true],
+    ['anthropic.claude-opus-4-6-v1:0', 'adaptive', ['low', 'medium', 'high', 'max'], true, true],
+    ['claude-opus-4-7', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, true],
+    ['claude-sonnet-4-6', 'adaptive', ['low', 'medium', 'high', 'max'], true, true],
+    ['claude-sonnet-5', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, true],
+    ['claude-fable-5', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, false],
+    ['claude-mythos-5', 'adaptive', ['low', 'medium', 'high', 'xhigh', 'max'], true, false],
+    ['claude-mythos-preview', 'adaptive', ['low', 'medium', 'high', 'max'], true, false],
+  ] as const)(
+    'matches %s to the built-in official profile',
+    (model, mode, efforts, supportsEffortParam, canDisableThinking) => {
+      expect(matchKnownAnthropicModelProfile(model)).toEqual({
+        mode,
+        efforts,
+        supportsEffortParam,
+        canDisableThinking,
+      });
+    },
+  );
+
+  it('does not claim an official profile for an unrecognized compatible model', () => {
+    expect(matchKnownAnthropicModelProfile('Example Compatible Model')).toBeUndefined();
+  });
+});
+
 type AnthropicGenerationState = {
   max_tokens?: number | undefined;
   temperature?: number | undefined;
@@ -94,7 +138,7 @@ async function captureRequestBody(
 }
 
 /** Create a mock stream that yields the given events as an async iterable. */
-function mockStream(events: unknown[]) {
+function mockStream(events: readonly unknown[]) {
   return {
     async *[Symbol.asyncIterator]() {
       for (const event of events) {
@@ -115,6 +159,56 @@ async function collectParts(
   return parts;
 }
 
+async function collectAnthropicStreamParts(
+  events: readonly Record<string, unknown>[],
+): Promise<StreamedMessagePart[]> {
+  const create = vi.fn().mockResolvedValue(mockStream(events));
+  const provider = new AnthropicChatProvider({
+    model: 'kimi-for-coding',
+    apiKey: '',
+    stream: true,
+    clientFactory: () => ({ messages: { create } }) as never,
+  });
+
+  return collectParts(
+    await provider.generate(
+      '',
+      [],
+      [{ role: 'user', content: [{ type: 'text', text: 'Think' }], toolCalls: [] }],
+    ),
+  );
+}
+
+async function captureAnthropicMessages(
+  model: string,
+  history: Message[],
+  configure?: (provider: AnthropicChatProvider) => AnthropicChatProvider,
+): Promise<Array<{ role: string; content: unknown[] }>> {
+  let captured: Record<string, unknown> | undefined;
+  const create = vi.fn().mockImplementation((params: unknown) => {
+    captured = params as Record<string, unknown>;
+    return Promise.resolve(makeAnthropicResponse(model));
+  });
+  let provider = new AnthropicChatProvider({
+    model,
+    apiKey: '',
+    defaultMaxTokens: 1024,
+    stream: false,
+    clientFactory: () => ({ messages: { create }, beta: { messages: { create } } }) as never,
+  });
+  if (configure !== undefined) {
+    provider = configure(provider);
+  }
+
+  const response = await provider.generate('', [], history);
+  await collectParts(response);
+
+  if (captured === undefined) {
+    throw new Error('Expected Anthropic provider to send a request.');
+  }
+  return captured['messages'] as Array<{ role: string; content: unknown[] }>;
+}
+
 const ADD_TOOL: Tool = {
   name: 'add',
   description: 'Add two integers.',
@@ -342,6 +436,302 @@ describe('withThinkingKeep (context_management)', () => {
     });
     expect(body['betas']).toContain('context-management-2025-06-27');
   });
+
+  it('replays compatible text history without injecting thinking when keep all is active', async () => {
+    const compatibleHistory: Message[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Hi' }], toolCalls: [] },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello' }],
+        toolCalls: [],
+      },
+      { role: 'user', content: [{ type: 'text', text: 'Continue' }], toolCalls: [] },
+    ];
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[1]).toEqual({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hello' }],
+    });
+  });
+
+  it('replays a compatible assistant tool call without injecting thinking when keep all is active', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [],
+        toolCalls: [
+          { type: 'function', id: 'call_1', name: 'lookup', arguments: '{"q":"test"}' },
+        ],
+      },
+    ];
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [
+        {
+          type: 'tool_use',
+          id: 'call_1',
+          name: 'lookup',
+          input: { q: 'test' },
+          cache_control: { type: 'ephemeral' },
+        },
+      ],
+    });
+  });
+
+  it('preserves an existing unsigned empty thinking block unchanged when keep all is active', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '' },
+          { type: 'text', text: 'Hello' },
+        ],
+        toolCalls: [],
+      },
+    ];
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [
+        { type: 'thinking', thinking: '' },
+        { type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } },
+      ],
+    });
+  });
+
+  it('preserves all unsigned blocks unchanged when every one is empty', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '' },
+          { type: 'think', think: '' },
+          { type: 'text', text: 'Hello' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: '' },
+      { type: 'thinking', thinking: '' },
+      { type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } },
+    ]);
+  });
+
+  it('replays each empty assistant message without injecting thinking when keep all is active', async () => {
+    const compatibleHistory: Message[] = [
+      { role: 'user', content: [{ type: 'text', text: 'First' }], toolCalls: [] },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'First response' }],
+        toolCalls: [],
+      },
+      { role: 'user', content: [{ type: 'text', text: 'Second' }], toolCalls: [] },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Second response' }],
+        toolCalls: [],
+      },
+      { role: 'user', content: [{ type: 'text', text: 'Third' }], toolCalls: [] },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect([messages[1]!.content[0], messages[3]!.content[0]]).toEqual([
+      { type: 'text', text: 'First response' },
+      { type: 'text', text: 'Second response' },
+    ]);
+  });
+
+  it('preserves every unsigned block when one contains non-empty thinking', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '' },
+          { type: 'think', think: 'reasoning' },
+          { type: 'text', text: 'Hello' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: '' },
+      { type: 'thinking', thinking: 'reasoning' },
+      { type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } },
+    ]);
+  });
+
+  it('preserves an empty signed thinking block when keep all is active', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '', encrypted: 'signature' },
+          { type: 'text', text: 'Hello' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: '', signature: 'signature' },
+      { type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } },
+    ]);
+  });
+
+  it('preserves the unsigned empty block when signed and unsigned thinking are empty', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: '', encrypted: 'signature' },
+          { type: 'think', think: '' },
+          { type: 'text', text: 'Hello' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: '', signature: 'signature' },
+      { type: 'thinking', thinking: '' },
+      { type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } },
+    ]);
+  });
+
+  it('leaves unsigned empty thinking unchanged when signed thinking is non-empty', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'think', think: 'signed reasoning', encrypted: 'signature' },
+          { type: 'think', think: '' },
+          { type: 'text', text: 'Hello' },
+        ],
+        toolCalls: [],
+      },
+    ];
+
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]!.content).toEqual([
+      { type: 'thinking', thinking: 'signed reasoning', signature: 'signature' },
+      { type: 'thinking', thinking: '' },
+      { type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } },
+    ]);
+  });
+
+  it('leaves missing compatible thinking absent when keep all is not enabled', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello' }],
+        toolCalls: [],
+      },
+    ];
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('max'),
+    );
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } }],
+    });
+  });
+
+  it('leaves missing compatible thinking absent when thinking is disabled', async () => {
+    const compatibleHistory: Message[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello' }],
+        toolCalls: [],
+      },
+    ];
+    const messages = await captureAnthropicMessages(
+      'compatible-preserved-thinking-model',
+      compatibleHistory,
+      (provider) => provider.withThinking('off').withThinkingKeep('all'),
+    );
+
+    expect(messages[0]).toEqual({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } }],
+    });
+  });
+
+  it.each(['claude-opus-4-8', 'claude-opus-4-9', 'claude-mythos-preview'])(
+    'does not synthesize unsigned thinking for Claude model %s with keep all',
+    async (model) => {
+      const claudeHistory: Message[] = [
+        {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Hello' }],
+          toolCalls: [],
+        },
+      ];
+      const messages = await captureAnthropicMessages(model, claudeHistory, (provider) =>
+        provider.withThinking('max').withThinkingKeep('all'),
+      );
+
+      expect(messages[0]).toEqual({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello', cache_control: { type: 'ephemeral' } }],
+      });
+    },
+  );
 });
 
 describe('AnthropicChatProvider', () => {
@@ -1341,7 +1731,25 @@ describe('AnthropicChatProvider', () => {
       expect(messages[0]!.content[0]).toEqual({ type: 'thinking', thinking: '' });
     });
 
-    it.each(['claude-opus-4-6', 'opus-4-6'])(
+    it('preserves an unsigned-only assistant message for Anthropic-compatible models', async () => {
+      const messages = await captureAnthropicMessages(
+        'compatible-model',
+        UNSIGNED_THINKING_ONLY_HISTORY,
+      );
+
+      expect(messages[1]).toEqual({
+        role: 'assistant',
+        content: [{ type: 'thinking', thinking: 'Partial reasoning' }],
+      });
+    });
+
+    it.each([
+      'claude-opus-4-6',
+      'opus-4-6',
+      'claude-opus-4-9',
+      'opus-4-9',
+      'claude-mythos-preview',
+    ])(
       'drops unsigned thinking for Claude model %s before tool_use blocks',
       async (model) => {
         const provider = createProvider(model);
@@ -1371,6 +1779,23 @@ describe('AnthropicChatProvider', () => {
       },
     );
 
+    it('drops an unsigned-only Claude assistant without leaving an empty wire message', async () => {
+      const messages = await captureAnthropicMessages(
+        'claude-opus-4-9',
+        UNSIGNED_THINKING_ONLY_HISTORY,
+      );
+
+      expect(messages).toEqual([
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'Start' },
+            { type: 'text', text: 'Continue', cache_control: { type: 'ephemeral' } },
+          ],
+        },
+      ]);
+    });
+
     it('base64 image', async () => {
       const provider = createProvider();
       const history: Message[] = [
@@ -1480,7 +1905,7 @@ describe('AnthropicChatProvider', () => {
     });
 
     it('combines thinking and max_tokens in internal state', () => {
-      const provider = createProvider()
+      const provider = createProvider('claude-sonnet-4-5')
         .withThinking('high')
         .withGenerationKwargs({ max_tokens: 512 });
       const state = getGenerationState(provider);
@@ -1520,7 +1945,7 @@ describe('AnthropicChatProvider', () => {
     ];
 
     it('pre-4.6 model: high -> budget_tokens=32000', async () => {
-      const provider = createProvider('k25').withThinking('high');
+      const provider = createProvider('claude-sonnet-4-5').withThinking('high');
       const body = await captureRequestBody(provider, '', [], thinkHistory);
 
       expect(body['thinking']).toEqual({ type: 'enabled', budget_tokens: 32000 });
@@ -1561,17 +1986,20 @@ describe('AnthropicChatProvider', () => {
       }
     });
 
-    it('claude-fable-5 with thinking off omits the thinking field entirely', async () => {
-      // Fable 400s on an explicit `disabled` thinking config (unlike Opus
-      // 4.7/4.8); the provider must drop the field from the request while
-      // still reporting `off` to callers.
-      const provider = createProvider('claude-fable-5').withThinking('off');
-      expect(provider.thinkingEffort).toBe('off');
+    it.each(['claude-fable-5', 'claude-mythos-5', 'claude-mythos-preview'])(
+      '%s: passes thinking off through for the backend to validate',
+      async (model) => {
+        const body = await captureRequestBody(
+          createProvider(model).withThinking('off'),
+          '',
+          [],
+          thinkHistory,
+        );
 
-      const body = await captureRequestBody(provider, '', [], thinkHistory);
-      expect('thinking' in body).toBe(false);
-      expect(body['output_config']).toBeUndefined();
-    });
+        expect(body['thinking']).toEqual({ type: 'disabled' });
+        expect(body['output_config']).toBeUndefined();
+      },
+    );
 
     it.each([
       'claude-sonnet-4-6',
@@ -1603,7 +2031,7 @@ describe('AnthropicChatProvider', () => {
 
     it('adaptiveThinking=true forces adaptive on an unversioned model name', async () => {
       const provider = new AnthropicChatProvider({
-        model: 'coding-model-okapi-0527-vibe',
+        model: 'compatible-model',
         apiKey: 'test-key',
         defaultMaxTokens: 1024,
         stream: false,
@@ -1629,17 +2057,73 @@ describe('AnthropicChatProvider', () => {
       expect(body['output_config']).toEqual({ effort: 'max' });
     });
 
-    it('unversioned model name without adaptiveThinking stays budget-based', async () => {
+    it('adaptiveThinking=true passes an unlisted effort through unchanged', async () => {
+      const provider = new AnthropicChatProvider({
+        model: 'claude-opus-4-6',
+        apiKey: 'test-key',
+        stream: false,
+        adaptiveThinking: true,
+      }).withThinking('xhigh');
+      const body = await captureRequestBody(provider, '', [], thinkHistory);
+
+      expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+      expect(body['output_config']).toEqual({ effort: 'xhigh' });
+    });
+
+    it('unversioned model without supportEfforts preserves max through the latest Opus profile', async () => {
       const provider = new AnthropicChatProvider({
         model: 'coding-model-okapi-0527-vibe',
         apiKey: 'test-key',
         defaultMaxTokens: 1024,
         stream: false,
-      }).withThinking('high');
+      }).withThinking('max');
       const body = await captureRequestBody(provider, '', [], thinkHistory);
 
-      expect(body['thinking']).toEqual({ type: 'enabled', budget_tokens: 32000 });
-      expect(body['output_config']).toBeUndefined();
+      expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+      expect(body['output_config']).toEqual({ effort: 'max' });
+    });
+
+    it('declared supportEfforts override a legacy model-name profile', async () => {
+      const provider = new AnthropicChatProvider({
+        model: 'claude-opus-4-5',
+        apiKey: 'test-key',
+        defaultMaxTokens: 1024,
+        stream: false,
+        supportEfforts: ['low', 'medium', 'high', 'max'],
+      }).withThinking('max');
+      const body = await captureRequestBody(provider, '', [], thinkHistory);
+
+      expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+      expect(body['output_config']).toEqual({ effort: 'max' });
+    });
+
+    it('passes efforts outside declared supportEfforts without converting them', async () => {
+      const provider = new AnthropicChatProvider({
+        model: 'Example Compatible Model',
+        apiKey: 'test-key',
+        defaultMaxTokens: 1024,
+        stream: false,
+        supportEfforts: ['low', 'high'],
+      }).withThinking('max');
+      const body = await captureRequestBody(provider, '', [], thinkHistory);
+
+      expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+      expect(body['output_config']).toEqual({ effort: 'max' });
+    });
+
+    it('keeps a concrete effort when adaptiveThinking is false', async () => {
+      const provider = new AnthropicChatProvider({
+        model: 'Example Compatible Model',
+        apiKey: 'test-key',
+        defaultMaxTokens: 1024,
+        stream: false,
+        adaptiveThinking: false,
+        supportEfforts: ['low', 'high', 'max'],
+      }).withThinking('max');
+      const body = await captureRequestBody(provider, '', [], thinkHistory);
+
+      expect(body['thinking']).toEqual({ type: 'enabled' });
+      expect(body['output_config']).toEqual({ effort: 'max' });
     });
 
     it('Kimi thinking mode sends concrete effort without budget conversion', async () => {
@@ -1714,18 +2198,48 @@ describe('AnthropicChatProvider', () => {
       expect(body['output_config']).toBeUndefined();
     });
 
-    it('pre-4.6 budget model rejects xhigh and max', () => {
-      for (const effort of ['xhigh', 'max'] as const) {
-        expect(() => createProvider('claude-sonnet-4-5').withThinking(effort)).toThrow(
-          /budget-based thinking cannot express effort/,
-        );
+    it('adaptiveThinking=false omits the effort param for an unversioned model name', async () => {
+      const provider = new AnthropicChatProvider({
+        model: 'coding-model-okapi-0527-vibe',
+        apiKey: 'test-key',
+        defaultMaxTokens: 1024,
+        stream: false,
+        adaptiveThinking: false,
+      });
+      for (const [effort, budget] of [
+        ['low', 1024],
+        ['medium', 4096],
+        ['high', 32_000],
+      ] as const) {
+        const body = await captureRequestBody(provider.withThinking(effort), '', [], thinkHistory);
+        expect(body['thinking']).toEqual({ type: 'enabled', budget_tokens: budget });
+        expect(body['output_config']).toBeUndefined();
       }
     });
 
-    it('opus-4-5 rejects xhigh', () => {
-      expect(() => createProvider('claude-opus-4-5').withThinking('xhigh')).toThrow(
-        /budget-based thinking cannot express effort/,
+    it('pre-4.6 budget model passes xhigh and max through unchanged', async () => {
+      for (const effort of ['xhigh', 'max'] as const) {
+        const body = await captureRequestBody(
+          createProvider('claude-sonnet-4-5').withThinking(effort),
+          '',
+          [],
+          thinkHistory,
+        );
+        expect(body['thinking']).toEqual({ type: 'enabled' });
+        expect(body['output_config']).toEqual({ effort });
+      }
+    });
+
+    it('opus-4-5 passes xhigh through unchanged', async () => {
+      const body = await captureRequestBody(
+        createProvider('claude-opus-4-5').withThinking('xhigh'),
+        '',
+        [],
+        thinkHistory,
       );
+
+      expect(body['thinking']).toEqual({ type: 'enabled' });
+      expect(body['output_config']).toEqual({ effort: 'xhigh' });
     });
 
     it('opus-4-6 with thinking off -> disabled', async () => {
@@ -1820,7 +2334,6 @@ describe('AnthropicChatProvider', () => {
       ['claude-opus-4-7', 'high', 'high'],
       ['claude-opus-4-7', 'xhigh', 'xhigh'],
       ['claude-opus-4-7', 'max', 'max'],
-      ['claude-opus-4-6', 'xhigh', 'xhigh'],
       ['claude-opus-4-6', 'max', 'max'],
     ] as const)(
       'adaptive wire body: %s + %s -> output_config.effort=%s',
@@ -1940,12 +2453,6 @@ describe('AnthropicChatProvider', () => {
         'claude-haiku-3-5',
         'claude-haiku-4-5',
         'claude-haiku-4-5-20251001',
-        // Non-Claude models / garbage input
-        'gpt-4',
-        'gpt-4-turbo',
-        'gemini-2.5-pro',
-        'unknown-model',
-        'claude', // no family word
       ])('non-adaptive: %s -> type=enabled budget', async (model) => {
         const provider = createProvider(model).withThinking('high');
         const body = await captureRequestBody(provider, '', [], thinkHistory);
@@ -1953,6 +2460,17 @@ describe('AnthropicChatProvider', () => {
         expect(body['thinking']).toMatchObject({ type: 'enabled' });
         expect((body['thinking'] as { type: string }).type).not.toBe('adaptive');
       });
+
+      it.each(['gpt-4', 'gpt-4-turbo', 'gemini-2.5-pro', 'unknown-model', 'claude'])(
+        'unrecognized model %s uses the latest Opus adaptive profile',
+        async (model) => {
+          const provider = createProvider(model).withThinking('max');
+          const body = await captureRequestBody(provider, '', [], thinkHistory);
+
+          expect(body['thinking']).toEqual({ type: 'adaptive', display: 'summarized' });
+          expect(body['output_config']).toEqual({ effort: 'max' });
+        },
+      );
     });
 
     // Effort handling per model capability: adaptive-capable models pass
@@ -1967,10 +2485,8 @@ describe('AnthropicChatProvider', () => {
         ['claude-opus-4-7', 'max', 'max'],
         ['claude-opus-4-7-20260301', 'xhigh', 'xhigh'],
         ['claude-opus-4-6', 'max', 'max'],
-        ['claude-opus-4-6', 'xhigh', 'xhigh'],
         ['claude-opus-4-6-20260205', 'max', 'max'],
         ['claude-sonnet-4-6', 'max', 'max'],
-        ['claude-sonnet-4-6', 'xhigh', 'xhigh'],
         ['claude-opus-4-6', 'medium', 'medium'],
         ['claude-fable-5', 'xhigh', 'xhigh'],
         ['claude-fable-5', 'max', 'max'],
@@ -1991,16 +2507,22 @@ describe('AnthropicChatProvider', () => {
       it.each([
         ['claude-opus-4-5', 'max'],
         ['claude-opus-4-5', 'xhigh'],
+        ['claude-opus-4-6', 'xhigh'],
         ['claude-sonnet-4-20250514', 'max'],
         ['claude-sonnet-4-20250514', 'xhigh'],
         ['claude-sonnet-4-5', 'xhigh'],
+        ['claude-sonnet-4-6', 'xhigh'],
         ['claude-haiku-4-5', 'max'],
       ] as const)(
-        'legacy budget rejects unsupported effort: %s + %s',
-        (model, effort) => {
-          expect(() => createProvider(model).withThinking(effort)).toThrow(
-            /budget-based thinking cannot express effort/,
+        'legacy budget passes an unlisted effort through: %s + %s',
+        async (model, effort) => {
+          const body = await captureRequestBody(
+            createProvider(model).withThinking(effort),
+            '',
+            [],
+            thinkHistory,
           );
+          expect(body['output_config']).toEqual({ effort });
         },
       );
 
@@ -2020,6 +2542,14 @@ describe('AnthropicChatProvider', () => {
           }
         },
       );
+
+      it('represents boolean on with the legacy high token budget', async () => {
+        const provider = createProvider('claude-sonnet-4-5').withThinking('on');
+        const body = await captureRequestBody(provider, '', [], thinkHistory);
+
+        expect(body['thinking']).toEqual({ type: 'enabled', budget_tokens: 32000 });
+        expect(body['output_config']).toBeUndefined();
+      });
     });
 
     // Effort-param gating: adaptive-capable models and explicit
@@ -2034,6 +2564,8 @@ describe('AnthropicChatProvider', () => {
         'claude-opus-4-6-20260205',
         'claude-sonnet-4-6',
         'claude-opus-5-0',
+        'gpt-4',
+        'claude-2.1',
         // Opus 4.5 explicitly supports effort (legacy budget thinking + effort)
         'claude-opus-4-5',
         'claude-opus-4-5-20251001',
@@ -2065,9 +2597,6 @@ describe('AnthropicChatProvider', () => {
         'claude-3-5-haiku-20241022',
         // Bedrock + old format
         'anthropic.claude-3-5-sonnet-20240620-v1:0',
-        // Non-Claude / garbage
-        'gpt-4',
-        'claude-2.1',
       ])('effort unsupported: %s -> output_config absent', async (model) => {
         const provider = createProvider(model).withThinking('high');
         const body = await captureRequestBody(provider, '', [], thinkHistory);
@@ -2125,19 +2654,19 @@ describe('AnthropicChatProvider', () => {
       expect(max.thinkingEffort).toBe('max');
     });
 
-    it('reports adaptive effort verbatim', () => {
-      const provider = createProvider('claude-sonnet-4-6').withThinking('xhigh');
-      expect(provider.thinkingEffort).toBe('xhigh');
+    it('reports an officially supported adaptive effort verbatim', () => {
+      const provider = createProvider('claude-sonnet-4-6').withThinking('max');
+      expect(provider.thinkingEffort).toBe('max');
     });
 
     it('pre-4.6 budget-based efforts', () => {
-      const low = createProvider().withThinking('low');
+      const low = createProvider('claude-sonnet-4-5').withThinking('low');
       expect(low.thinkingEffort).toBe('low');
 
-      const med = createProvider().withThinking('medium');
+      const med = createProvider('claude-sonnet-4-5').withThinking('medium');
       expect(med.thinkingEffort).toBe('medium');
 
-      const high = createProvider().withThinking('high');
+      const high = createProvider('claude-sonnet-4-5').withThinking('high');
       expect(high.thinkingEffort).toBe('high');
     });
   });
@@ -2334,6 +2863,30 @@ describe('AnthropicChatProvider', () => {
       });
     });
 
+    it('normalizes a thinking delta with no thinking field to an empty ThinkPart', async () => {
+      const parts = await collectAnthropicStreamParts([
+        {
+          type: 'content_block_delta',
+          index: 0,
+          delta: { type: 'thinking_delta' },
+        },
+      ]);
+
+      expect(parts).toEqual([{ type: 'think', think: '' }]);
+    });
+
+    it('normalizes a thinking block start with no thinking field to an empty ThinkPart', async () => {
+      const parts = await collectAnthropicStreamParts([
+        {
+          type: 'content_block_start',
+          index: 0,
+          content_block: { type: 'thinking' },
+        },
+      ]);
+
+      expect(parts).toEqual([{ type: 'think', think: '' }]);
+    });
+
     it('yields tool_use start and argument deltas from stream events', async () => {
       const provider = createStreamProvider();
       const stream = mockStream([
@@ -2743,7 +3296,8 @@ describe('resolveDefaultMaxTokens', () => {
     expect(resolveDefaultMaxTokens('claude-opus-4-5-20251101')).toBe(64000);
     expect(resolveDefaultMaxTokens('claude-opus-4-1-20250805')).toBe(32000);
     expect(resolveDefaultMaxTokens('claude-opus-4-20250514')).toBe(32000);
-    expect(resolveDefaultMaxTokens('claude-sonnet-4-6')).toBe(64000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-5')).toBe(128000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-4-6')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-sonnet-4-5-20250929')).toBe(64000);
     expect(resolveDefaultMaxTokens('claude-sonnet-4-20250514')).toBe(64000);
     expect(resolveDefaultMaxTokens('claude-haiku-4-5-20251001')).toBe(64000);
@@ -2772,7 +3326,7 @@ describe('resolveDefaultMaxTokens', () => {
     expect(resolveDefaultMaxTokens('claude-opus-4.8')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-opus-4.7')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-opus-4.6')).toBe(128000);
-    expect(resolveDefaultMaxTokens('claude-sonnet-4.6')).toBe(64000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-4.6')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-haiku-4.5')).toBe(64000);
   });
 
@@ -2797,7 +3351,7 @@ describe('resolveDefaultMaxTokens', () => {
     // ceiling (a newer minor inherits at least its predecessor's cap).
     expect(resolveDefaultMaxTokens('claude-opus-4-9')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-opus-4-10')).toBe(128000);
-    expect(resolveDefaultMaxTokens('claude-sonnet-4-9')).toBe(64000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-4-9')).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-haiku-4-9')).toBe(64000);
     // A gap between catalogued minors also resolves to the nearest lower one.
     expect(resolveDefaultMaxTokens('claude-opus-4-3')).toBe(32000);
@@ -2805,7 +3359,7 @@ describe('resolveDefaultMaxTokens', () => {
 
   it('matches case-insensitively', () => {
     expect(resolveDefaultMaxTokens('CLAUDE-OPUS-4-7')).toBe(128000);
-    expect(resolveDefaultMaxTokens('Claude-Sonnet-4-6')).toBe(64000);
+    expect(resolveDefaultMaxTokens('Claude-Sonnet-4-6')).toBe(128000);
     expect(resolveDefaultMaxTokens('Anthropic.Claude-Opus-4-7-v1:0')).toBe(128000);
   });
 
@@ -2822,19 +3376,19 @@ describe('resolveDefaultMaxTokens', () => {
 
   it('clamps an override above the documented ceiling for known models', () => {
     expect(resolveDefaultMaxTokens('claude-opus-4-7', 999999)).toBe(128000);
-    expect(resolveDefaultMaxTokens('claude-sonnet-4-6', 200000)).toBe(64000);
+    expect(resolveDefaultMaxTokens('claude-sonnet-4-6', 200000)).toBe(128000);
     expect(resolveDefaultMaxTokens('claude-3-opus', 99999)).toBe(4096);
   });
 
-  it('falls back to 32000 when both lookup and override miss', () => {
-    expect(resolveDefaultMaxTokens('totally-unknown-model')).toBe(32000);
-    expect(resolveDefaultMaxTokens('gpt-5')).toBe(32000);
+  it('falls back to the latest Opus 128k ceiling when both lookup and override miss', () => {
+    expect(resolveDefaultMaxTokens('totally-unknown-model')).toBe(128000);
+    expect(resolveDefaultMaxTokens('gpt-5')).toBe(128000);
   });
 
   it('does not apply Claude ceilings to non-Claude ids that contain an opus/sonnet/haiku token', () => {
     // No "claude" marker → fall through to the override / fallback rather
     // than quietly applying a Claude ceiling to a fine-tune or unrelated model.
-    expect(resolveDefaultMaxTokens('vendor-opus-4-7-preview')).toBe(32000);
+    expect(resolveDefaultMaxTokens('vendor-opus-4-7-preview')).toBe(128000);
     expect(resolveDefaultMaxTokens('vendor-opus-4-7-preview', 8000)).toBe(8000);
   });
 });
@@ -2861,7 +3415,7 @@ describe('AnthropicChatProvider constructor max_tokens', () => {
     expect(await maxTokensFor('claude-opus-4-7')).toBe(128000);
     expect(await maxTokensFor('claude-opus-4-6')).toBe(128000);
     expect(await maxTokensFor('claude-opus-4-5')).toBe(64000);
-    expect(await maxTokensFor('claude-sonnet-4-6')).toBe(64000);
+    expect(await maxTokensFor('claude-sonnet-4-6')).toBe(128000);
     expect(await maxTokensFor('claude-haiku-4-5-20251001')).toBe(64000);
   });
 
@@ -2873,6 +3427,10 @@ describe('AnthropicChatProvider constructor max_tokens', () => {
     expect(await maxTokensFor('unknown-model', { defaultMaxTokens: 12345 })).toBe(12345);
   });
 
+  it('uses the 128k fallback for unknown models without an override', async () => {
+    expect(await maxTokensFor('unknown-model')).toBe(128000);
+  });
+
   it('lets defaultMaxTokens lower the budget for known models', async () => {
     expect(await maxTokensFor('claude-opus-4-7', { defaultMaxTokens: 200 })).toBe(200);
   });
diff --git a/packages/kosong/test/e2e/anthropic-adapter.test.ts b/packages/kosong/test/e2e/anthropic-adapter.test.ts
index bbf020746..e30c00308 100644
--- a/packages/kosong/test/e2e/anthropic-adapter.test.ts
+++ b/packages/kosong/test/e2e/anthropic-adapter.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: exercise the Anthropic adapter over a real local HTTP connection.
+ * Responsibilities: verify public-provider request serialization and response parsing at the wire.
+ * Wiring: the provider and Anthropic SDK are real; only the remote Messages API is stubbed.
+ * Run: pnpm exec vitest run packages/kosong/test/e2e/anthropic-adapter.test.ts
+ */
 import type { Message, StreamedMessagePart, ToolCall } from '#/message';
 import { AnthropicChatProvider } from '#/providers/anthropic';
 import type { Tool } from '#/tool';
@@ -61,6 +67,111 @@ const MUL_TOOL: Tool = {
 };
 
 describe('e2e: Anthropic adapter bridge', () => {
+  it('replays model-switched text-only history as valid preserved-thinking wire content for a compatible endpoint', async () => {
+    const harness = await createFakeProviderHarness();
+
+    try {
+      harness.route('POST', '/v1/messages', async (_request, reply) => {
+        const stream = [
+          anthropicSseFrame('message_start', {
+            type: 'message_start',
+            message: {
+              id: 'msg_compatible',
+              type: 'message',
+              role: 'assistant',
+              model: 'compatible-preserved-thinking-model',
+              content: [],
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 12, output_tokens: 0 },
+            },
+          }),
+          anthropicSseFrame('content_block_start', {
+            type: 'content_block_start',
+            index: 0,
+            content_block: { type: 'text', text: 'Compatible endpoint accepted the history.' },
+          }),
+          anthropicSseFrame('content_block_stop', {
+            type: 'content_block_stop',
+            index: 0,
+          }),
+          anthropicSseFrame('message_delta', {
+            type: 'message_delta',
+            delta: { type: 'message_delta', stop_reason: 'end_turn', stop_sequence: null },
+            usage: { input_tokens: 12, output_tokens: 7 },
+          }),
+          anthropicSseFrame('message_stop', { type: 'message_stop' }),
+        ].join('');
+
+        await reply.raw(200, stream, {
+          'content-type': 'text/event-stream; charset=utf-8',
+          'cache-control': 'no-cache',
+          connection: 'keep-alive',
+        });
+      });
+
+      const provider = new AnthropicChatProvider({
+        model: 'compatible-preserved-thinking-model',
+        apiKey: 'test-key',
+        baseUrl: harness.baseUrl,
+        stream: true,
+      })
+        .withThinking('max')
+        .withThinkingKeep('all');
+      const history: Message[] = [
+        { role: 'user', content: [{ type: 'text', text: 'Hi' }], toolCalls: [] },
+        {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Hello from Opus' }],
+          toolCalls: [],
+        },
+        {
+          role: 'user',
+          content: [{ type: 'text', text: 'Continue with the compatible model' }],
+          toolCalls: [],
+        },
+      ];
+
+      const response = await provider.generate('', [], history);
+      expect(await collectParts(response)).toEqual([
+        { type: 'text', text: 'Compatible endpoint accepted the history.' },
+      ]);
+      expect(harness.requests).toHaveLength(1);
+      expect(harness.requests[0]!.search).toBe('?beta=true');
+      expect(harness.requests[0]!.headers['anthropic-beta']).toBe(
+        'context-management-2025-06-27',
+      );
+      expect(harness.requests[0]!.bodyJson).toMatchObject({
+        model: 'compatible-preserved-thinking-model',
+        max_tokens: 128000,
+        thinking: { type: 'adaptive', display: 'summarized' },
+        output_config: { effort: 'max' },
+        context_management: {
+          edits: [{ type: 'clear_thinking_20251015', keep: 'all' }],
+        },
+        messages: [
+          { role: 'user', content: [{ type: 'text', text: 'Hi' }] },
+          {
+            role: 'assistant',
+            content: [{ type: 'text', text: 'Hello from Opus' }],
+          },
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'text',
+                text: 'Continue with the compatible model',
+                cache_control: { type: 'ephemeral' },
+              },
+            ],
+          },
+        ],
+      });
+    } finally {
+      await harness.close();
+    }
+  });
+
   it('sends the adapter request body and parses streamed text, tool use, and usage', async () => {
     const previousAuthToken = process.env['ANTHROPIC_AUTH_TOKEN'];
     const previousCustomHeaders = process.env['ANTHROPIC_CUSTOM_HEADERS'];
diff --git a/packages/kosong/test/e2e/google-genai-adapter.test.ts b/packages/kosong/test/e2e/google-genai-adapter.test.ts
index 12210eff2..a9b925f24 100644
--- a/packages/kosong/test/e2e/google-genai-adapter.test.ts
+++ b/packages/kosong/test/e2e/google-genai-adapter.test.ts
@@ -210,7 +210,7 @@ describe('e2e: Google GenAI adapter bridge', () => {
         { type: 'text', text: 'Done.' },
         {
           type: 'function',
-          id: 'notify_call-1',
+          id: expect.stringMatching(/^notify_call-1_[0-9a-f]{8}$/),
           name: 'notify', arguments: '{"ok":true}',
           extras: { thought_signature_b64: 'sig-1' },
         } satisfies ToolCall,
diff --git a/packages/kosong/test/finish-reason.test.ts b/packages/kosong/test/finish-reason.test.ts
index 511919841..324b86713 100644
--- a/packages/kosong/test/finish-reason.test.ts
+++ b/packages/kosong/test/finish-reason.test.ts
@@ -86,11 +86,26 @@ function makeOpenAIChatClient(response: unknown) {
   };
 }
 
+// The Kimi provider consumes `APIPromise.withResponse()` to read the
+// `x-trace-id` response header, so its mocked client must expose that method.
+function makeKimiChatClient(response: unknown) {
+  return {
+    chat: {
+      completions: {
+        create: vi.fn().mockImplementation(() => ({
+          withResponse: () =>
+            Promise.resolve({ data: response, response: new Response(null) }),
+        })),
+      },
+    },
+  };
+}
+
 function createKimiProvider(response: unknown, stream: boolean): KimiChatProvider {
   return new KimiChatProvider({
     model: 'kimi-k2-turbo-preview',
     stream,
-    clientFactory: () => makeOpenAIChatClient(response) as never,
+    clientFactory: () => makeKimiChatClient(response) as never,
   });
 }
 
diff --git a/packages/kosong/test/fixtures/echo-provider.ts b/packages/kosong/test/fixtures/echo-provider.ts
index 9317001c1..dcb80448c 100644
--- a/packages/kosong/test/fixtures/echo-provider.ts
+++ b/packages/kosong/test/fixtures/echo-provider.ts
@@ -319,6 +319,7 @@ class EchoStreamedMessage implements StreamedMessage {
   readonly usage: TokenUsage | null;
   readonly finishReason: FinishReason | null;
   readonly rawFinishReason: string | null;
+  readonly traceId: string | null = null;
 
   private readonly _parts: StreamedMessagePart[];
 
diff --git a/packages/kosong/test/fixtures/mock-provider.ts b/packages/kosong/test/fixtures/mock-provider.ts
index c6b55ddf8..55e8d12ac 100644
--- a/packages/kosong/test/fixtures/mock-provider.ts
+++ b/packages/kosong/test/fixtures/mock-provider.ts
@@ -91,6 +91,7 @@ class MockStreamedMessage implements StreamedMessage {
   readonly usage: TokenUsage | null;
   readonly finishReason: FinishReason | null;
   readonly rawFinishReason: string | null;
+  readonly traceId: string | null = null;
 
   private readonly _parts: StreamedMessagePart[];
 
diff --git a/packages/kosong/test/generate.test.ts b/packages/kosong/test/generate.test.ts
index 152a89f6a..4f84b9572 100644
--- a/packages/kosong/test/generate.test.ts
+++ b/packages/kosong/test/generate.test.ts
@@ -47,6 +47,21 @@ function createMockProvider(stream: StreamedMessage): ChatProvider {
   };
 }
 describe('generate()', () => {
+  it('omits trace metadata when the provider does not expose it', async () => {
+    const onTraceId = vi.fn();
+    const result = await generate(
+      createMockProvider(createMockStream([{ type: 'text', text: 'ok' }])),
+      '',
+      [],
+      [],
+      undefined,
+      { onTraceId },
+    );
+
+    expect(onTraceId).not.toHaveBeenCalled();
+    expect(Object.hasOwn(result, 'traceId')).toBe(false);
+  });
+
   it('merges consecutive TextParts and filters empty ones', async () => {
     const stream = createMockStream([
       { type: 'text', text: 'Hello, ' },
diff --git a/packages/kosong/test/google-genai.test.ts b/packages/kosong/test/google-genai.test.ts
index b8a2468dd..e29614b08 100644
--- a/packages/kosong/test/google-genai.test.ts
+++ b/packages/kosong/test/google-genai.test.ts
@@ -753,10 +753,10 @@ describe('GoogleGenAIChatProvider', () => {
     // When a tool message arrives without a preceding assistant message
     // carrying the tool_call (e.g. after history compaction), the provider
     // falls back to parsing the name out of the tool_call_id. Google IDs
-    // produced by this provider have the shape "{tool_name}_{id_suffix}"
-    // where the suffix is a single non-underscored token, so stripping the
-    // first underscore truncates multi-word tool names such as
-    // `fetch_image_<id>` down to `fetch`.
+    // produced by this provider have the shape "{tool_name}_{upstream_id}_{entropy}"
+    // where `entropy` is a fixed 8-hex-char suffix and the upstream id is a
+    // non-underscored token, so stripping the first underscore would truncate
+    // multi-word tool names such as `fetch_image_<id>` down to `fetch`.
     function firstFunctionResponseName(history: Message[]): string | undefined {
       const contents = messagesToGoogleGenAIContents(history);
       for (const content of contents) {
@@ -814,6 +814,30 @@ describe('GoogleGenAIChatProvider', () => {
       ];
       expect(firstFunctionResponseName(history)).toBe('bareid');
     });
+
+    it('strips both the entropy suffix and the upstream id', () => {
+      const history: Message[] = [
+        {
+          role: 'tool',
+          content: [{ type: 'text', text: 'ok' }],
+          toolCallId: 'AgentSwarm_0_ab12cd34',
+          toolCalls: [],
+        },
+      ];
+      expect(firstFunctionResponseName(history)).toBe('AgentSwarm');
+    });
+
+    it('strips entropy and upstream id from multi-word tool names', () => {
+      const history: Message[] = [
+        {
+          role: 'tool',
+          content: [{ type: 'text', text: 'ok' }],
+          toolCallId: 'fetch_image_abc123_a1b2c3d4',
+          toolCalls: [],
+        },
+      ];
+      expect(firstFunctionResponseName(history)).toBe('fetch_image');
+    });
   });
 
   describe('no id in functionCall or functionResponse', () => {
@@ -1224,7 +1248,7 @@ describe('GoogleGenAIChatProvider', () => {
       expect(parts).toEqual([
         {
           type: 'function',
-          id: 'add_call_1',
+          id: expect.stringMatching(/^add_call_1_[0-9a-f]{8}$/),
           name: 'add', arguments: '{"a":2,"b":3}',
         },
       ]);
@@ -1254,7 +1278,7 @@ describe('GoogleGenAIChatProvider', () => {
       expect(parts).toEqual([
         {
           type: 'function',
-          id: 'search_fc_1',
+          id: expect.stringMatching(/^search_fc_1_[0-9a-f]{8}$/),
           name: 'search', arguments: '{"q":"test"}',
           extras: { thought_signature_b64: 'sig_abc123' },
         },
diff --git a/packages/kosong/test/kimi.test.ts b/packages/kosong/test/kimi.test.ts
index e14d3e510..12d898396 100644
--- a/packages/kosong/test/kimi.test.ts
+++ b/packages/kosong/test/kimi.test.ts
@@ -31,6 +31,24 @@ function createProvider(stream: boolean = false): KimiChatProvider {
   });
 }
 
+/**
+ * The provider reads the KFC `x-trace-id` response header via the SDK's
+ * `APIPromise.withResponse()`, so mocked `chat.completions.create` calls must
+ * resolve to an object exposing that method. `traceId` sets the header value
+ * the fake response reports.
+ */
+function mockCreateResult(data: unknown, traceId?: string) {
+  return {
+    withResponse: () =>
+      Promise.resolve({
+        data,
+        response: new Response(null, {
+          headers: traceId === undefined ? {} : { 'x-trace-id': traceId },
+        }),
+      }),
+  };
+}
+
 type KimiGenerationState = {
   max_tokens?: number | undefined;
   temperature?: number | undefined;
@@ -56,7 +74,7 @@ async function captureRequestBody(
     .fn()
     .mockImplementation((params: unknown) => {
       capturedBody = params as Record<string, unknown>;
-      return Promise.resolve(makeChatCompletionResponse('kimi-k2'));
+      return mockCreateResult(makeChatCompletionResponse('kimi-k2'));
     });
 
   const stream = await provider.generate(systemPrompt, tools, history, options);
@@ -77,7 +95,7 @@ async function captureKimiMessages(
   let captured: Record<string, unknown> | undefined;
   const create = vi.fn().mockImplementation((params: unknown) => {
     captured = params as Record<string, unknown>;
-    return Promise.resolve(makeChatCompletionResponse('kimi-k2'));
+    return mockCreateResult(makeChatCompletionResponse('kimi-k2'));
   });
   let provider = new KimiChatProvider({
     model: 'kimi-k2',
@@ -633,7 +651,7 @@ describe('KimiChatProvider', () => {
       ]);
     });
 
-    it('backfills an assistant tool-call message when preserved thinking is active', async () => {
+    it('sends empty reasoning_content for an assistant tool call when preserved thinking is active', async () => {
       const history: Message[] = [
         {
           role: 'assistant',
@@ -651,7 +669,7 @@ describe('KimiChatProvider', () => {
       expect(messages[0]).toHaveProperty('reasoning_content', '');
     });
 
-    it('backfills a text assistant message when keep=all omits thinking.type', async () => {
+    it('sends empty reasoning_content for a text assistant when keep=all omits thinking.type', async () => {
       const history: Message[] = [
         {
           role: 'assistant',
@@ -667,27 +685,59 @@ describe('KimiChatProvider', () => {
       expect(messages[0]).toHaveProperty('reasoning_content', '');
     });
 
-    it.each([
-      ['empty', ''],
-      ['non-empty', 'reasoning text'],
-    ])(
-      'sends an existing %s ThinkPart verbatim when preserved thinking is active',
-      async (_kind, think) => {
-        const history: Message[] = [
-          {
-            role: 'assistant',
-            content: [{ type: 'think', think }],
-            toolCalls: [],
-          },
-        ];
+    it('replays an existing empty ThinkPart unchanged when preserved thinking is active', async () => {
+      const history: Message[] = [
+        {
+          role: 'assistant',
+          content: [{ type: 'think', think: '' }],
+          toolCalls: [],
+        },
+      ];
 
-        const messages = await captureKimiMessages(history, (provider) =>
-          provider.withExtraBody({ thinking: { type: 'enabled', keep: 'all' } }),
-        );
+      const messages = await captureKimiMessages(history, (provider) =>
+        provider.withExtraBody({ thinking: { type: 'enabled', keep: 'all' } }),
+      );
 
-        expect(messages[0]).toHaveProperty('reasoning_content', think);
-      },
-    );
+      expect(messages[0]).toHaveProperty('reasoning_content', '');
+    });
+
+    it('replays aggregated empty ThinkParts unchanged when preserved thinking is active', async () => {
+      const history: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'think', think: '' },
+            { type: 'think', think: '' },
+          ],
+          toolCalls: [],
+        },
+      ];
+
+      const messages = await captureKimiMessages(history, (provider) =>
+        provider.withExtraBody({ thinking: { type: 'enabled', keep: 'all' } }),
+      );
+
+      expect(messages[0]).toHaveProperty('reasoning_content', '');
+    });
+
+    it('preserves non-empty reasoning when preserved thinking is active', async () => {
+      const history: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'think', think: '' },
+            { type: 'think', think: 'reasoning text' },
+          ],
+          toolCalls: [],
+        },
+      ];
+
+      const messages = await captureKimiMessages(history, (provider) =>
+        provider.withExtraBody({ thinking: { type: 'enabled', keep: 'all' } }),
+      );
+
+      expect(messages[0]).toHaveProperty('reasoning_content', 'reasoning text');
+    });
 
     it.each([
       ['missing', undefined],
@@ -1050,7 +1100,7 @@ describe('KimiChatProvider', () => {
       const client = {
         chat: {
           completions: {
-            create: vi.fn().mockResolvedValue(makeChatCompletionResponse('kimi-k2')),
+            create: vi.fn().mockImplementation(() => mockCreateResult(makeChatCompletionResponse('kimi-k2'))),
           },
         },
       };
@@ -1132,11 +1182,13 @@ describe('KimiChatProvider', () => {
   describe('non-stream response parsing', () => {
     it('yields text content from non-stream response', async () => {
       const provider = createProvider();
-      (provider as any)._client.chat.completions.create = vi.fn().mockResolvedValue({
-        id: 'chatcmpl-123',
-        choices: [{ message: { role: 'assistant', content: 'Hello world' } }],
-        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
-      });
+      (provider as any)._client.chat.completions.create = vi.fn().mockImplementation(() =>
+        mockCreateResult({
+          id: 'chatcmpl-123',
+          choices: [{ message: { role: 'assistant', content: 'Hello world' } }],
+          usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+        }),
+      );
 
       const stream = await provider.generate(
         '',
@@ -1161,19 +1213,21 @@ describe('KimiChatProvider', () => {
 
     it('yields reasoning_content as ThinkPart', async () => {
       const provider = createProvider();
-      (provider as any)._client.chat.completions.create = vi.fn().mockResolvedValue({
-        id: 'chatcmpl-123',
-        choices: [
-          {
-            message: {
-              role: 'assistant',
-              content: 'The answer is 4.',
-              reasoning_content: 'Let me think about this...',
+      (provider as any)._client.chat.completions.create = vi.fn().mockImplementation(() =>
+        mockCreateResult({
+          id: 'chatcmpl-123',
+          choices: [
+            {
+              message: {
+                role: 'assistant',
+                content: 'The answer is 4.',
+                reasoning_content: 'Let me think about this...',
+              },
             },
-          },
-        ],
-        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
-      });
+          ],
+          usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+        }),
+      );
 
       const stream = await provider.generate(
         '',
@@ -1194,25 +1248,27 @@ describe('KimiChatProvider', () => {
 
     it('yields an empty ThinkPart when reasoning_content is explicitly empty', async () => {
       const provider = createProvider();
-      (provider as any)._client.chat.completions.create = vi.fn().mockResolvedValue({
-        id: 'chatcmpl-empty-reasoning',
-        choices: [
-          {
-            message: {
-              role: 'assistant',
-              content: null,
-              reasoning_content: '',
-              tool_calls: [
-                {
-                  id: 'call_1',
-                  type: 'function',
-                  function: { name: 'lookup', arguments: '{"q":"test"}' },
-                },
-              ],
+      (provider as any)._client.chat.completions.create = vi.fn().mockImplementation(() =>
+        mockCreateResult({
+          id: 'chatcmpl-empty-reasoning',
+          choices: [
+            {
+              message: {
+                role: 'assistant',
+                content: null,
+                reasoning_content: '',
+                tool_calls: [
+                  {
+                    id: 'call_1',
+                    type: 'function',
+                    function: { name: 'lookup', arguments: '{"q":"test"}' },
+                  },
+                ],
+              },
             },
-          },
-        ],
-      });
+          ],
+        }),
+      );
 
       const stream = await provider.generate('', [], []);
       const parts = [];
@@ -1230,6 +1286,66 @@ describe('KimiChatProvider', () => {
     });
   });
 
+  describe('trace id capture', () => {
+    it('reads x-trace-id from a non-stream response', async () => {
+      const provider = createProvider();
+      (provider as any)._client.chat.completions.create = vi
+        .fn()
+        .mockImplementation(() => mockCreateResult(makeChatCompletionResponse('kimi-k2'), 'trace-abc'));
+
+      const stream = await provider.generate('', [], []);
+      for await (const part of stream) void part;
+
+      expect(stream.traceId).toBe('trace-abc');
+    });
+
+    it('reads x-trace-id from a streaming response before the body is drained', async () => {
+      const provider = createProvider(true);
+      async function* chunks(): AsyncIterable<Record<string, unknown>> {
+        yield {
+          id: 'chatcmpl-stream',
+          choices: [{ index: 0, delta: { content: 'hi' }, finish_reason: 'stop' }],
+        };
+      }
+      (provider as any)._client.chat.completions.create = vi
+        .fn()
+        .mockImplementation(() => mockCreateResult(chunks(), 'trace-stream'));
+
+      const stream = await provider.generate('', [], []);
+      // The header arrives with the response, before any streamed part.
+      expect(stream.traceId).toBe('trace-stream');
+      for await (const part of stream) void part;
+      expect(stream.traceId).toBe('trace-stream');
+    });
+
+    it('reports null when the response carries no x-trace-id header', async () => {
+      const provider = createProvider();
+      (provider as any)._client.chat.completions.create = vi
+        .fn()
+        .mockImplementation(() => mockCreateResult(makeChatCompletionResponse('kimi-k2')));
+
+      const stream = await provider.generate('', [], []);
+      for await (const part of stream) void part;
+
+      expect(stream.traceId).toBeNull();
+    });
+
+    it('generate() carries traceId onto the result and fires onTraceId once headers arrive', async () => {
+      const provider = createProvider();
+      (provider as any)._client.chat.completions.create = vi
+        .fn()
+        .mockImplementation(() => mockCreateResult(makeChatCompletionResponse('kimi-k2'), 'trace-gen'));
+
+      const traceIds: Array<string | null> = [];
+      const result = await generate(provider, '', [], [], undefined, {
+        onTraceId: (traceId) => traceIds.push(traceId),
+      });
+
+      expect(traceIds).toEqual(['trace-gen']);
+      expect(result.traceId).toBe('trace-gen');
+    });
+  });
+
   describe('streaming tool call routing', () => {
     interface MockToolCallDelta {
       index: number;
@@ -1278,7 +1394,7 @@ describe('KimiChatProvider', () => {
       ];
       (
         provider as unknown as { _client: { chat: { completions: { create: unknown } } } }
-      )._client.chat.completions.create = vi.fn().mockResolvedValue(mockStream(chunks));
+      )._client.chat.completions.create = vi.fn().mockImplementation(() => mockCreateResult(mockStream(chunks)));
 
       const stream = await provider.generate('', [], []);
       const parts = [];
@@ -1300,7 +1416,7 @@ describe('KimiChatProvider', () => {
 
       (
         provider as unknown as { _client: { chat: { completions: { create: unknown } } } }
-      )._client.chat.completions.create = vi.fn().mockResolvedValue(mockStream(chunks));
+      )._client.chat.completions.create = vi.fn().mockImplementation(() => mockCreateResult(mockStream(chunks)));
 
       const result = await generate(
         provider,
@@ -1332,7 +1448,7 @@ describe('KimiChatProvider', () => {
 
       (
         provider as unknown as { _client: { chat: { completions: { create: unknown } } } }
-      )._client.chat.completions.create = vi.fn().mockResolvedValue(mockStream(chunks));
+      )._client.chat.completions.create = vi.fn().mockImplementation(() => mockCreateResult(mockStream(chunks)));
 
       const events: string[] = [];
       await generate(
@@ -1389,7 +1505,7 @@ describe('KimiChatProvider', () => {
 
       (
         provider as unknown as { _client: { chat: { completions: { create: unknown } } } }
-      )._client.chat.completions.create = vi.fn().mockResolvedValue(mockStream(chunks));
+      )._client.chat.completions.create = vi.fn().mockImplementation(() => mockCreateResult(mockStream(chunks)));
 
       const result = await generate(
         provider,
@@ -1464,7 +1580,7 @@ describe('KimiChatProvider', () => {
 
       (
         provider as unknown as { _client: { chat: { completions: { create: unknown } } } }
-      )._client.chat.completions.create = vi.fn().mockResolvedValue(mockStream([singleChunk]));
+      )._client.chat.completions.create = vi.fn().mockImplementation(() => mockCreateResult(mockStream([singleChunk])));
 
       // generate() uses the reducer which expects a ToolCall header before
       // accumulating arguments. A pure arg-only without a prior header is
@@ -1479,25 +1595,27 @@ describe('KimiChatProvider', () => {
 
     it('non-stream response with tool_calls yields ToolCall parts', async () => {
       const provider = createProvider(false);
-      (provider as any)._client.chat.completions.create = vi.fn().mockResolvedValue({
-        id: 'chatcmpl-nonstream',
-        choices: [
-          {
-            message: {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  id: 'call_ns_a',
-                  type: 'function',
-                  function: { name: 'lookup', arguments: '{"q":"hi"}' },
-                },
-              ],
+      (provider as any)._client.chat.completions.create = vi.fn().mockImplementation(() =>
+        mockCreateResult({
+          id: 'chatcmpl-nonstream',
+          choices: [
+            {
+              message: {
+                role: 'assistant',
+                content: null,
+                tool_calls: [
+                  {
+                    id: 'call_ns_a',
+                    type: 'function',
+                    function: { name: 'lookup', arguments: '{"q":"hi"}' },
+                  },
+                ],
+              },
             },
-          },
-        ],
-        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
-      });
+          ],
+          usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+        }),
+      );
 
       const stream = await provider.generate(
         '',
@@ -1518,23 +1636,25 @@ describe('KimiChatProvider', () => {
 
     it('non-stream response generates UUID when tool_call has no id', async () => {
       const provider = createProvider(false);
-      (provider as any)._client.chat.completions.create = vi.fn().mockResolvedValue({
-        id: 'chatcmpl-uuid',
-        choices: [
-          {
-            message: {
-              role: 'assistant',
-              content: null,
-              tool_calls: [
-                {
-                  type: 'function',
-                  function: { name: 'lookup', arguments: '{}' },
-                },
-              ],
+      (provider as any)._client.chat.completions.create = vi.fn().mockImplementation(() =>
+        mockCreateResult({
+          id: 'chatcmpl-uuid',
+          choices: [
+            {
+              message: {
+                role: 'assistant',
+                content: null,
+                tool_calls: [
+                  {
+                    type: 'function',
+                    function: { name: 'lookup', arguments: '{}' },
+                  },
+                ],
+              },
             },
-          },
-        ],
-      });
+          ],
+        }),
+      );
 
       const stream = await provider.generate(
         '',
diff --git a/packages/kosong/test/openai-common-errors.test.ts b/packages/kosong/test/openai-common-errors.test.ts
index f8cd126e9..d2b1bf388 100644
--- a/packages/kosong/test/openai-common-errors.test.ts
+++ b/packages/kosong/test/openai-common-errors.test.ts
@@ -141,6 +141,37 @@ describe('convertOpenAIError: provider rate limit', () => {
     expect(result).toBeInstanceOf(APIProviderRateLimitError);
     expect((result as APIProviderRateLimitError).retryAfterMs).toBeNull();
   });
+
+  it('carries the x-trace-id response header onto the status error', () => {
+    const err = new OpenAIAPIError(
+      500,
+      undefined,
+      'Internal server error',
+      new Headers({ 'x-trace-id': 'trace-err-500' }),
+    );
+    const result = convertOpenAIError(err);
+    expect(result).toBeInstanceOf(APIStatusError);
+    expect((result as APIStatusError).traceId).toBe('trace-err-500');
+  });
+
+  it('leaves traceId null when the error response has no x-trace-id header', () => {
+    const err = new OpenAIAPIError(500, undefined, 'Internal server error', new Headers());
+    const result = convertOpenAIError(err);
+    expect(result).toBeInstanceOf(APIStatusError);
+    expect((result as APIStatusError).traceId).toBeNull();
+  });
+
+  it('leaves traceId null when the x-trace-id header is empty', () => {
+    const err = new OpenAIAPIError(
+      500,
+      undefined,
+      'Internal server error',
+      new Headers({ 'x-trace-id': '' }),
+    );
+    const result = convertOpenAIError(err);
+    expect(result).toBeInstanceOf(APIStatusError);
+    expect((result as APIStatusError).traceId).toBeNull();
+  });
 });
 describe('convertOpenAIError: subclass errors still match first', () => {
   it('APIConnectionError matches its own case', () => {
diff --git a/packages/kosong/test/openai-legacy.test.ts b/packages/kosong/test/openai-legacy.test.ts
index 2cd371ade..915580eab 100644
--- a/packages/kosong/test/openai-legacy.test.ts
+++ b/packages/kosong/test/openai-legacy.test.ts
@@ -992,6 +992,43 @@ describe('OpenAILegacyChatProvider', () => {
       expect(maxBody['reasoning_effort']).toBe('max');
       expect(xhighBody['reasoning_effort']).toBe('xhigh');
     });
+
+    it('.withThinking("off") sends no reasoning_effort and reports "off"', async () => {
+      const provider = createProvider().withThinking('off');
+      const history: Message[] = [
+        { role: 'user', content: [{ type: 'text', text: 'Think' }], toolCalls: [] },
+      ];
+      const body = await captureRequestBody(provider, '', [], history);
+
+      expect(body['reasoning_effort']).toBeUndefined();
+      expect(provider.thinkingEffort).toBe('off');
+    });
+
+    it('.withThinking("on") sends no reasoning_effort without ThinkPart history and reports "on"', async () => {
+      const provider = createProvider().withThinking('on');
+      const history: Message[] = [
+        { role: 'user', content: [{ type: 'text', text: 'Think' }], toolCalls: [] },
+      ];
+      const body = await captureRequestBody(provider, '', [], history);
+
+      expect(body['reasoning_effort']).toBeUndefined();
+      expect(provider.thinkingEffort).toBe('on');
+    });
+
+    it('reports a null thinkingEffort until withThinking is called', () => {
+      expect(createProvider().thinkingEffort).toBeNull();
+    });
+
+    it('.withThinking("off") clears a concrete effort set earlier', async () => {
+      const provider = createProvider().withThinking('high').withThinking('off');
+      expect(provider.thinkingEffort).toBe('off');
+
+      const history: Message[] = [
+        { role: 'user', content: [{ type: 'text', text: 'Think' }], toolCalls: [] },
+      ];
+      const body = await captureRequestBody(provider, '', [], history);
+      expect(body['reasoning_effort']).toBeUndefined();
+    });
   });
 
   describe('auto reasoning_effort', () => {
@@ -1082,6 +1119,52 @@ describe('OpenAILegacyChatProvider', () => {
 
       expect(body['reasoning_effort']).toBe('high');
     });
+
+    it('does not auto-inject reasoning_effort when thinking was explicitly turned off', async () => {
+      // An explicit withThinking('off') is not the same as "never configured":
+      // with thinking off, auto-injection must not silently switch reasoning
+      // back on (or leak reasoning_effort to models that reject the field).
+      const provider = createProvider({ model: 'some-model' }).withThinking('off');
+      const history: Message[] = [
+        { role: 'user', content: [{ type: 'text', text: 'Hello' }], toolCalls: [] },
+        {
+          role: 'assistant',
+          content: [
+            { type: 'think', think: 'Thinking...' },
+            { type: 'text', text: 'Hi!' },
+          ],
+          toolCalls: [],
+        },
+        { role: 'user', content: [{ type: 'text', text: 'How are you?' }], toolCalls: [] },
+      ];
+      const body = await captureRequestBody(provider, '', [], history);
+
+      expect(body['reasoning_effort']).toBeUndefined();
+      expect(provider.thinkingEffort).toBe('off');
+    });
+
+    it('still auto-injects reasoning_effort for an explicit "on"', async () => {
+      // 'on' keeps the #1616 behavior: thinking enabled without a concrete
+      // effort still pairs reasoning_effort with ThinkPart history so strict
+      // OpenAI-compatible gateways don't 400.
+      const provider = createProvider({ model: 'some-model' }).withThinking('on');
+      const history: Message[] = [
+        { role: 'user', content: [{ type: 'text', text: 'Hello' }], toolCalls: [] },
+        {
+          role: 'assistant',
+          content: [
+            { type: 'think', think: 'Thinking...' },
+            { type: 'text', text: 'Hi!' },
+          ],
+          toolCalls: [],
+        },
+        { role: 'user', content: [{ type: 'text', text: 'How are you?' }], toolCalls: [] },
+      ];
+      const body = await captureRequestBody(provider, '', [], history);
+
+      expect(body['reasoning_effort']).toBe('medium');
+      expect(provider.thinkingEffort).toBe('on');
+    });
   });
 
   describe('default reasoning protocol (no explicit reasoningKey)', () => {
diff --git a/packages/kosong/test/select-tools.test.ts b/packages/kosong/test/select-tools.test.ts
index 9d2706eb9..1e5574ef9 100644
--- a/packages/kosong/test/select-tools.test.ts
+++ b/packages/kosong/test/select-tools.test.ts
@@ -74,7 +74,15 @@ async function captureRequestBody(
     .fn()
     .mockImplementation((params: unknown) => {
       capturedBody = params as Record<string, unknown>;
-      return Promise.resolve(makeChatCompletionResponse());
+      // The Kimi provider consumes `APIPromise.withResponse()` to read the
+      // `x-trace-id` header, so the mock must expose that method.
+      return {
+        withResponse: () =>
+          Promise.resolve({
+            data: makeChatCompletionResponse(),
+            response: new Response(null),
+          }),
+      };
     });
   const stream = await provider.generate('system prompt', tools, history);
   for await (const part of stream) {
diff --git a/packages/kosong/tsdown.config.ts b/packages/kosong/tsdown.config.ts
index 00783406f..577fed3fe 100644
--- a/packages/kosong/tsdown.config.ts
+++ b/packages/kosong/tsdown.config.ts
@@ -6,6 +6,7 @@ export default defineConfig({
     './src/providers/kimi.ts',
     './src/providers/openai-legacy.ts',
     './src/providers/openai-responses.ts',
+    './src/providers/anthropic-profile.ts',
     './src/providers/anthropic.ts',
     './src/providers/google-genai.ts',
     './src/providers/openai-common.ts',
diff --git a/packages/migration-legacy/CHANGELOG.md b/packages/migration-legacy/CHANGELOG.md
index e3bfb31e7..88d4b541f 100644
--- a/packages/migration-legacy/CHANGELOG.md
+++ b/packages/migration-legacy/CHANGELOG.md
@@ -1,5 +1,14 @@
 # @moonshot-ai/migration-legacy
 
+## 0.1.16
+
+### Patch Changes
+
+- [#1769](https://github.com/MoonshotAI/kimi-code/pull/1769) [`d1ca65e`](https://github.com/MoonshotAI/kimi-code/commit/d1ca65e1de189617e9edbc54010e62d472a1de3d) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Keep legacy migrations idempotent across multiple Kimi homes and report damaged or unmapped sessions instead of silently skipping them.
+
+- Updated dependencies [[`d1ca65e`](https://github.com/MoonshotAI/kimi-code/commit/d1ca65e1de189617e9edbc54010e62d472a1de3d)]:
+  - @moonshot-ai/agent-core@0.15.5
+
 ## 0.1.15
 
 ### Patch Changes
diff --git a/packages/migration-legacy/package.json b/packages/migration-legacy/package.json
index d68b1d993..52448df87 100644
--- a/packages/migration-legacy/package.json
+++ b/packages/migration-legacy/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/migration-legacy",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Migrate kimi-cli (~/.kimi/) data into kimi-code (~/.kimi-code/).",
   "license": "MIT",
   "type": "module",
diff --git a/packages/migration-legacy/src/detect.ts b/packages/migration-legacy/src/detect.ts
index ec2a9ac46..e46fb78c5 100644
--- a/packages/migration-legacy/src/detect.ts
+++ b/packages/migration-legacy/src/detect.ts
@@ -13,7 +13,12 @@ import {
   sourceSessionsDir,
   sourceKimiJson,
 } from './paths.js';
-import type { MigrationPlan, SessionEntry, WorkDirEntry } from './types.js';
+import type {
+  MigrationPlan,
+  SessionEntry,
+  SessionMigrationFailure,
+  WorkDirEntry,
+} from './types.js';
 import { classifySessionDir } from './sessions/classify.js';
 import { oldMd5BucketName } from './sessions/workdir-bucket.js';
 
@@ -51,22 +56,43 @@ export async function detectMigration(opts: { sourcePath: string }): Promise<Mig
 
   const workdirs: WorkDirEntry[] = [];
   let totalSessions = 0;
+  const sessionScanFailures: SessionMigrationFailure[] = [];
 
+  const sessionsRoot = sourceSessionsDir(src);
   try {
-    const sessionsRoot = sourceSessionsDir(src);
     const bucketNames = await readdir(sessionsRoot);
     for (const bucketName of bucketNames) {
-      // Skip non-local-kaos buckets (`<kaos>_<md5>`) and unknown formats.
-      if (!MD5_HEX_RE.test(bucketName)) continue;
+      const bucketPath = join(sessionsRoot, bucketName);
+      // Skip non-local-kaos buckets (`<kaos>_<md5>`), which cannot be
+      // represented by the local Kimi Code runtime. Every other unknown
+      // bucket is user data we failed to map and must remain visible.
+      if (!MD5_HEX_RE.test(bucketName)) {
+        const separator = bucketName.lastIndexOf('_');
+        if (separator > 0 && MD5_HEX_RE.test(bucketName.slice(separator + 1))) continue;
+        sessionScanFailures.push({
+          sourcePath: bucketPath,
+          reason: unknownWorkdirReason(),
+        });
+        continue;
+      }
       const wd = workdirMap.get(bucketName);
-      if (wd === undefined) continue;
+      if (wd === undefined) {
+        sessionScanFailures.push({
+          sourcePath: bucketPath,
+          reason: unknownWorkdirReason(),
+        });
+        continue;
+      }
       if (wd.kaos !== 'local') continue;
 
-      const bucketPath = join(sessionsRoot, bucketName);
       let uuids: string[];
       try {
         uuids = await readdir(bucketPath);
-      } catch {
+      } catch (error) {
+        sessionScanFailures.push({
+          sourcePath: bucketPath,
+          reason: `Legacy session bucket could not be read: ${formatError(error)}`,
+        });
         continue;
       }
 
@@ -74,6 +100,13 @@ export async function detectMigration(opts: { sourcePath: string }): Promise<Mig
       for (const uuid of uuids) {
         const sessionDir = join(bucketPath, uuid);
         const cls = await classifySessionDir(sessionDir);
+        if (cls === 'malformed') {
+          sessionScanFailures.push({
+            sourcePath: sessionDir,
+            reason: unreadableSessionReason(),
+          });
+          continue;
+        }
         if (cls !== 'real') continue;
         const wireMtime = await readWireMtime(sessionDir);
         sessions.push({ uuid, oldDir: sessionDir, wireMtime });
@@ -84,8 +117,13 @@ export async function detectMigration(opts: { sourcePath: string }): Promise<Mig
         workdirs.push({ oldHashDir: bucketPath, workdirPath: wd.path, sessions });
       }
     }
-  } catch {
-    // sessions dir missing — leave workdirs empty
+  } catch (error) {
+    if (!isMissingError(error)) {
+      sessionScanFailures.push({
+        sourcePath: sessionsRoot,
+        reason: `Legacy sessions directory could not be read: ${formatError(error)}`,
+      });
+    }
   }
 
   return {
@@ -98,9 +136,31 @@ export async function detectMigration(opts: { sourcePath: string }): Promise<Mig
     detectedPlugins,
     detectedMcpOauthServers,
     totalSessions,
+    sessionScanFailures,
   };
 }
 
+function unknownWorkdirReason(): string {
+  return 'No local workdir mapping was found for this legacy session bucket; kimi.json may be missing, unreadable, or not list the workdir.';
+}
+
+function unreadableSessionReason(): string {
+  return 'Legacy session could not be inspected because context.jsonl is missing or unreadable.';
+}
+
+function isMissingError(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    (error as { readonly code?: unknown }).code === 'ENOENT'
+  );
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 async function listDirSafe(
   dir: string,
   filter: (name: string) => boolean,
diff --git a/packages/migration-legacy/src/index.ts b/packages/migration-legacy/src/index.ts
index 5130c2ee5..27b8a73e0 100644
--- a/packages/migration-legacy/src/index.ts
+++ b/packages/migration-legacy/src/index.ts
@@ -2,6 +2,10 @@
 
 export * from './types.js';
 export { detectMigration } from './detect.js';
+export {
+  shouldSuppressMigration,
+  type MigrationSuppressionInput,
+} from './marker.js';
 export { runMigration, type RunMigrationInput } from './run-migration.js';
 export {
   resolveMigrationScope,
diff --git a/packages/migration-legacy/src/marker.ts b/packages/migration-legacy/src/marker.ts
index 611bd305b..2116dce74 100644
--- a/packages/migration-legacy/src/marker.ts
+++ b/packages/migration-legacy/src/marker.ts
@@ -1,5 +1,7 @@
+import { existsSync, readFileSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
-import { migratedMarker } from './paths.js';
+import { resolve, win32 } from 'node:path';
+import { migratedMarker, skipMarker } from './paths.js';
 
 export interface MarkerRun {
   readonly startedAt: string;
@@ -14,9 +16,43 @@ export interface MarkerData {
   readonly last_migrated_at: string;
   readonly migrator_version: string;
   readonly target_path: string;
+  /** All target homes covered by this marker. Absent in legacy markers. */
+  readonly target_paths?: readonly string[];
   readonly runs: readonly MarkerRun[];
 }
 
+export interface MigrationSuppressionInput {
+  readonly sourceHome: string;
+  readonly targetHome: string;
+}
+
+/**
+ * Decide whether a migration prompt should be suppressed for one target home.
+ *
+ * A completed marker covers every target recorded in `target_paths`; the
+ * legacy `target_path` field remains authoritative when that list is absent.
+ * Unreadable markers are treated conservatively as completed so upgrading does
+ * not start prompting users who had already dismissed the migration.
+ */
+export function shouldSuppressMigration(input: MigrationSuppressionInput): boolean {
+  if (existsSync(skipMarker(input.targetHome))) return true;
+
+  const markerPath = migratedMarker(input.sourceHome);
+  if (!existsSync(markerPath)) return false;
+
+  try {
+    const parsed = JSON.parse(readFileSync(markerPath, 'utf-8')) as {
+      readonly target_path?: unknown;
+      readonly target_paths?: unknown;
+    };
+    const targetPaths = markerTargetPaths(parsed);
+    if (targetPaths.length === 0) return true;
+    return targetPaths.some((targetPath) => sameTargetPath(targetPath, input.targetHome));
+  } catch {
+    return true;
+  }
+}
+
 export async function readMarker(sourceHome: string): Promise<MarkerData | undefined> {
   try {
     const text = await readFile(migratedMarker(sourceHome), 'utf-8');
@@ -42,6 +78,7 @@ export async function writeMarker(
     last_migrated_at: run.completedAt,
     migrator_version: run.migratorVersion,
     target_path: run.targetPath,
+    target_paths: [run.targetPath],
     runs: [
       {
         startedAt: run.startedAt,
@@ -68,6 +105,7 @@ export async function appendMarkerRun(
     // updates the marker — otherwise `detectPendingMigration` keeps prompting
     // for the new target even though it was just migrated.
     target_path: run.targetPath,
+    target_paths: appendTargetPath(markerTargetPaths(existing), run.targetPath),
     runs: [
       ...existing.runs,
       {
@@ -80,3 +118,38 @@ export async function appendMarkerRun(
   };
   await writeFile(migratedMarker(sourceHome), JSON.stringify(updated, null, 2), 'utf-8');
 }
+
+function markerTargetPaths(marker: {
+  readonly target_path?: unknown;
+  readonly target_paths?: unknown;
+}): string[] {
+  const targetPaths = Array.isArray(marker.target_paths)
+    ? marker.target_paths.filter((targetPath): targetPath is string => typeof targetPath === 'string')
+    : [];
+  if (typeof marker.target_path === 'string') {
+    return appendTargetPath(targetPaths, marker.target_path);
+  }
+  return targetPaths;
+}
+
+function appendTargetPath(targetPaths: readonly string[], targetPath: string): string[] {
+  if (targetPaths.some((existing) => sameTargetPath(existing, targetPath))) {
+    return [...targetPaths];
+  }
+  return [...targetPaths, targetPath];
+}
+
+function sameTargetPath(left: string, right: string): boolean {
+  if (process.platform === 'win32') {
+    return win32.resolve(left).toLowerCase() === win32.resolve(right).toLowerCase();
+  }
+
+  const leftIsWindowsAbsolute = win32.isAbsolute(left);
+  const rightIsWindowsAbsolute = win32.isAbsolute(right);
+  if (leftIsWindowsAbsolute || rightIsWindowsAbsolute) {
+    if (!leftIsWindowsAbsolute || !rightIsWindowsAbsolute) return false;
+    return win32.resolve(left).toLowerCase() === win32.resolve(right).toLowerCase();
+  }
+
+  return resolve(left) === resolve(right);
+}
diff --git a/packages/migration-legacy/src/run-migration.ts b/packages/migration-legacy/src/run-migration.ts
index 11ee18928..870cbc250 100644
--- a/packages/migration-legacy/src/run-migration.ts
+++ b/packages/migration-legacy/src/run-migration.ts
@@ -121,31 +121,32 @@ export async function runMigration(input: RunMigrationInput): Promise<MigrationR
     sessions,
   };
 
-  // Marker persistence is best-effort: the data migration and the target
-  // report are already complete, so a marker write failure (e.g. a read-only
-  // legacy home) must not turn a finished migration into a reported failure.
-  // The only consequence is that detection re-prompts on a later launch.
-  try {
-    const existingMarker = await readMarker(input.source);
-    if (existingMarker === undefined) {
-      await writeMarker(input.source, {
-        startedAt,
-        completedAt,
-        migratorVersion: version,
-        summary: markerSummary,
-        targetPath: input.target,
-      });
-    } else {
-      await appendMarkerRun(input.source, {
-        startedAt,
-        completedAt,
-        migratorVersion: version,
-        summary: markerSummary,
-        targetPath: input.target,
-      });
+  // Do not suppress a later retry when session data could not be inspected or
+  // migrated. Successful marker persistence remains best-effort: the data and
+  // report are already complete, so a marker write failure must not reject.
+  if (sessions.sessionsFailed.length === 0) {
+    try {
+      const existingMarker = await readMarker(input.source);
+      if (existingMarker === undefined) {
+        await writeMarker(input.source, {
+          startedAt,
+          completedAt,
+          migratorVersion: version,
+          summary: markerSummary,
+          targetPath: input.target,
+        });
+      } else {
+        await appendMarkerRun(input.source, {
+          startedAt,
+          completedAt,
+          migratorVersion: version,
+          summary: markerSummary,
+          targetPath: input.target,
+        });
+      }
+    } catch {
+      // best-effort — see comment above
     }
-  } catch {
-    // best-effort — see comment above
   }
 
   return report;
diff --git a/packages/migration-legacy/src/sessions/index.ts b/packages/migration-legacy/src/sessions/index.ts
index 606739e85..93f24df49 100644
--- a/packages/migration-legacy/src/sessions/index.ts
+++ b/packages/migration-legacy/src/sessions/index.ts
@@ -52,14 +52,24 @@ export async function migrateSessionsStep(
   let bucketDirs: string[];
   try {
     bucketDirs = await readdir(sessionsDir);
-  } catch {
-    return emptySummary();
+  } catch (error) {
+    if (isMissingError(error)) return emptySummary();
+    return {
+      ...emptySummary(),
+      sessionsFailed: [
+        {
+          sourcePath: sessionsDir,
+          reason: `Legacy sessions directory could not be read: ${formatError(error)}`,
+        },
+      ],
+    };
   }
 
   const candidates: SessionCandidate[] = [];
 
   for (const bucketName of bucketDirs) {
     bucketsScanned++;
+    const bucketPath = join(sessionsDir, bucketName);
     const workdir = resolveBucket(bucketName, md5ToWorkdir);
     if (workdir.kind === 'nonlocal-kaos') {
       bucketsSkippedNonlocalKaos++;
@@ -67,14 +77,21 @@ export async function migrateSessionsStep(
     }
     if (workdir.kind === 'no-workdir-found') {
       bucketsSkippedNoWorkdirFound++;
+      sessionsFailed.push({
+        sourcePath: bucketPath,
+        reason: unknownWorkdirReason(),
+      });
       continue;
     }
     // workdir.kind === 'local'
-    const bucketPath = join(sessionsDir, bucketName);
     let sessionUuids: string[];
     try {
       sessionUuids = await readdir(bucketPath);
-    } catch {
+    } catch (error) {
+      sessionsFailed.push({
+        sourcePath: bucketPath,
+        reason: `Legacy session bucket could not be read: ${formatError(error)}`,
+      });
       continue;
     }
     for (const uuid of sessionUuids) {
@@ -89,7 +106,10 @@ export async function migrateSessionsStep(
         continue;
       }
       if (cls === 'malformed') {
-        sessionsSkippedMalformed++;
+        sessionsFailed.push({
+          sourcePath: sessionDir,
+          reason: unreadableSessionReason(),
+        });
         continue;
       }
       const wireMtime = await readWireMtime(sessionDir);
@@ -266,3 +286,24 @@ function emptySummary(): SessionsSummary {
     sessionsConflicts: [],
   };
 }
+
+function unknownWorkdirReason(): string {
+  return 'No local workdir mapping was found for this legacy session bucket; kimi.json may be missing, unreadable, or not list the workdir.';
+}
+
+function unreadableSessionReason(): string {
+  return 'Legacy session could not be inspected because context.jsonl is missing or unreadable.';
+}
+
+function isMissingError(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    (error as { readonly code?: unknown }).code === 'ENOENT'
+  );
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
diff --git a/packages/migration-legacy/src/sessions/migrate-one.ts b/packages/migration-legacy/src/sessions/migrate-one.ts
index 4ad6735c8..f5ab2c42b 100644
--- a/packages/migration-legacy/src/sessions/migrate-one.ts
+++ b/packages/migration-legacy/src/sessions/migrate-one.ts
@@ -13,6 +13,7 @@ import {
 } from './translator.js';
 import { writeMainAgentWire } from './wire-writer.js';
 import { writeSessionState } from './state-writer.js';
+import { extractToolCallDisplays } from './tool-call-display.js';
 
 export type MigrateOneResult =
   | { readonly outcome: 'migrated'; readonly targetDir: string }
@@ -59,10 +60,21 @@ export async function migrateOneSession(input: MigrateOneInput): Promise<Migrate
   let messages: NormalizedMessage[] = [];
   let lastUserPrompt = '';
   let contextLines: readonly string[] = [];
+  let oldWireText: string | undefined;
   try {
     const contextText = await readFile(join(input.sourceSessionDir, 'context.jsonl'), 'utf-8');
     contextLines = contextText.split(/\r?\n/);
-    messages = closeDanglingToolCalls(translateContextLines(contextLines));
+    try {
+      oldWireText = await readFile(join(input.sourceSessionDir, 'wire.jsonl'), 'utf-8');
+    } catch {
+      // A missing/corrupt wire must not prevent the model-facing context from
+      // migrating; it only means UI display enrichment is unavailable.
+    }
+    const toolCallDisplays =
+      oldWireText === undefined ? undefined : extractToolCallDisplays(oldWireText);
+    messages = closeDanglingToolCalls(
+      translateContextLines(contextLines, toolCallDisplays),
+    );
     lastUserPrompt = extractLastUserText(messages);
   } catch {
     return { outcome: 'failed', reason: 'cannot read context.jsonl' };
@@ -104,21 +116,23 @@ export async function migrateOneSession(input: MigrateOneInput): Promise<Migrate
   }
 
   let wireProtocolFromOld: string | null = null;
-  try {
-    const oldWire = await readFile(join(input.sourceSessionDir, 'wire.jsonl'), 'utf-8');
-    const firstLine = oldWire.split(/\r?\n/)[0];
-    if (firstLine !== undefined && firstLine.length > 0) {
-      const parsed: unknown = JSON.parse(firstLine);
-      if (
-        parsed !== null &&
-        typeof parsed === 'object' &&
-        typeof (parsed as { protocol_version?: unknown }).protocol_version === 'string'
-      ) {
-        wireProtocolFromOld = (parsed as { protocol_version: string }).protocol_version;
+  if (oldWireText !== undefined) {
+    try {
+      const firstLine = oldWireText.split(/\r?\n/)[0];
+      if (firstLine !== undefined && firstLine.length > 0) {
+        const parsed: unknown = JSON.parse(firstLine);
+        if (
+          parsed !== null &&
+          typeof parsed === 'object' &&
+          typeof (parsed as { protocol_version?: unknown }).protocol_version === 'string'
+        ) {
+          wireProtocolFromOld = (parsed as { protocol_version: string }).protocol_version;
+        }
       }
+    } catch {
+      // ignore a corrupt metadata line; display extraction already skips
+      // malformed records independently.
     }
-  } catch {
-    // ignore
   }
 
   try {
diff --git a/packages/migration-legacy/src/sessions/state-writer.ts b/packages/migration-legacy/src/sessions/state-writer.ts
index 12c849b9c..b7175b1b5 100644
--- a/packages/migration-legacy/src/sessions/state-writer.ts
+++ b/packages/migration-legacy/src/sessions/state-writer.ts
@@ -33,6 +33,10 @@ export async function writeSessionState(sessionDir: string, input: StateWriteInp
     title: finalTitle,
     isCustomTitle,
     lastPrompt: input.lastUserPrompt.slice(0, 200),
+    additionalDirs:
+      input.oldState.additional_dirs?.length === 0
+        ? undefined
+        : input.oldState.additional_dirs,
     agents: {
       main: {
         // kimi-core's `Session.resume()` treats `agents.main.homedir` as the
@@ -52,6 +56,13 @@ export async function writeSessionState(sessionDir: string, input: StateWriteInp
       kimi_cli_wire_protocol: input.wireProtocolFromOld,
       imported_at: new Date().toISOString(),
       archived: input.oldState.archived ?? false,
+      vscode_legacy_approval:
+        input.oldState.approval === undefined
+          ? undefined
+          : {
+              yolo: input.oldState.approval.yolo ?? false,
+              afk: input.oldState.approval.afk ?? false,
+            },
     },
   };
 
diff --git a/packages/migration-legacy/src/sessions/tool-call-display.ts b/packages/migration-legacy/src/sessions/tool-call-display.ts
new file mode 100644
index 000000000..f546fdd6c
--- /dev/null
+++ b/packages/migration-legacy/src/sessions/tool-call-display.ts
@@ -0,0 +1,105 @@
+import type { ToolInputDisplay } from '@moonshot-ai/agent-core';
+
+/**
+ * Recover the UI display attached to a legacy top-level ToolResult.
+ *
+ * Legacy context.jsonl carries the model-facing tool exchange, but the
+ * user-facing diff/todo/command display only exists in wire.jsonl. Both files
+ * use the same tool-call id, so the migrator can safely join an unambiguous
+ * single display block back onto the assistant message that owns the call.
+ * Nested SubagentEvent payloads are deliberately ignored here: their child
+ * transcript needs a separate agent migration, not a main-context join.
+ */
+export function extractToolCallDisplays(
+  wireText: string,
+): ReadonlyMap<string, ToolInputDisplay> {
+  const displays = new Map<string, ToolInputDisplay>();
+  const seenToolCallIds = new Set<string>();
+
+  for (const rawLine of wireText.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === '') continue;
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    const record = asRecord(parsed);
+    const message = asRecord(record?.['message']);
+    if (message?.['type'] !== 'ToolResult') continue;
+
+    const payload = asRecord(message['payload']);
+    const toolCallId = payload?.['tool_call_id'];
+    if (typeof toolCallId !== 'string' || toolCallId === '') continue;
+
+    // A duplicate result makes the id-to-display join ambiguous. Do not let a
+    // later line silently replace the display chosen from an earlier result.
+    if (seenToolCallIds.has(toolCallId)) {
+      displays.delete(toolCallId);
+      continue;
+    }
+    seenToolCallIds.add(toolCallId);
+
+    if (payload === undefined) continue;
+    const returnValue = asRecord(payload['return_value']);
+    const legacyDisplays = returnValue?.['display'];
+    if (!Array.isArray(legacyDisplays) || legacyDisplays.length !== 1) continue;
+
+    const display = translateDisplayBlock(legacyDisplays[0]);
+    if (display !== undefined) displays.set(toolCallId, display);
+  }
+
+  return displays;
+}
+
+function translateDisplayBlock(raw: unknown): ToolInputDisplay | undefined {
+  const block = asRecord(raw);
+  if (block === undefined) return undefined;
+
+  switch (block['type']) {
+    case 'diff': {
+      const path = block['path'];
+      const before = block['old_text'];
+      const after = block['new_text'];
+      if (typeof path !== 'string' || typeof before !== 'string' || typeof after !== 'string') {
+        return undefined;
+      }
+      return { kind: 'diff', path, before, after };
+    }
+    case 'todo': {
+      const items = block['items'];
+      if (!Array.isArray(items)) return undefined;
+      const normalizedItems: Array<{ title: string; status: string }> = [];
+      for (const rawItem of items) {
+        const item = asRecord(rawItem);
+        const title = item?.['title'];
+        const status = item?.['status'];
+        if (typeof title !== 'string' || typeof status !== 'string') return undefined;
+        normalizedItems.push({ title, status });
+      }
+      return { kind: 'todo_list', items: normalizedItems };
+    }
+    case 'shell': {
+      const command = block['command'];
+      const language = block['language'];
+      if (typeof command !== 'string' || language !== 'bash') return undefined;
+      return { kind: 'command', command, language: 'bash' };
+    }
+    case 'brief': {
+      const summary = block['text'];
+      if (typeof summary !== 'string') return undefined;
+      return { kind: 'generic', summary };
+    }
+    default:
+      return undefined;
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value !== null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
diff --git a/packages/migration-legacy/src/sessions/translator.ts b/packages/migration-legacy/src/sessions/translator.ts
index 499180b94..cf85b47ba 100644
--- a/packages/migration-legacy/src/sessions/translator.ts
+++ b/packages/migration-legacy/src/sessions/translator.ts
@@ -1,3 +1,5 @@
+import type { ToolInputDisplay } from '@moonshot-ai/agent-core';
+
 import { normalizeContentPart, type NormalizedContentPart } from './content-part.js';
 
 export interface NormalizedMessage {
@@ -9,6 +11,8 @@ export interface NormalizedMessage {
     readonly function: { readonly name: string; readonly arguments: string };
   }>;
   readonly toolCallId?: string;
+  /** UI-only display metadata recovered from legacy wire.jsonl. */
+  readonly toolCallDisplays?: Record<string, ToolInputDisplay>;
 }
 
 const DROPPED_ROLES = new Set(['_system_prompt', '_checkpoint', '_usage']);
@@ -66,7 +70,10 @@ export function containsUsableMessage(lines: readonly string[]): boolean {
   return analyzeContextContent(lines) === 'real';
 }
 
-export function translateContextLines(lines: readonly string[]): NormalizedMessage[] {
+export function translateContextLines(
+  lines: readonly string[],
+  displaysByToolCallId: ReadonlyMap<string, ToolInputDisplay> = new Map(),
+): NormalizedMessage[] {
   const out: NormalizedMessage[] = [];
   for (const rawLine of lines) {
     const line = rawLine.trim();
@@ -88,7 +95,7 @@ export function translateContextLines(lines: readonly string[]): NormalizedMessa
     if (role === 'user') {
       out.push(buildUser(obj));
     } else if (role === 'assistant') {
-      out.push(buildAssistant(obj));
+      out.push(buildAssistant(obj, displaysByToolCallId));
     } else if (role === 'tool') {
       out.push(buildTool(obj));
     }
@@ -122,14 +129,25 @@ function buildUser(obj: Record<string, unknown>): NormalizedMessage {
   };
 }
 
-function buildAssistant(obj: Record<string, unknown>): NormalizedMessage {
+function buildAssistant(
+  obj: Record<string, unknown>,
+  displaysByToolCallId: ReadonlyMap<string, ToolInputDisplay>,
+): NormalizedMessage {
   const toolCalls = Array.isArray(obj['tool_calls'])
     ? (obj['tool_calls'] as unknown[]).map(parseToolCall).filter(isNonNull)
     : [];
+  const toolCallDisplays = Object.fromEntries(
+    toolCalls.flatMap((call) => {
+      const display = displaysByToolCallId.get(call.id);
+      return display === undefined ? [] : [[call.id, display] as const];
+    }),
+  );
   return {
     role: 'assistant',
     content: normalizeContent(obj['content']),
     toolCalls,
+    toolCallDisplays:
+      Object.keys(toolCallDisplays).length === 0 ? undefined : toolCallDisplays,
   };
 }
 
diff --git a/packages/migration-legacy/src/types.ts b/packages/migration-legacy/src/types.ts
index 137d0b844..3a99109f1 100644
--- a/packages/migration-legacy/src/types.ts
+++ b/packages/migration-legacy/src/types.ts
@@ -12,6 +12,16 @@ export interface MigrationPlan {
   readonly detectedPlugins: readonly string[];
   readonly detectedMcpOauthServers: readonly string[];
   readonly totalSessions: number; // sum across workdirs (real, post-classify)
+  /**
+   * Session storage that detection could see but could not safely inspect.
+   * Optional for callers that persisted or constructed an older plan shape.
+   */
+  readonly sessionScanFailures?: readonly SessionMigrationFailure[];
+}
+
+export interface SessionMigrationFailure {
+  readonly sourcePath: string;
+  readonly reason: string;
 }
 
 /**
@@ -115,7 +125,7 @@ export interface SessionsSummary {
   readonly sessionsSkippedPlaceholder: number;
   readonly sessionsSkippedEmpty: number;
   readonly sessionsSkippedMalformed: number;
-  readonly sessionsFailed: ReadonlyArray<{ readonly sourcePath: string; readonly reason: string }>;
+  readonly sessionsFailed: readonly SessionMigrationFailure[];
   readonly sessionsConflicts: ReadonlyArray<{ readonly sourcePath: string; readonly targetPath: string }>;
 }
 
diff --git a/packages/migration-legacy/test/detect.test.ts b/packages/migration-legacy/test/detect.test.ts
index 9cdcf0e36..355be992c 100644
--- a/packages/migration-legacy/test/detect.test.ts
+++ b/packages/migration-legacy/test/detect.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it, beforeEach, afterEach } from 'vitest';
 import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { oldMd5BucketName } from '../src/sessions/workdir-bucket.js';
 import { detectMigration } from '../src/detect.js';
 
 let src: string;
@@ -39,4 +40,23 @@ describe('detectMigration', () => {
     expect(plan.detectedMcpOauthServers).toContain('server-1');
   });
 
+  it('reports an unknown workdir bucket when kimi.json cannot map it', async () => {
+    const bucket = join(src, 'sessions', oldMd5BucketName('/workspace/example'));
+    await mkdir(join(bucket, 'legacy-session'), { recursive: true });
+    await writeFile(
+      join(bucket, 'legacy-session', 'context.jsonl'),
+      '{"role":"user","content":"hello"}\n',
+    );
+
+    const plan = await detectMigration({ sourcePath: src });
+
+    expect(plan.totalSessions).toBe(0);
+    expect(plan.sessionScanFailures).toEqual([
+      {
+        sourcePath: bucket,
+        reason: expect.stringMatching(/workdir.*kimi\.json/i),
+      },
+    ]);
+  });
+
 });
diff --git a/packages/migration-legacy/test/integration.test.ts b/packages/migration-legacy/test/integration.test.ts
index 81e846519..e7d45dfcc 100644
--- a/packages/migration-legacy/test/integration.test.ts
+++ b/packages/migration-legacy/test/integration.test.ts
@@ -64,6 +64,27 @@ describe('runMigration (end-to-end on multi-workdir fixture)', () => {
     expect(report.summary.sessions.sessionsMigrated).toBeGreaterThan(0);
   });
 
+  it('does not write a completed marker when legacy session data remains unreadable', async () => {
+    const src = await mkdtemp(join(tmpdir(), 'failed-session-marker-src-'));
+    try {
+      const bucket = join(src, 'sessions', '11111111111111111111111111111111');
+      await mkdir(join(bucket, 'legacy-session'), { recursive: true });
+      const plan = await detectMigration({ sourcePath: src });
+
+      const report = await runMigration({
+        plan,
+        scope: { config: true, mcp: true, userHistory: true, skills: true, sessions: true },
+        source: src,
+        target: tgt,
+      });
+
+      expect(report.summary.sessions.sessionsFailed).toHaveLength(1);
+      await expect(readFile(join(src, '.migrated-to-kimi-code'), 'utf-8')).rejects.toThrow();
+    } finally {
+      await rm(src, { recursive: true, force: true });
+    }
+  });
+
   it('config-only scope writes config but skips sessions', async () => {
     // Materialize a config.toml in the fixture; afterEach cleans it up.
     await writeFile(FIXTURE_CONFIG, 'default_thinking = true\n');
diff --git a/packages/migration-legacy/test/marker.test.ts b/packages/migration-legacy/test/marker.test.ts
index bcacd9b1f..f3269f930 100644
--- a/packages/migration-legacy/test/marker.test.ts
+++ b/packages/migration-legacy/test/marker.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: legacy migration marker persistence and prompt suppression.
+ * Responsibilities: preserve run history and decide whether one target still needs migration.
+ * Wiring: real temporary filesystem; no stubbed collaborators.
+ * Run: pnpm --filter @moonshot-ai/migration-legacy test -- marker.test.ts
+ */
 import { describe, expect, it, beforeEach, afterEach } from 'vitest';
 import { mkdtemp, rm, readFile, writeFile, mkdir } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -8,6 +14,7 @@ import {
   appendMarkerRun,
   type MarkerData,
 } from '../src/marker.js';
+import { runMigration, shouldSuppressMigration } from '../src/index.js';
 
 let dir: string;
 beforeEach(async () => {
@@ -34,6 +41,7 @@ describe('marker', () => {
     const data = await readMarker(dir);
     expect(data?.first_migrated_at).toBe('2026-05-16T10:00:00Z');
     expect(data?.last_migrated_at).toBe('2026-05-16T10:00:42Z');
+    expect(data?.target_paths).toEqual(['/foo']);
     expect(data?.runs).toHaveLength(1);
   });
 
@@ -61,6 +69,52 @@ describe('marker', () => {
     expect(data?.target_path).toBe('/bar');
   });
 
+  it('suppresses migration for both targets when appending a run to a legacy marker', async () => {
+    const firstTarget = join(dir, 'first-target');
+    const secondTarget = join(dir, 'second-target');
+    await writeFile(
+      join(dir, '.migrated-to-kimi-code'),
+      JSON.stringify({
+        version: 1,
+        first_migrated_at: '2026-05-16T10:00:00Z',
+        last_migrated_at: '2026-05-16T10:00:42Z',
+        migrator_version: '0.1.1',
+        target_path: firstTarget,
+        runs: [
+          {
+            startedAt: '2026-05-16T10:00:00Z',
+            completedAt: '2026-05-16T10:00:42Z',
+            migratorVersion: '0.1.1',
+            summary: {},
+          },
+        ],
+      }),
+      'utf-8',
+    );
+    const plan = {
+      sourceHome: dir,
+      hasConfig: false,
+      hasMcp: false,
+      hasUserHistory: false,
+      oauthCredentials: [],
+      workdirs: [],
+      detectedPlugins: [],
+      detectedMcpOauthServers: [],
+      totalSessions: 0,
+    };
+    const scope = {
+      config: false,
+      mcp: false,
+      userHistory: false,
+      skills: false,
+      sessions: false,
+    };
+    await runMigration({ plan, scope, source: dir, target: secondTarget });
+
+    expect(shouldSuppressMigration({ sourceHome: dir, targetHome: firstTarget })).toBe(true);
+    expect(shouldSuppressMigration({ sourceHome: dir, targetHome: secondTarget })).toBe(true);
+  });
+
   it('readMarker returns undefined when file is corrupt', async () => {
     await writeFile(join(dir, '.migrated-to-kimi-code'), 'not-json', 'utf-8');
     expect(await readMarker(dir)).toBeUndefined();
@@ -76,4 +130,72 @@ describe('marker', () => {
     );
     expect(await readMarker(dir)).toBeUndefined();
   });
+
+  it('does not suppress migration when no marker exists for the target', () => {
+    expect(
+      shouldSuppressMigration({ sourceHome: dir, targetHome: join(dir, 'target') }),
+    ).toBe(false);
+  });
+
+  it('suppresses migration when the completed marker names the same target', async () => {
+    const targetHome = join(dir, 'target');
+    await writeFile(
+      join(dir, '.migrated-to-kimi-code'),
+      JSON.stringify({ target_path: targetHome }),
+      'utf-8',
+    );
+
+    expect(shouldSuppressMigration({ sourceHome: dir, targetHome })).toBe(true);
+  });
+
+  it('does not suppress migration when the completed marker names another target', async () => {
+    await writeFile(
+      join(dir, '.migrated-to-kimi-code'),
+      JSON.stringify({ target_path: join(dir, 'first-target') }),
+      'utf-8',
+    );
+
+    expect(
+      shouldSuppressMigration({ sourceHome: dir, targetHome: join(dir, 'second-target') }),
+    ).toBe(false);
+  });
+
+  it('suppresses migration when an old marker has no target path', async () => {
+    await writeFile(join(dir, '.migrated-to-kimi-code'), '{}', 'utf-8');
+
+    expect(
+      shouldSuppressMigration({ sourceHome: dir, targetHome: join(dir, 'target') }),
+    ).toBe(true);
+  });
+
+  it('suppresses migration when the completed marker is corrupt', async () => {
+    await writeFile(join(dir, '.migrated-to-kimi-code'), 'not-json', 'utf-8');
+
+    expect(
+      shouldSuppressMigration({ sourceHome: dir, targetHome: join(dir, 'target') }),
+    ).toBe(true);
+  });
+
+  it('suppresses migration when the target contains the skip marker', async () => {
+    const targetHome = join(dir, 'target');
+    await mkdir(targetHome, { recursive: true });
+    await writeFile(join(targetHome, '.skip-migration-from-kimi-cli'), '', 'utf-8');
+
+    expect(shouldSuppressMigration({ sourceHome: dir, targetHome })).toBe(true);
+  });
+
+  it('suppresses migration when Windows drive letters differ only by case', async () => {
+    await writeFile(
+      join(dir, '.migrated-to-kimi-code'),
+      JSON.stringify({ target_path: 'C:\\Users\\Example\\.kimi-code' }),
+      'utf-8',
+    );
+
+    expect(
+      shouldSuppressMigration({
+        sourceHome: dir,
+        targetHome: 'c:\\Users\\Example\\.kimi-code',
+      }),
+    ).toBe(true);
+  });
 });
diff --git a/packages/migration-legacy/test/resume.integration.test.ts b/packages/migration-legacy/test/resume.integration.test.ts
index 74d2e6455..06b00c6d1 100644
--- a/packages/migration-legacy/test/resume.integration.test.ts
+++ b/packages/migration-legacy/test/resume.integration.test.ts
@@ -156,4 +156,46 @@ describe('migrated session loads in real kimi-core', () => {
       await session.close();
     }
   });
+
+  it('real Session.resume() preserves a legacy todo display', async () => {
+    const result = await migrateOneSession({
+      sourceSessionDir: join(FIXTURES, 'large-100msgs'),
+      oldSessionUuid: 'todo-display',
+      workdirPath: WORK_DIR,
+      targetHome,
+    });
+    expect(result.outcome).toBe('migrated');
+    const targetDir = (result as Extract<MigrateOneResult, { outcome: 'migrated' }>)
+      .targetDir;
+
+    const session = new Session({
+      kaos: (await LocalKaos.create()).withCwd(WORK_DIR),
+      id: 'ses_todo-display',
+      homedir: targetDir,
+      rpc: createSessionRpc(),
+      initializeMainAgent: false,
+    });
+    try {
+      await session.resume();
+      const assistant = session
+        .getReadyAgent('main')
+        ?.context.history.find((message) =>
+          message.toolCalls.some(
+            (call) => call.id === 'tool_y3SXWWQIUysddnYoklaWhUeE',
+          ),
+        );
+
+      expect(
+        assistant?.toolCallDisplays?.['tool_y3SXWWQIUysddnYoklaWhUeE'],
+      ).toEqual({
+        kind: 'todo_list',
+        items: expect.arrayContaining([
+          { title: '准备测试环境（创建隔离 work-dir）', status: 'in_progress' },
+          { title: '汇报结论', status: 'pending' },
+        ]),
+      });
+    } finally {
+      await session.close();
+    }
+  });
 });
diff --git a/packages/migration-legacy/test/sessions/__snapshots__/fixtures.snapshot.test.ts.snap b/packages/migration-legacy/test/sessions/__snapshots__/fixtures.snapshot.test.ts.snap
index e037c8abc..537493c71 100644
--- a/packages/migration-legacy/test/sessions/__snapshots__/fixtures.snapshot.test.ts.snap
+++ b/packages/migration-legacy/test/sessions/__snapshots__/fixtures.snapshot.test.ts.snap
@@ -21,7 +21,11 @@ exports[`migration snapshot: archived > migration succeeds and matches snapshot
     "kimi_cli_session_id": "archived",
     "kimi_cli_wire_protocol": "1.8",
     "imported_at": "<REDACTED>",
-    "archived": true
+    "archived": true,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
@@ -54,7 +58,11 @@ exports[`migration snapshot: large-100msgs > migration succeeds and matches snap
     "kimi_cli_session_id": "large-100msgs",
     "kimi_cli_wire_protocol": "1.4",
     "imported_at": "<REDACTED>",
-    "archived": false
+    "archived": false,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
@@ -81,22 +89,22 @@ exports[`migration snapshot: large-100msgs > migration succeeds and matches snap
 {"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"我已经获取了足够的背景信息。让我继续读取 KimiSoul 中 notification 相关的代码，以及相关的测试来理解完整的功能边界。"}],"toolCalls":[{"type":"function","id":"tool_okFY9oLifSxqJb8egNPac0MS","function":{"name":"ReadFile","arguments":"{\\"path\\": \\"src/example_pkg/soul/kimisoul.py\\", \\"line_offset\\": 200, \\"n_lines\\": 200}"}},{"type":"function","id":"tool_CcxVl6nzWr4TfMaivaLiZxsz","function":{"name":"Grep","arguments":"{\\"pattern\\": \\"def _step|notification|claim|publish\\", \\"path\\": \\"src/example_pkg/soul/kimisoul.py\\", \\"output_mode\\": \\"content\\", \\"-n\\": true}"}}]}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>200 lines read from file starting from line 200.</system>"},{"type":"text","text":"   200\\t\\n   201\\t        def path_getter() -> Path | None:\\n   202\\t            return self.get_plan_file_path()\\n   203\\t\\n   204\\t        # WriteFile gets both checker and path_getter (for plan file auto-approve)\\n   205\\t        from example_pkg.tools.file.write import WriteFile\\n   206\\t\\n   207\\t        write_tool = self._agent.toolset.find(\\"WriteFile\\")\\n   208\\t        if isinstance(write_tool, WriteFile):\\n   209\\t            write_tool.bind_plan_mode(checker, path_getter)\\n   210\\t\\n   211\\t        # ExitPlanMod... [truncated]"}],"toolCalls":[],"toolCallId":"tool_okFY9oLifSxqJb8egNPac0MS"}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"26:from example_pkg.notifications import build_notification_message, extract_notification_ids\\n147:            self._runtime.notifications.ack_ids(\\"llm\\", extract_notification_ids(context.history))\\n626:    async def _step(self) -> StepOutcome | None:\\n634:            notifications = self._runtime.notifications.claim_for_sink(\\"llm\\", limit=4)\\n635:            if notifications:\\n637:                    build_notification_message(view, self._runtime) for view in notifications\\n640:                self._runti... [truncated]"}],"toolCalls":[],"toolCallId":"tool_CcxVl6nzWr4TfMaivaLiZxsz"}}
-{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"现在我对功能有了完整的理解。让我总结一下测试范围：\\n\\n**功能边界：**\\n1. **后台任务系统** - 创建、监控、停止、输出获取\\n2. **通知系统** - 发布、消费、去重、确认\\n3. **集成点** - Shell 后台模式、TaskList/TaskOutput/TaskStop 工具、Wire 通知事件、LLM 通知消息\\n\\n**用户可感知的行为变化：**\\n1. Shell 工具新增 \`run_in_background\` 和 \`description\` 参数\\n2. 新增 TaskList/TaskOutput/TaskStop 工具\\n3. 后台任务完成后自动发送通知到 LLM context 和 Wire\\n4. 通知通过独立的 \`<notification>\` 消息进入 context\\n5. Wire 协议新增 \`Notification\` 事件类型\\n\\n**测试计划：**\\n1. **正常路径** - 启动后台任务，等待完成，验证通知\\n2. **边界条件** - 超时处理、重复停止、无效 task_id\\n3. **中断/清理** - 主动停止任务、任务丢失恢复\\n\\n让我开始制定... [truncated]"},{"type":"text","text":"现在我对功能有了完整理解。让我制定测试计划：\\n\\n## 功能边界总结\\n\\n**主要变更：**\\n1. **后台任务系统** (\`background/\`) - 全新模块，支持后台 bash 任务\\n2. **通知系统** (\`notifications/\`) - 独立基建，支持多 sink (llm/wire/shell)\\n3. **新工具** - \`TaskList\` / \`TaskOutput\` / \`TaskStop\`\\n4. **Shell 工具更新** - 新增 \`run_in_background\` + \`description\` 参数\\n5. **Wire 协议** - 新增 \`Notification\` 事件类型\\n6. **KimiSoul 集成** - 自动 claim/ack notification，compaction 后恢复活跃任务快照\\n\\n**测试范围：**\\n- 后台任务生命周期（创建→运行→完成→通知）\\n- 任务控制工具（List/Output/Stop）\\n- 通知系统（去重、claim/ack、多 sink）\\n- 集成点（Shell 后台模式、Wire 事件、LLM ... [truncated]"}],"toolCalls":[{"type":"function","id":"tool_y3SXWWQIUysddnYoklaWhUeE","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_BH2zd6kVzHhV4pIjKLSmrUeB","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"$(mktemp -d /tmp/kimi-smoke-XXXXXX)\\\\\\"\\\\necho \\\\\\"SMOKE_DIR=$SMOKE_DIR\\\\\\"\\\\n# 验证 CLI 可运行\\\\nuv run python -m example_pkg.cli --help 2>&1 | head -20\\"}"}}]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"现在我对功能有了完整的理解。让我总结一下测试范围：\\n\\n**功能边界：**\\n1. **后台任务系统** - 创建、监控、停止、输出获取\\n2. **通知系统** - 发布、消费、去重、确认\\n3. **集成点** - Shell 后台模式、TaskList/TaskOutput/TaskStop 工具、Wire 通知事件、LLM 通知消息\\n\\n**用户可感知的行为变化：**\\n1. Shell 工具新增 \`run_in_background\` 和 \`description\` 参数\\n2. 新增 TaskList/TaskOutput/TaskStop 工具\\n3. 后台任务完成后自动发送通知到 LLM context 和 Wire\\n4. 通知通过独立的 \`<notification>\` 消息进入 context\\n5. Wire 协议新增 \`Notification\` 事件类型\\n\\n**测试计划：**\\n1. **正常路径** - 启动后台任务，等待完成，验证通知\\n2. **边界条件** - 超时处理、重复停止、无效 task_id\\n3. **中断/清理** - 主动停止任务、任务丢失恢复\\n\\n让我开始制定... [truncated]"},{"type":"text","text":"现在我对功能有了完整理解。让我制定测试计划：\\n\\n## 功能边界总结\\n\\n**主要变更：**\\n1. **后台任务系统** (\`background/\`) - 全新模块，支持后台 bash 任务\\n2. **通知系统** (\`notifications/\`) - 独立基建，支持多 sink (llm/wire/shell)\\n3. **新工具** - \`TaskList\` / \`TaskOutput\` / \`TaskStop\`\\n4. **Shell 工具更新** - 新增 \`run_in_background\` + \`description\` 参数\\n5. **Wire 协议** - 新增 \`Notification\` 事件类型\\n6. **KimiSoul 集成** - 自动 claim/ack notification，compaction 后恢复活跃任务快照\\n\\n**测试范围：**\\n- 后台任务生命周期（创建→运行→完成→通知）\\n- 任务控制工具（List/Output/Stop）\\n- 通知系统（去重、claim/ack、多 sink）\\n- 集成点（Shell 后台模式、Wire 事件、LLM ... [truncated]"}],"toolCalls":[{"type":"function","id":"tool_y3SXWWQIUysddnYoklaWhUeE","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_BH2zd6kVzHhV4pIjKLSmrUeB","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"$(mktemp -d /tmp/kimi-smoke-XXXXXX)\\\\\\"\\\\necho \\\\\\"SMOKE_DIR=$SMOKE_DIR\\\\\\"\\\\n# 验证 CLI 可运行\\\\nuv run python -m example_pkg.cli --help 2>&1 | head -20\\"}"}}],"toolCallDisplays":{"tool_y3SXWWQIUysddnYoklaWhUeE":{"kind":"todo_list","items":[{"title":"准备测试环境（创建隔离 work-dir）","status":"in_progress"},{"title":"探索轮：验证工具可用性和接口","status":"pending"},{"title":"执行轮1：正常路径 - 后台任务生命周期","status":"pending"},{"title":"执行轮2：边界条件 - 超时和停止","status":"pending"},{"title":"执行轮3：中断场景 - TaskStop 和恢复","status":"pending"},{"title":"观察轮：检查 session 产物","status":"pending"},{"title":"汇报结论","status":"pending"}]}}}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Todo list updated</system>"}],"toolCalls":[],"toolCallId":"tool_y3SXWWQIUysddnYoklaWhUeE"}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Command executed successfully.</system>"},{"type":"text","text":"SMOKE_DIR=/tmp/kimi-smoke-a2i1xj\\n                                                                                \\n Usage: python -m example_pkg.cli [OPTIONS] COMMAND [ARGS]...                      \\n                                                                                \\n The Starting Point for Next-Gen Agents                                                     \\n                                                                                \\n╭─ Options ───────────────────────────────────────────────────... [truncated]"}],"toolCalls":[],"toolCallId":"tool_BH2zd6kVzHhV4pIjKLSmrUeB"}}
-{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"环境准备好了，现在让我开始第一轮探索测试，验证工具可用性。"}],"toolCalls":[{"type":"function","id":"tool_mj72EeaBIxBi3NOVwE3tjxBc","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_ocohNUErNzzNQnYsibl670ms","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 探索轮：验证后台任务相关工具是否可用\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请列出你当前所有可用的工具，特别关注：\\\\n1. 是否有 TaskList、TaskOutput、TaskStop 这三个工具？\\\\n2. Shell 工具是否支持 run_in_background 参数？\\\\n3. 简单描述这些工具的功能。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&1\\\\necho \\\\\\"exit_code=$?\\\\\\"\\", \\"timeout\\": 120}"}}]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"环境准备好了，现在让我开始第一轮探索测试，验证工具可用性。"}],"toolCalls":[{"type":"function","id":"tool_mj72EeaBIxBi3NOVwE3tjxBc","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_ocohNUErNzzNQnYsibl670ms","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 探索轮：验证后台任务相关工具是否可用\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请列出你当前所有可用的工具，特别关注：\\\\n1. 是否有 TaskList、TaskOutput、TaskStop 这三个工具？\\\\n2. Shell 工具是否支持 run_in_background 参数？\\\\n3. 简单描述这些工具的功能。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&1\\\\necho \\\\\\"exit_code=$?\\\\\\"\\", \\"timeout\\": 120}"}}],"toolCallDisplays":{"tool_mj72EeaBIxBi3NOVwE3tjxBc":{"kind":"todo_list","items":[{"title":"准备测试环境（创建隔离 work-dir）","status":"done"},{"title":"探索轮：验证工具可用性和接口","status":"in_progress"},{"title":"执行轮1：正常路径 - 后台任务生命周期","status":"pending"},{"title":"执行轮2：边界条件 - 超时和停止","status":"pending"},{"title":"执行轮3：中断场景 - TaskStop 和恢复","status":"pending"},{"title":"观察轮：检查 session 产物","status":"pending"},{"title":"汇报结论","status":"pending"}]}}}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Todo list updated</system>"}],"toolCalls":[],"toolCallId":"tool_mj72EeaBIxBi3NOVwE3tjxBc"}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Command executed successfully.</system>"},{"type":"text","text":"请列出你当前所有可用的工具，特别关注：\\n1. 是否有 TaskList、TaskOutput、TaskStop 这三个工具？\\n2. Shell 工具是否支持 run_in_background 参数？\\n3. 简单描述这些工具的功能。\\nTurnBegin(\\n    user_input='请列出你当前所有可用的工具，特别关注：\\\\n1. 是否有 \\nTaskList、TaskOutput、TaskStop 这三个工具？\\\\n2. Shell 工具是否支持 \\nrun_in_background 参数？\\\\n3. 简单描述这些工具的功能。'\\n)\\nStepBegin(n=1)\\nThinkPart(\\n    type='think',\\n    think='用户询问我当前可用的工具列表，特别关注三个问题：\\\\n1. 是否有 \\nTaskList、TaskOutput、TaskStop 这三个工具？\\\\n2. Shell 工具是否支持 \\nrun_in_background 参数？\\\\n3. \\n简单描述这些工具的功能。\\\\n\\\\n我需要查看我的工具列表。从 system \\n提示中，我可以看到我有以下工具：\\\\n- Tas... [truncated]"}],"toolCalls":[],"toolCallId":"tool_ocohNUErNzzNQnYsibl670ms"}}
-{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"探索轮成功，工具都已正确加载。现在进入执行轮1：测试正常路径 - 启动后台任务，等待完成，验证通知。"},{"type":"text","text":"探索轮成功！工具都已正确加载。现在执行第一轮测试："}],"toolCalls":[{"type":"function","id":"tool_bpOwCgVz6wYah52SnaJB39ZW","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_HejoTo6Izmlets9y9hN9u1pZ","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 执行轮1：正常路径 - 启动一个短生命周期的后台任务，验证生命周期完整\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请执行以下测试：\\\\n\\\\n1. 使用 Shell 工具启动一个后台任务：\\\\n   - 命令: echo 'hello from background' && sleep 2 && echo 'task done'\\\\n   - run_in_background: true\\\\n   - description: '测试后台任务生命周期'\\\\n   - timeout: 30\\\\n\\\\n2. 记录返回的 task_id\\\\n\\\\n3. 使用 TaskList 查看当前活跃任务\\\\n\\\\n4. 使用 TaskOutput 获取任务输出（block=true, timeout=10）\\\\n\\\\n请报告：task_id、任务状态、输出内容。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&... [truncated]"}}]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"探索轮成功，工具都已正确加载。现在进入执行轮1：测试正常路径 - 启动后台任务，等待完成，验证通知。"},{"type":"text","text":"探索轮成功！工具都已正确加载。现在执行第一轮测试："}],"toolCalls":[{"type":"function","id":"tool_bpOwCgVz6wYah52SnaJB39ZW","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_HejoTo6Izmlets9y9hN9u1pZ","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 执行轮1：正常路径 - 启动一个短生命周期的后台任务，验证生命周期完整\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请执行以下测试：\\\\n\\\\n1. 使用 Shell 工具启动一个后台任务：\\\\n   - 命令: echo 'hello from background' && sleep 2 && echo 'task done'\\\\n   - run_in_background: true\\\\n   - description: '测试后台任务生命周期'\\\\n   - timeout: 30\\\\n\\\\n2. 记录返回的 task_id\\\\n\\\\n3. 使用 TaskList 查看当前活跃任务\\\\n\\\\n4. 使用 TaskOutput 获取任务输出（block=true, timeout=10）\\\\n\\\\n请报告：task_id、任务状态、输出内容。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&... [truncated]"}}],"toolCallDisplays":{"tool_bpOwCgVz6wYah52SnaJB39ZW":{"kind":"todo_list","items":[{"title":"准备测试环境（创建隔离 work-dir）","status":"done"},{"title":"探索轮：验证工具可用性和接口","status":"done"},{"title":"执行轮1：正常路径 - 后台任务生命周期","status":"in_progress"},{"title":"执行轮2：边界条件 - 超时和停止","status":"pending"},{"title":"执行轮3：中断场景 - TaskStop 和恢复","status":"pending"},{"title":"观察轮：检查 session 产物","status":"pending"},{"title":"汇报结论","status":"pending"}]}}}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Todo list updated</system>"}],"toolCalls":[],"toolCallId":"tool_bpOwCgVz6wYah52SnaJB39ZW"}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Command executed successfully.</system>"},{"type":"text","text":"请执行以下测试：\\n\\n1. 使用 Shell 工具启动一个后台任务：\\n   - 命令: echo 'hello from background' && sleep 2 && echo 'task done'\\n   - run_in_background: true\\n   - description: '测试后台任务生命周期'\\n   - timeout: 30\\n\\n2. 记录返回的 task_id\\n\\n3. 使用 TaskList 查看当前活跃任务\\n\\n4. 使用 TaskOutput 获取任务输出（block=true, timeout=10）\\n\\n请报告：task_id、任务状态、输出内容。\\nTurnBegin(\\n    user_input=\\"请执行以下测试：\\\\n\\\\n1. 使用 Shell 工具启动一个后台任务：\\\\n   - \\n命令: echo 'hello from background' && sleep 2 && echo 'task done'\\\\n   - \\nrun_in_background: true\\\\n   - description: '测试后台任务生命周期'\\\\n   - t... [truncated]"}],"toolCalls":[],"toolCallId":"tool_HejoTo6Izmlets9y9hN9u1pZ"}}
-{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"第一轮测试成功！关键验证点：\\n1. ✅ Shell 后台任务启动成功，返回 task_id\\n2. ✅ TaskList 正确工作\\n3. ✅ TaskOutput 正确工作，block=true 等待完成\\n4. ✅ Notification 事件正确发送（Wire 中可见 Notification 事件）\\n\\n现在进行第二轮：边界条件 - 测试超时和停止功能。"},{"type":"text","text":"第一轮成功！所有核心功能正常工作。现在测试边界条件："}],"toolCalls":[{"type":"function","id":"tool_3tueNNJt54oG2X47QK4PLnTj","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_NT90qPui3vOOBqIjmTgvYe9Q","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 执行轮2：边界条件 - 超时处理和停止\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请执行以下边界条件测试：\\\\n\\\\n1. 启动一个长时间运行的后台任务（会被停止）：\\\\n   - 命令: for i in 1 2 3 4 5; do echo \\\\\\\\\\\\\\"line \\\\\\\\$i\\\\\\\\\\\\\\"; sleep 5; done\\\\n   - run_in_background: true\\\\n   - description: '测试停止功能'\\\\n   - timeout: 60\\\\n\\\\n2. 使用 TaskList 确认任务在运行中\\\\n\\\\n3. 等待 3 秒后，使用 TaskStop 停止该任务\\\\n\\\\n4. 使用 TaskOutput 获取任务最终状态和输出\\\\n\\\\n请报告：task_id、停止前后的状态、输出内容、是否有正确通知。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&1\\\\necho \\\\\\"... [truncated]"}}]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"第一轮测试成功！关键验证点：\\n1. ✅ Shell 后台任务启动成功，返回 task_id\\n2. ✅ TaskList 正确工作\\n3. ✅ TaskOutput 正确工作，block=true 等待完成\\n4. ✅ Notification 事件正确发送（Wire 中可见 Notification 事件）\\n\\n现在进行第二轮：边界条件 - 测试超时和停止功能。"},{"type":"text","text":"第一轮成功！所有核心功能正常工作。现在测试边界条件："}],"toolCalls":[{"type":"function","id":"tool_3tueNNJt54oG2X47QK4PLnTj","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"执行轮3：中断场景 - TaskStop 和恢复\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_NT90qPui3vOOBqIjmTgvYe9Q","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 执行轮2：边界条件 - 超时处理和停止\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请执行以下边界条件测试：\\\\n\\\\n1. 启动一个长时间运行的后台任务（会被停止）：\\\\n   - 命令: for i in 1 2 3 4 5; do echo \\\\\\\\\\\\\\"line \\\\\\\\$i\\\\\\\\\\\\\\"; sleep 5; done\\\\n   - run_in_background: true\\\\n   - description: '测试停止功能'\\\\n   - timeout: 60\\\\n\\\\n2. 使用 TaskList 确认任务在运行中\\\\n\\\\n3. 等待 3 秒后，使用 TaskStop 停止该任务\\\\n\\\\n4. 使用 TaskOutput 获取任务最终状态和输出\\\\n\\\\n请报告：task_id、停止前后的状态、输出内容、是否有正确通知。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&1\\\\necho \\\\\\"... [truncated]"}}],"toolCallDisplays":{"tool_3tueNNJt54oG2X47QK4PLnTj":{"kind":"todo_list","items":[{"title":"准备测试环境（创建隔离 work-dir）","status":"done"},{"title":"探索轮：验证工具可用性和接口","status":"done"},{"title":"执行轮1：正常路径 - 后台任务生命周期","status":"done"},{"title":"执行轮2：边界条件 - 超时和停止","status":"in_progress"},{"title":"执行轮3：中断场景 - TaskStop 和恢复","status":"pending"},{"title":"观察轮：检查 session 产物","status":"pending"},{"title":"汇报结论","status":"pending"}]}}}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Todo list updated</system>"}],"toolCalls":[],"toolCallId":"tool_3tueNNJt54oG2X47QK4PLnTj"}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Command executed successfully.</system>"},{"type":"text","text":"请执行以下边界条件测试：\\n\\n1. 启动一个长时间运行的后台任务（会被停止）：\\n   - 命令: for i in 1 2 3 4 5; do echo \\"line $i\\"; sleep 5; done\\n   - run_in_background: true\\n   - description: '测试停止功能'\\n   - timeout: 60\\n\\n2. 使用 TaskList 确认任务在运行中\\n\\n3. 等待 3 秒后，使用 TaskStop 停止该任务\\n\\n4. 使用 TaskOutput 获取任务最终状态和输出\\n\\n请报告：task_id、停止前后的状态、输出内容、是否有正确通知。\\nTurnBegin(\\n    user_input='请执行以下边界条件测试：\\\\n\\\\n1. \\n启动一个长时间运行的后台任务（会被停止）：\\\\n   - 命令: for i in 1 2 3 4 5; do \\necho \\"line $i\\"; sleep 5; done\\\\n   - run_in_background: true\\\\n   - description: \\n\\\\'测试停止功能\\\\'\\\\n   - timeou... [truncated]"}],"toolCalls":[],"toolCallId":"tool_NT90qPui3vOOBqIjmTgvYe9Q"}}
-{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"第二轮也成功！测试了停止功能，验证了：\\n1. ✅ TaskStop 成功停止任务\\n2. ✅ 通知正确发送 (task.killed)\\n3. ✅ exit_code 正确 (-15 = SIGTERM)\\n4. ✅ 输出正确捕获\\n\\n现在进行第三轮测试：测试超时处理。"},{"type":"text","text":"第二轮成功！停止功能完全正常。现在测试超时场景："}],"toolCalls":[{"type":"function","id":"tool_TS5JUSZELJoTVcos6rp90ZUT","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮3：超时场景测试\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_J3cQ5m3qyTep0zNLWhZR3OGg","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 执行轮3：测试超时处理\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请测试后台任务超时功能：\\\\n\\\\n1. 启动一个会超时的后台任务：\\\\n   - 命令: sleep 300\\\\n   - run_in_background: true\\\\n   - description: '测试超时处理'\\\\n   - timeout: 3  （设置为3秒，确保会超时）\\\\n\\\\n2. 使用 TaskOutput 阻塞等待任务结束（block=true, timeout=15）\\\\n\\\\n3. 检查任务最终状态是否为 timeout\\\\n\\\\n请报告：task_id、最终状态、exit_code、是否有 timeout 通知。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&1\\\\necho \\\\\\"exit_code=$?\\\\\\"\\", \\"timeout\\": 180}"}}]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"第二轮也成功！测试了停止功能，验证了：\\n1. ✅ TaskStop 成功停止任务\\n2. ✅ 通知正确发送 (task.killed)\\n3. ✅ exit_code 正确 (-15 = SIGTERM)\\n4. ✅ 输出正确捕获\\n\\n现在进行第三轮测试：测试超时处理。"},{"type":"text","text":"第二轮成功！停止功能完全正常。现在测试超时场景："}],"toolCalls":[{"type":"function","id":"tool_TS5JUSZELJoTVcos6rp90ZUT","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮3：超时场景测试\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"pending\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_J3cQ5m3qyTep0zNLWhZR3OGg","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 执行轮3：测试超时处理\\\\nuv run python -m example_pkg.cli \\\\\\\\\\\\n  --print \\\\\\\\\\\\n  --prompt \\\\\\"请测试后台任务超时功能：\\\\n\\\\n1. 启动一个会超时的后台任务：\\\\n   - 命令: sleep 300\\\\n   - run_in_background: true\\\\n   - description: '测试超时处理'\\\\n   - timeout: 3  （设置为3秒，确保会超时）\\\\n\\\\n2. 使用 TaskOutput 阻塞等待任务结束（block=true, timeout=15）\\\\n\\\\n3. 检查任务最终状态是否为 timeout\\\\n\\\\n请报告：task_id、最终状态、exit_code、是否有 timeout 通知。\\\\\\" \\\\\\\\\\\\n  --work-dir \\\\\\"$SMOKE_DIR\\\\\\" 2>&1\\\\necho \\\\\\"exit_code=$?\\\\\\"\\", \\"timeout\\": 180}"}}],"toolCallDisplays":{"tool_TS5JUSZELJoTVcos6rp90ZUT":{"kind":"todo_list","items":[{"title":"准备测试环境（创建隔离 work-dir）","status":"done"},{"title":"探索轮：验证工具可用性和接口","status":"done"},{"title":"执行轮1：正常路径 - 后台任务生命周期","status":"done"},{"title":"执行轮2：边界条件 - 超时和停止","status":"done"},{"title":"执行轮3：超时场景测试","status":"in_progress"},{"title":"观察轮：检查 session 产物","status":"pending"},{"title":"汇报结论","status":"pending"}]}}}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Todo list updated</system>"}],"toolCalls":[],"toolCallId":"tool_TS5JUSZELJoTVcos6rp90ZUT"}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Command executed successfully.</system>"},{"type":"text","text":"请测试后台任务超时功能：\\n\\n1. 启动一个会超时的后台任务：\\n   - 命令: sleep 300\\n   - run_in_background: true\\n   - description: '测试超时处理'\\n   - timeout: 3  （设置为3秒，确保会超时）\\n\\n2. 使用 TaskOutput 阻塞等待任务结束（block=true, timeout=15）\\n\\n3. 检查任务最终状态是否为 timeout\\n\\n请报告：task_id、最终状态、exit_code、是否有 timeout 通知。\\nTurnBegin(\\n    user_input=\\"请测试后台任务超时功能：\\\\n\\\\n1. 启动一个会超时的后台任务：\\\\n   - \\n命令: sleep 300\\\\n   - run_in_background: true\\\\n   - description: \\n'测试超时处理'\\\\n   - timeout: 3  （设置为3秒，确保会超时）\\\\n\\\\n2. 使用 TaskOutput\\n阻塞等待任务结束（block=true, timeout=15）\\\\n\\\\n3. 检查任务最终状态是否为 \\n... [truncated]"}],"toolCalls":[],"toolCallId":"tool_J3cQ5m3qyTep0zNLWhZR3OGg"}}
-{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"第三轮也成功！测试了超时处理：\\n1. ✅ 任务正确超时\\n2. ✅ 状态为 failed，timed_out=true\\n3. ✅ 通知正确发送 (task.timed_out)\\n4. ✅ exit_code 正确 (-15)\\n\\n现在进入观察轮，检查 session 产物，验证 notification 是否正确写入 context 等。"},{"type":"text","text":"第三轮成功！超时处理完全正常。现在进入观察轮，检查 session 产物："}],"toolCalls":[{"type":"function","id":"tool_n7Bz3OSHPlOZnL3ghEe8Rciw","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮3：超时场景测试\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_3s3qLBo5c7kA1pqbpX36YbVo","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 查找 session 目录\\\\necho \\\\\\"=== Session 定位 ===\\\\\\"\\\\nSESSION_ID=$(echo -n \\\\\\"$SMOKE_DIR\\\\\\" | md5)\\\\necho \\\\\\"Work dir: $SMOKE_DIR\\\\\\"\\\\necho \\\\\\"Session ID (md5): $SESSION_ID\\\\\\"\\\\nSESSION_DIR=\\\\\\"$HOME/.kimi/sessions/$SESSION_ID\\\\\\"\\\\necho \\\\\\"Session dir: $SESSION_DIR\\\\\\"\\\\n\\\\n# 检查 session 目录是否存在\\\\nif [ -d \\\\\\"$SESSION_DIR\\\\\\" ]; then\\\\n    echo \\\\\\"Session exists: YES\\\\\\"\\\\n    ls -la \\\\\\"$SESSION_DIR\\\\\\"\\\\nelse\\\\n    echo \\\\\\"Session exists: NO\\\\\\"\\\\n    # 尝试找到最新的 session\\\\n    echo \\\\\\"Finding... [truncated]"}}]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"第三轮也成功！测试了超时处理：\\n1. ✅ 任务正确超时\\n2. ✅ 状态为 failed，timed_out=true\\n3. ✅ 通知正确发送 (task.timed_out)\\n4. ✅ exit_code 正确 (-15)\\n\\n现在进入观察轮，检查 session 产物，验证 notification 是否正确写入 context 等。"},{"type":"text","text":"第三轮成功！超时处理完全正常。现在进入观察轮，检查 session 产物："}],"toolCalls":[{"type":"function","id":"tool_n7Bz3OSHPlOZnL3ghEe8Rciw","function":{"name":"SetTodoList","arguments":"{\\"todos\\": [{\\"title\\": \\"准备测试环境（创建隔离 work-dir）\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"探索轮：验证工具可用性和接口\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮1：正常路径 - 后台任务生命周期\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮2：边界条件 - 超时和停止\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"执行轮3：超时场景测试\\", \\"status\\": \\"done\\"}, {\\"title\\": \\"观察轮：检查 session 产物\\", \\"status\\": \\"in_progress\\"}, {\\"title\\": \\"汇报结论\\", \\"status\\": \\"pending\\"}]}"}},{"type":"function","id":"tool_3s3qLBo5c7kA1pqbpX36YbVo","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 查找 session 目录\\\\necho \\\\\\"=== Session 定位 ===\\\\\\"\\\\nSESSION_ID=$(echo -n \\\\\\"$SMOKE_DIR\\\\\\" | md5)\\\\necho \\\\\\"Work dir: $SMOKE_DIR\\\\\\"\\\\necho \\\\\\"Session ID (md5): $SESSION_ID\\\\\\"\\\\nSESSION_DIR=\\\\\\"$HOME/.kimi/sessions/$SESSION_ID\\\\\\"\\\\necho \\\\\\"Session dir: $SESSION_DIR\\\\\\"\\\\n\\\\n# 检查 session 目录是否存在\\\\nif [ -d \\\\\\"$SESSION_DIR\\\\\\" ]; then\\\\n    echo \\\\\\"Session exists: YES\\\\\\"\\\\n    ls -la \\\\\\"$SESSION_DIR\\\\\\"\\\\nelse\\\\n    echo \\\\\\"Session exists: NO\\\\\\"\\\\n    # 尝试找到最新的 session\\\\n    echo \\\\\\"Finding... [truncated]"}}],"toolCallDisplays":{"tool_n7Bz3OSHPlOZnL3ghEe8Rciw":{"kind":"todo_list","items":[{"title":"准备测试环境（创建隔离 work-dir）","status":"done"},{"title":"探索轮：验证工具可用性和接口","status":"done"},{"title":"执行轮1：正常路径 - 后台任务生命周期","status":"done"},{"title":"执行轮2：边界条件 - 超时和停止","status":"done"},{"title":"执行轮3：超时场景测试","status":"done"},{"title":"观察轮：检查 session 产物","status":"in_progress"},{"title":"汇报结论","status":"pending"}]}}}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Todo list updated</system>"}],"toolCalls":[],"toolCallId":"tool_n7Bz3OSHPlOZnL3ghEe8Rciw"}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>Command executed successfully.</system>"},{"type":"text","text":"=== Session 定位 ===\\nWork dir: /tmp/kimi-smoke-a2i1xj\\nSession ID (md5): d1c3750c0cc0757aeac04ad5a7d6b8cf\\nSession dir: /Users/example/proj/.kimi/sessions/d1c3750c0cc0757aeac04ad5a7d6b8cf\\nSession exists: YES\\ntotal 0\\ndrwxr-xr-x@    6 user      staff    192  3月 17 12:59 .\\ndrwxr-xr-x@ 1722 user      staff  55104  3月 17 12:58 ..\\ndrwxr-xr-x@    6 user      staff    192  3月 17 12:58 0e1d3b94-dae2-4dfb-b36d-717397f4d2f6\\ndrwxr-xr-x@    6 user      staff    192  3月 17 12:59 228b54e2-5b5d-4675-94f2-ec56e42cdbae\\nd... [truncated]"}],"toolCalls":[],"toolCallId":"tool_3s3qLBo5c7kA1pqbpX36YbVo"}}
 {"type":"context.append_message","message":{"role":"assistant","content":[{"type":"think","think":"找到了 session 目录，下面有多个子目录（每次运行 CLI 会创建一个新的子 session）。让我使用 inspect_session.py 来检查最新的 session。"}],"toolCalls":[{"type":"function","id":"tool_4Zcuo5i4xl2NEz1Y1EZ1IvSn","function":{"name":"Shell","arguments":"{\\"command\\": \\"SMOKE_DIR=\\\\\\"/tmp/kimi-smoke-a2i1xj\\\\\\"\\\\n\\\\n# 使用 inspect_session.py 检查最新的 session\\\\necho \\\\\\"=== 使用 inspect_session.py 检查 ===\\\\\\"\\\\nuv run python .agents/skills/example-task/scripts/inspect_session.py --share-dir ~/.kimi 2>&1\\"}"}}]}}
@@ -142,7 +150,11 @@ exports[`migration snapshot: legacy-protocol-1.3 > migration succeeds and matche
     "kimi_cli_session_id": "legacy-protocol-1.3",
     "kimi_cli_wire_protocol": "1.3",
     "imported_at": "<REDACTED>",
-    "archived": true
+    "archived": true,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
@@ -175,7 +187,11 @@ exports[`migration snapshot: recent-protocol-1.10 > migration succeeds and match
     "kimi_cli_session_id": "recent-protocol-1.10",
     "kimi_cli_wire_protocol": "1.10",
     "imported_at": "<REDACTED>",
-    "archived": false
+    "archived": false,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
@@ -211,7 +227,11 @@ exports[`migration snapshot: tiny-hello-world > migration succeeds and matches s
     "kimi_cli_session_id": "tiny-hello-world",
     "kimi_cli_wire_protocol": "1.10",
     "imported_at": "<REDACTED>",
-    "archived": false
+    "archived": false,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
@@ -275,7 +295,11 @@ exports[`migration snapshot: with-subagent-collapsed > migration succeeds and ma
     "kimi_cli_session_id": "with-subagent-collapsed",
     "kimi_cli_wire_protocol": "1.6",
     "imported_at": "<REDACTED>",
-    "archived": false
+    "archived": false,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
@@ -309,7 +333,11 @@ exports[`migration snapshot: with-thinking > migration succeeds and matches snap
     "kimi_cli_session_id": "with-thinking",
     "kimi_cli_wire_protocol": "1.9",
     "imported_at": "<REDACTED>",
-    "archived": false
+    "archived": false,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
@@ -342,13 +370,17 @@ exports[`migration snapshot: with-tool-calls > migration succeeds and matches sn
     "kimi_cli_session_id": "with-tool-calls",
     "kimi_cli_wire_protocol": "1.8",
     "imported_at": "<REDACTED>",
-    "archived": false
+    "archived": false,
+    "vscode_legacy_approval": {
+      "yolo": false,
+      "afk": false
+    }
   }
 }",
   "wire": "{"type":"metadata","protocol_version":"1.0","created_at":<REDACTED>}
 {"type":"context.append_message","message":{"role":"user","content":[{"type":"text","text":"run echo hi"}],"toolCalls":[]}}
 {"type":"context.append_message","message":{"role":"user","content":[{"type":"text","text":"<system-reminder>\\nYou are running in non-interactive mode. The user cannot answer questions or provide feedback during execution.\\n- Do NOT call AskUserQuestion. If you need to make a decision, make your best judgment and proceed.\\n- For EnterPlanMode / ExitPlanMode, they will be auto-approved. You can use them normally but expect no user feedback.\\n</system-reminder>"}],"toolCalls":[]}}
-{"type":"context.append_message","message":{"role":"assistant","content":[],"toolCalls":[{"type":"function","id":"tc1","function":{"name":"Shell","arguments":"{\\"command\\": \\"echo hi\\"}"}}]}}
+{"type":"context.append_message","message":{"role":"assistant","content":[],"toolCalls":[{"type":"function","id":"tc1","function":{"name":"Shell","arguments":"{\\"command\\": \\"echo hi\\"}"}}],"toolCallDisplays":{"tc1":{"kind":"generic","summary":"Hook blocked"}}}}
 {"type":"context.append_message","message":{"role":"tool","content":[{"type":"text","text":"<system>ERROR: Shell blocked by hook</system>"}],"toolCalls":[],"toolCallId":"tc1"}}
 ",
 }
diff --git a/packages/migration-legacy/test/sessions/sessions-step.test.ts b/packages/migration-legacy/test/sessions/sessions-step.test.ts
index 2c9b9f2bd..bf7a9e5ee 100644
--- a/packages/migration-legacy/test/sessions/sessions-step.test.ts
+++ b/packages/migration-legacy/test/sessions/sessions-step.test.ts
@@ -39,6 +39,7 @@ describe('migrateSessionsStep (multi-workdir fixture)', () => {
     expect(report.sessionsMigrated).toBe(2); // a1, a2
     expect(report.sessionsSkippedPlaceholder).toBe(1);
     expect(report.sessionsSkippedEmpty).toBe(1);
+    expect(report.sessionsFailed).toEqual([]);
   });
 
   it('counts a migrated session as failed when its index entry cannot be written', async () => {
@@ -175,4 +176,99 @@ describe('migrateSessionsStep (multi-workdir fixture)', () => {
       await rm(src, { recursive: true, force: true });
     }
   });
+
+  it('reports a non-empty session without context.jsonl as a failure', async () => {
+    const src = await mkdtemp(join(tmpdir(), 'missing-context-src-'));
+    try {
+      const workdir = '/Users/me/missing-context-project';
+      await writeFile(
+        join(src, 'kimi.json'),
+        JSON.stringify({ work_dirs: [{ path: workdir, kaos: 'local' }] }),
+      );
+      const sessionDir = join(src, 'sessions', oldMd5BucketName(workdir), 'missing-context');
+      await mkdir(sessionDir, { recursive: true });
+      await writeFile(join(sessionDir, 'state.json'), '{}');
+
+      const report = await migrateSessionsStep({ sourceHome: src, targetHome });
+
+      expect(report.sessionsFailed).toEqual([
+        {
+          sourcePath: sessionDir,
+          reason: expect.stringMatching(/context\.jsonl.*missing.*unreadable/i),
+        },
+      ]);
+      expect(report.sessionsSkippedMalformed).toBe(0);
+    } finally {
+      await rm(src, { recursive: true, force: true });
+    }
+  });
+
+  it('reports a context.jsonl that cannot be read as a failure', async () => {
+    const src = await mkdtemp(join(tmpdir(), 'unreadable-context-src-'));
+    try {
+      const workdir = '/Users/me/unreadable-context-project';
+      await writeFile(
+        join(src, 'kimi.json'),
+        JSON.stringify({ work_dirs: [{ path: workdir, kaos: 'local' }] }),
+      );
+      const sessionDir = join(src, 'sessions', oldMd5BucketName(workdir), 'bad-context');
+      await mkdir(join(sessionDir, 'context.jsonl'), { recursive: true });
+
+      const report = await migrateSessionsStep({ sourceHome: src, targetHome });
+
+      expect(report.sessionsFailed).toEqual([
+        {
+          sourcePath: sessionDir,
+          reason: expect.stringMatching(/context\.jsonl.*unreadable/i),
+        },
+      ]);
+    } finally {
+      await rm(src, { recursive: true, force: true });
+    }
+  });
+
+  it('reports an unknown workdir bucket as a failure', async () => {
+    const src = await mkdtemp(join(tmpdir(), 'unknown-workdir-src-'));
+    try {
+      const bucket = join(src, 'sessions', oldMd5BucketName('/workspace/not-registered'));
+      await mkdir(join(bucket, 'legacy-session'), { recursive: true });
+
+      const report = await migrateSessionsStep({ sourceHome: src, targetHome });
+
+      expect(report.bucketsSkippedNoWorkdirFound).toBe(1);
+      expect(report.sessionsFailed).toEqual([
+        {
+          sourcePath: bucket,
+          reason: expect.stringMatching(/workdir.*kimi\.json/i),
+        },
+      ]);
+    } finally {
+      await rm(src, { recursive: true, force: true });
+    }
+  });
+
+  it('reports a bucket that cannot be read as a failure', async () => {
+    const src = await mkdtemp(join(tmpdir(), 'unreadable-bucket-src-'));
+    try {
+      const workdir = '/Users/me/unreadable-bucket-project';
+      await writeFile(
+        join(src, 'kimi.json'),
+        JSON.stringify({ work_dirs: [{ path: workdir, kaos: 'local' }] }),
+      );
+      const bucket = join(src, 'sessions', oldMd5BucketName(workdir));
+      await mkdir(join(src, 'sessions'), { recursive: true });
+      await writeFile(bucket, 'not a directory');
+
+      const report = await migrateSessionsStep({ sourceHome: src, targetHome });
+
+      expect(report.sessionsFailed).toEqual([
+        {
+          sourcePath: bucket,
+          reason: expect.stringMatching(/bucket could not be read/i),
+        },
+      ]);
+    } finally {
+      await rm(src, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/packages/migration-legacy/test/sessions/state-writer.test.ts b/packages/migration-legacy/test/sessions/state-writer.test.ts
index a393100d8..e33aa98f8 100644
--- a/packages/migration-legacy/test/sessions/state-writer.test.ts
+++ b/packages/migration-legacy/test/sessions/state-writer.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: translating legacy session state into the v1 session metadata file.
+ * Responsibilities: user-visible metadata and legacy session-scoped fields survive migration.
+ * Wiring: real state writer and filesystem; no collaborators are stubbed.
+ * Run: pnpm exec vitest run packages/migration-legacy/test/sessions/state-writer.test.ts
+ */
 import { describe, expect, it, beforeEach, afterEach } from 'vitest';
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -72,4 +78,38 @@ describe('writeSessionState', () => {
     const meta = JSON.parse(await readFile(join(dir, 'state.json'), 'utf-8'));
     expect(meta.custom.archived).toBe(true);
   });
+
+  it('writes legacy additional dirs into session-scoped metadata', async () => {
+    await writeSessionState(dir, {
+      oldState: {
+        additional_dirs: ['../shared', 'C:\\Projects\\reference'],
+        wire_mtime: 1,
+      },
+      lastUserPrompt: 'x',
+      sourcePath: '/a',
+      oldSessionUuid: 'u',
+      wireProtocolFromOld: null,
+      createdAtMs: 1,
+    });
+
+    const meta = JSON.parse(await readFile(join(dir, 'state.json'), 'utf-8'));
+    expect(meta.additionalDirs).toEqual(['../shared', 'C:\\Projects\\reference']);
+  });
+
+  it('preserves the independent legacy yolo and afk flags', async () => {
+    await writeSessionState(dir, {
+      oldState: {
+        approval: { yolo: true, afk: false },
+        wire_mtime: 1,
+      },
+      lastUserPrompt: 'x',
+      sourcePath: '/a',
+      oldSessionUuid: 'u',
+      wireProtocolFromOld: null,
+      createdAtMs: 1,
+    });
+
+    const meta = JSON.parse(await readFile(join(dir, 'state.json'), 'utf-8'));
+    expect(meta.custom.vscode_legacy_approval).toEqual({ yolo: true, afk: false });
+  });
 });
diff --git a/packages/migration-legacy/test/sessions/translator.test.ts b/packages/migration-legacy/test/sessions/translator.test.ts
index 785aab192..cd2ea789c 100644
--- a/packages/migration-legacy/test/sessions/translator.test.ts
+++ b/packages/migration-legacy/test/sessions/translator.test.ts
@@ -1,9 +1,15 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 import {
   translateContextLines,
   containsUsableMessage,
   analyzeContextContent,
 } from '../../src/sessions/translator.js';
+import { extractToolCallDisplays } from '../../src/sessions/tool-call-display.js';
+
+const FIXTURES = fileURLToPath(new URL('../fixtures', import.meta.url));
 
 describe('translateContextLines', () => {
   it('drops _system_prompt, _checkpoint, _usage markers', () => {
@@ -98,6 +104,19 @@ describe('translateContextLines', () => {
   });
 });
 
+describe('extractToolCallDisplays', () => {
+  it('recovers the file diff from a real legacy wire fixture', async () => {
+    const wire = await readFile(join(FIXTURES, 'archived', 'wire.jsonl'), 'utf-8');
+
+    expect(extractToolCallDisplays(wire).get('WriteFile:1')).toEqual({
+      kind: 'diff',
+      path: expect.stringMatching(/translated\.py$/),
+      before: '',
+      after: expect.stringContaining('def main():'),
+    });
+  });
+});
+
 describe('containsUsableMessage', () => {
   it('false when lines hold only _system_prompt / _checkpoint / _usage markers', () => {
     expect(
diff --git a/packages/node-sdk/CHANGELOG.md b/packages/node-sdk/CHANGELOG.md
index a2bf3356d..4366a54b3 100644
--- a/packages/node-sdk/CHANGELOG.md
+++ b/packages/node-sdk/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @moonshot-ai/kimi-code-sdk
 
+## 0.13.4
+
+### Patch Changes
+
+- [#1769](https://github.com/MoonshotAI/kimi-code/pull/1769) [`d1ca65e`](https://github.com/MoonshotAI/kimi-code/commit/d1ca65e1de189617e9edbc54010e62d472a1de3d) Thanks [@wbxl2000](https://github.com/wbxl2000)! - Support in-process editor hosts with session lifecycle, context, MCP configuration, and cross-platform session storage APIs.
+
 ## 0.13.3
 
 ### Patch Changes
diff --git a/packages/node-sdk/package.json b/packages/node-sdk/package.json
index b6422f911..805afe630 100644
--- a/packages/node-sdk/package.json
+++ b/packages/node-sdk/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@moonshot-ai/kimi-code-sdk",
-  "version": "0.13.3",
+  "version": "0.13.4",
   "private": true,
   "description": "TypeScript SDK for the Kimi Code Agent",
   "license": "MIT",
diff --git a/packages/node-sdk/src/index.ts b/packages/node-sdk/src/index.ts
index f58e06075..6b731391e 100644
--- a/packages/node-sdk/src/index.ts
+++ b/packages/node-sdk/src/index.ts
@@ -52,6 +52,7 @@ export {
 // RootLogger / getRootLogger / LoggingConfig stay inside agent-core.
 export {
   flushDiagnosticLogs,
+  flushDiagnosticLogsSync,
   log,
   redact,
   resolveGlobalLogPath,
diff --git a/packages/node-sdk/src/kimi-harness.ts b/packages/node-sdk/src/kimi-harness.ts
index 7e9a22a7b..653933c78 100644
--- a/packages/node-sdk/src/kimi-harness.ts
+++ b/packages/node-sdk/src/kimi-harness.ts
@@ -11,6 +11,7 @@ import { Session } from '#/session';
 import type { KimiAuthFacade } from '#/auth';
 import type { SDKRpcClientBase } from '#/rpc';
 import type {
+  AuthenticateMcpServerOptions,
   ConfigDiagnostics,
   CreateSessionOptions,
   ExportSessionInput,
@@ -21,13 +22,17 @@ import type {
   KimiConfigPatch,
   KimiHostIdentity,
   ListSessionsOptions,
+  McpServerConfig,
+  McpTestResult,
   RenameSessionInput,
   ResumeSessionInput,
   ReloadSessionInput,
   SessionSummary,
+  SkillSummary,
   TelemetryClient,
   TelemetryContextPatch,
   TelemetryProperties,
+  TestMcpServerOptions,
 } from '#/types';
 
 export interface KimiHarnessRuntimeOptions {
@@ -194,6 +199,7 @@ export class KimiHarness {
       forkId: input.forkId,
       title: input.title,
       metadata: input.metadata,
+      turnIndex: input.turnIndex,
     });
     const session = new Session({
       id: summary.id,
@@ -218,6 +224,12 @@ export class KimiHarness {
     await this.activeSessions.get(id)?.close();
   }
 
+  async deleteSession(id: string): Promise<void> {
+    const sessionId = normalizeSessionId(id);
+    await this.activeSessions.get(sessionId)?.close();
+    await this.rpc.deleteSession({ sessionId });
+  }
+
   async renameSession(input: RenameSessionInput): Promise<void> {
     await this.rpc.renameSession(input);
     this.activeSessions.get(input.id)?.emitMetaUpdated({ title: input.title });
@@ -236,6 +248,11 @@ export class KimiHarness {
     return this.rpc.listSessions(options);
   }
 
+  /** Skills visible to a new session in `workDir`, without creating that session. */
+  async listWorkspaceSkills(workDir: string): Promise<readonly SkillSummary[]> {
+    return this.rpc.listWorkspaceSkills(workDir);
+  }
+
   async getConfig(options: GetConfigOptions = {}): Promise<KimiConfig> {
     return this.rpc.getConfig(options);
   }
@@ -261,6 +278,55 @@ export class KimiHarness {
     return this.rpc.removeProvider(providerId);
   }
 
+  /** User-global MCP entries from `<KIMI_CODE_HOME>/mcp.json` only. */
+  async listMcpServers(): Promise<readonly McpServerConfig[]> {
+    return this.rpc.listGlobalMcpServers();
+  }
+
+  async addMcpServer(server: McpServerConfig): Promise<readonly McpServerConfig[]> {
+    return this.rpc.addGlobalMcpServer(server);
+  }
+
+  async updateMcpServer(server: McpServerConfig): Promise<readonly McpServerConfig[]> {
+    return this.rpc.updateGlobalMcpServer(server);
+  }
+
+  async removeMcpServer(name: string): Promise<readonly McpServerConfig[]> {
+    return this.rpc.removeGlobalMcpServer(name);
+  }
+
+  async authenticateMcpServer(
+    name: string,
+    options: AuthenticateMcpServerOptions,
+  ): Promise<void> {
+    const started = await this.rpc.beginGlobalMcpServerAuth(name);
+    if (started.status === 'already-authorized') return;
+    try {
+      const opened = await options.onAuthorizationUrl(started.authorizationUrl);
+      if (opened === false) {
+        throw new KimiError(ErrorCodes.REQUEST_INVALID, 'MCP OAuth authorization was cancelled');
+      }
+      await this.rpc.completeGlobalMcpServerAuth(
+        { flowId: started.flowId, timeoutMs: options.timeoutMs },
+        options.signal,
+      );
+    } catch (error) {
+      await this.rpc.cancelGlobalMcpServerAuth(started.flowId).catch(() => undefined);
+      throw error;
+    }
+  }
+
+  async resetMcpServerAuth(name: string): Promise<void> {
+    return this.rpc.resetGlobalMcpServerAuth(name);
+  }
+
+  async testMcpServer(
+    name: string,
+    options: TestMcpServerOptions = {},
+  ): Promise<McpTestResult> {
+    return this.rpc.testGlobalMcpServer(name, options);
+  }
+
   async close(): Promise<void> {
     await Promise.all(Array.from(this.activeSessions.values(), (session) => session.close()));
     await this.closeImpl();
diff --git a/packages/node-sdk/src/rpc.ts b/packages/node-sdk/src/rpc.ts
index 9b1b83554..df5a2825e 100644
--- a/packages/node-sdk/src/rpc.ts
+++ b/packages/node-sdk/src/rpc.ts
@@ -6,6 +6,7 @@ import {
   type AgentContextData,
   type ApprovalRequest,
   type ApprovalResponse,
+  type BeginGlobalMcpServerAuthResult,
   type CoreAPI,
   type Event,
   type ExperimentalFeatureState,
@@ -32,13 +33,16 @@ import type {
   CreateGoalInput,
   ForkSessionInput,
   GetConfigOptions,
+  McpServerConfig,
   GoalSnapshot,
   GoalToolResult,
+  JsonObject,
   KimiConfig,
   KimiConfigPatch,
   ListSessionsOptions,
   McpServerInfo,
   McpStartupMetrics,
+  McpTestResult,
   PermissionMode,
   PluginInfo,
   PluginSummary,
@@ -68,6 +72,11 @@ export interface SessionIdRpcInput {
   readonly sessionId: string;
 }
 
+export interface ImportContextRpcInput extends SessionIdRpcInput {
+  readonly content: string;
+  readonly source: string;
+}
+
 export interface ReloadSessionRpcInput extends SessionIdRpcInput {
   readonly forcePluginSessionStartReminder?: boolean;
 }
@@ -89,6 +98,10 @@ export interface SetSessionPermissionRpcInput extends SessionIdRpcInput {
   readonly mode: PermissionMode;
 }
 
+export interface UpdateSessionMetadataRpcInput extends SessionIdRpcInput {
+  readonly metadata: JsonObject;
+}
+
 export interface SetSessionPlanModeRpcInput extends SessionIdRpcInput {
   readonly enabled: boolean;
 }
@@ -177,6 +190,7 @@ export abstract class SDKRpcClientBase {
       id: input.forkId,
       title: input.title,
       metadata: input.metadata,
+      turnIndex: input.turnIndex,
     });
   }
 
@@ -185,11 +199,21 @@ export abstract class SDKRpcClientBase {
     return rpc.closeSession({ sessionId: input.sessionId });
   }
 
+  async deleteSession(input: SessionIdRpcInput): Promise<void> {
+    const rpc = await this.getRpc();
+    return rpc.deleteSession({ sessionId: input.sessionId });
+  }
+
   async listSessions(input: ListSessionsOptions = {}): Promise<readonly SessionSummary[]> {
     const rpc = await this.getRpc();
     return rpc.listSessions(input);
   }
 
+  async listWorkspaceSkills(workDir: string): Promise<readonly SkillSummary[]> {
+    const rpc = await this.getRpc();
+    return rpc.listWorkspaceSkills({ workDir });
+  }
+
   async renameSession(input: RenameSessionInput): Promise<void> {
     const rpc = await this.getRpc();
     return rpc.renameSession({
@@ -235,6 +259,57 @@ export abstract class SDKRpcClientBase {
     return rpc.removeKimiProvider({ providerId });
   }
 
+  async listGlobalMcpServers(): Promise<readonly McpServerConfig[]> {
+    const rpc = await this.getRpc();
+    return rpc.listGlobalMcpServers({});
+  }
+
+  async addGlobalMcpServer(server: McpServerConfig): Promise<readonly McpServerConfig[]> {
+    const rpc = await this.getRpc();
+    return rpc.addGlobalMcpServer({ server });
+  }
+
+  async updateGlobalMcpServer(server: McpServerConfig): Promise<readonly McpServerConfig[]> {
+    const rpc = await this.getRpc();
+    return rpc.updateGlobalMcpServer({ server });
+  }
+
+  async removeGlobalMcpServer(name: string): Promise<readonly McpServerConfig[]> {
+    const rpc = await this.getRpc();
+    return rpc.removeGlobalMcpServer({ name });
+  }
+
+  async beginGlobalMcpServerAuth(name: string): Promise<BeginGlobalMcpServerAuthResult> {
+    const rpc = await this.getRpc();
+    return rpc.beginGlobalMcpServerAuth({ name });
+  }
+
+  async completeGlobalMcpServerAuth(
+    input: { readonly flowId: string; readonly timeoutMs?: number },
+    signal?: AbortSignal,
+  ): Promise<void> {
+    const rpc = await this.getRpc();
+    return rpc.completeGlobalMcpServerAuth(input, { signal });
+  }
+
+  async cancelGlobalMcpServerAuth(flowId: string): Promise<void> {
+    const rpc = await this.getRpc();
+    return rpc.cancelGlobalMcpServerAuth({ flowId });
+  }
+
+  async resetGlobalMcpServerAuth(name: string): Promise<void> {
+    const rpc = await this.getRpc();
+    return rpc.resetGlobalMcpServerAuth({ name });
+  }
+
+  async testGlobalMcpServer(
+    name: string,
+    options: { readonly cwd?: string } = {},
+  ): Promise<McpTestResult> {
+    const rpc = await this.getRpc();
+    return rpc.testGlobalMcpServer({ name, cwd: options.cwd });
+  }
+
   async prompt(input: SessionPromptRpcInput): Promise<void> {
     const agentId = this.interactiveAgentId;
     const rpc = await this.getRpc();
@@ -313,6 +388,24 @@ export abstract class SDKRpcClientBase {
     });
   }
 
+  async clearContext(input: SessionIdRpcInput): Promise<void> {
+    const rpc = await this.getRpc();
+    return rpc.clearContext({
+      sessionId: input.sessionId,
+      agentId: this.interactiveAgentId,
+    });
+  }
+
+  async importContext(input: ImportContextRpcInput): Promise<void> {
+    const rpc = await this.getRpc();
+    return rpc.importContext({
+      sessionId: input.sessionId,
+      agentId: this.interactiveAgentId,
+      content: input.content,
+      source: input.source,
+    });
+  }
+
   async setModel(input: SetSessionModelRpcInput): Promise<SetSessionModelRpcResult> {
     const rpc = await this.getRpc();
     return rpc.setModel({
@@ -340,6 +433,16 @@ export abstract class SDKRpcClientBase {
     });
   }
 
+  async updateSessionMetadata(input: UpdateSessionMetadataRpcInput): Promise<void> {
+    const rpc = await this.getRpc();
+    const current = await rpc.getSessionMetadata({ sessionId: input.sessionId });
+    const metadata = { ...current.custom, ...input.metadata } as JsonObject;
+    await rpc.updateSessionMetadata({
+      sessionId: input.sessionId,
+      metadata: { custom: metadata },
+    });
+  }
+
   async setPlanMode(input: SetSessionPlanModeRpcInput): Promise<void> {
     const rpc = await this.getRpc();
     if (!input.enabled) {
diff --git a/packages/node-sdk/src/sdk-rpc-client.ts b/packages/node-sdk/src/sdk-rpc-client.ts
index ae3c3c67f..ae7e7ecd6 100644
--- a/packages/node-sdk/src/sdk-rpc-client.ts
+++ b/packages/node-sdk/src/sdk-rpc-client.ts
@@ -37,6 +37,12 @@ export interface SDKRpcClientOptions {
   readonly skillDirs?: readonly string[];
   readonly telemetry?: TelemetryClient;
   readonly onOAuthRefresh?: (outcome: OAuthRefreshOutcome) => void;
+  /**
+   * Host UI mode (`'print'` for `kimi -p`, `'cli'` for the TUI, ...). Forwarded
+   * to the v1 core, which applies print-mode config defaults when it is
+   * `'print'`.
+   */
+  readonly uiMode?: string;
 }
 
 export class SDKRpcClient extends SDKRpcClientBase {
@@ -78,6 +84,7 @@ export class SDKRpcClient extends SDKRpcClientBase {
       skillDirs: options.skillDirs,
       telemetry: this.telemetry,
       appVersion: this.identity?.version,
+      uiMode: options.uiMode,
     };
     this.core = new KimiCore(coreRpc, coreOptions);
     this.ready = sdkRpc(new ClientAPI(this));
diff --git a/packages/node-sdk/src/session.ts b/packages/node-sdk/src/session.ts
index 2c0ec3e9f..571c2355f 100644
--- a/packages/node-sdk/src/session.ts
+++ b/packages/node-sdk/src/session.ts
@@ -17,6 +17,7 @@ import type {
   GetCronTasksResult,
   GoalSnapshot,
   GoalToolResult,
+  JsonObject,
   McpServerInfo,
   McpStartupMetrics,
   PermissionMode,
@@ -217,6 +218,30 @@ export class Session {
     await this.rpc.setPermission({ sessionId: this.id, mode });
   }
 
+  /** Shallow-merge host-owned fields into this session's persisted custom metadata. */
+  async updateMetadata(patch: JsonObject): Promise<void> {
+    this.ensureOpen();
+    if (Object.hasOwn(patch, 'goal')) {
+      throw new KimiError(
+        ErrorCodes.GOAL_METADATA_RESERVED,
+        'Session metadata key "goal" is reserved for the goal lifecycle',
+      );
+    }
+    const summary = this.requireSummary();
+    await this.rpc.updateSessionMetadata({ sessionId: this.id, metadata: patch });
+    const metadata = { ...summary.metadata, ...patch };
+    this.summary = { ...summary, metadata };
+    if (this.resumeState !== undefined) {
+      this.resumeState = {
+        ...this.resumeState,
+        sessionMetadata: {
+          ...this.resumeState.sessionMetadata,
+          custom: { ...this.resumeState.sessionMetadata.custom, ...patch },
+        },
+      };
+    }
+  }
+
   async setPlanMode(enabled: boolean): Promise<void> {
     this.ensureOpen();
     if (typeof enabled !== 'boolean') {
@@ -272,6 +297,18 @@ export class Session {
     await this.rpc.undoHistory({ sessionId: this.id, count });
   }
 
+  /** Clear this session's model context without creating a new session. */
+  async clearContext(): Promise<void> {
+    this.ensureOpen();
+    await this.rpc.clearContext({ sessionId: this.id });
+  }
+
+  /** Append imported text to this session's context without prompting the model. */
+  async importContext(content: string, source: string): Promise<void> {
+    this.ensureOpen();
+    await this.rpc.importContext({ sessionId: this.id, content, source });
+  }
+
   async getContext(): Promise<AgentContextData> {
     this.ensureOpen();
     return this.rpc.getContext({ sessionId: this.id });
diff --git a/packages/node-sdk/src/types.ts b/packages/node-sdk/src/types.ts
index 869a14745..c72419e3f 100644
--- a/packages/node-sdk/src/types.ts
+++ b/packages/node-sdk/src/types.ts
@@ -64,6 +64,8 @@ export type {
   SkillSummary,
   ThinkingConfig,
   ToolInfo,
+  GlobalMcpServerConfig as McpServerConfig,
+  GlobalMcpServerTestResult as McpTestResult,
 } from '@moonshot-ai/agent-core';
 
 export type { KimiHostIdentity, OAuthRefreshOutcome };
@@ -126,6 +128,8 @@ export interface ResumeSessionInput {
   readonly kaos?: Kaos | undefined;
   readonly persistenceKaos?: Kaos | undefined;
   readonly additionalDirs?: readonly string[];
+  /** Include persisted subagent states in the returned replay snapshot. */
+  readonly includeSubagents?: boolean;
   readonly sessionStartedProperties?: TelemetryProperties;
 }
 
@@ -140,6 +144,8 @@ export interface AddAdditionalDirInput {
 }
 
 export interface AddAdditionalDirOptions {
+  /** When true, share the directory through workspace local config. When false,
+   * keep it scoped to this session while still restoring it on session resume. */
   readonly persist: boolean;
 }
 
@@ -148,6 +154,11 @@ export interface ForkSessionInput {
   readonly forkId?: string;
   readonly title?: string;
   readonly metadata?: JsonObject;
+  /**
+   * Zero-based index of the user-visible turn to retain through. Omit it to
+   * preserve the existing full-session fork behavior.
+   */
+  readonly turnIndex?: number;
 }
 
 export interface ExportSessionInput {
@@ -177,6 +188,18 @@ export interface GetConfigOptions {
   readonly reload?: boolean | undefined;
 }
 
+export interface AuthenticateMcpServerOptions {
+  readonly onAuthorizationUrl: (
+    url: string,
+  ) => void | boolean | PromiseLike<void | boolean>;
+  readonly signal?: AbortSignal;
+  readonly timeoutMs?: number;
+}
+
+export interface TestMcpServerOptions {
+  readonly cwd?: string;
+}
+
 export interface CompactOptions {
   readonly instruction?: string | undefined;
 }
diff --git a/packages/node-sdk/test/create-session-transport.test.ts b/packages/node-sdk/test/create-session-transport.test.ts
index 5bd3d4a64..491b19f25 100644
--- a/packages/node-sdk/test/create-session-transport.test.ts
+++ b/packages/node-sdk/test/create-session-transport.test.ts
@@ -587,6 +587,84 @@ effort = "medium"
     expect(coreSessionIds(harness)).toEqual([]);
   });
 
+  it('permanently deletes an active session', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({
+      identity: TEST_IDENTITY,
+      homeDir,
+    });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_delete_active', workDir });
+      const [summary] = await harness.listSessions({ sessionId: session.id });
+
+      await harness.deleteSession(session.id);
+
+      expect(harness.getSession(session.id)).toBeUndefined();
+      await expect(harness.listSessions({ sessionId: session.id })).resolves.toEqual([]);
+      expect(existsSync(summary!.sessionDir)).toBe(false);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('returns session.not_found when deleteSession targets a missing id', async () => {
+    const homeDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await expect(harness.deleteSession('ses_delete_missing')).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'session.not_found',
+      } satisfies Partial<KimiError>);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('allows a deleted session id to be created again', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+    const sessionId = 'ses_delete_recreate';
+
+    try {
+      await harness.createSession({ id: sessionId, workDir });
+      await harness.deleteSession(sessionId);
+
+      const recreated = await harness.createSession({ id: sessionId, workDir });
+
+      expect(recreated.id).toBe(sessionId);
+      await expect(harness.listSessions({ sessionId })).resolves.toHaveLength(1);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('preserves a legacy source directory referenced by session metadata', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const legacySourceDir = await makeTempDir();
+    const markerPath = join(legacySourceDir, 'legacy-marker.txt');
+    await writeFile(markerPath, 'legacy source remains', 'utf-8');
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      const session = await harness.createSession({
+        id: 'ses_delete_migrated',
+        workDir,
+        metadata: { kimi_cli_source_path: legacySourceDir },
+      });
+
+      await harness.deleteSession(session.id);
+
+      await expect(readFile(markerPath, 'utf-8')).resolves.toBe('legacy source remains');
+    } finally {
+      await harness.close();
+    }
+  });
+
   it('applies initial thinking and permission runtime options', async () => {
     const homeDir = await makeTempDir();
     const workDir = await makeTempDir();
diff --git a/packages/node-sdk/test/export-session.test.ts b/packages/node-sdk/test/export-session.test.ts
index 04f04cff2..358e1fac4 100644
--- a/packages/node-sdk/test/export-session.test.ts
+++ b/packages/node-sdk/test/export-session.test.ts
@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join, resolve, basename, dirname } from 'node:path';
 import * as zlib from 'node:zlib';
 
 import { afterEach, describe, expect, it } from 'vitest';
@@ -169,7 +169,7 @@ describe('exportSessionDirectory', () => {
     expect(manifest.workspaceDir).toBe(workDir);
   });
 
-  it('uses the default output path when outputPath is omitted', async () => {
+  it('uses a timestamped default output path when outputPath is omitted', async () => {
     const tmp = await makeTempDir();
     const sid = 'session_default_output';
     const sessionDir = join(tmp, 'sessions', sid);
@@ -181,10 +181,39 @@ describe('exportSessionDirectory', () => {
       summary: makeSummary({ id: sid, sessionDir, workDir: tmp }),
     });
 
-    const expectedPath = resolve(`${sid}.zip`);
-    expect(result.zipPath).toBe(toPosix(expectedPath));
+    expect(dirname(result.zipPath)).toBe(toPosix(resolve('.')));
+    expect(basename(result.zipPath)).toMatch(/^kimi-debug-session_-\d{8}-\d{6}\.zip$/);
     expect(existsSync(result.zipPath)).toBe(true);
-    await rm(expectedPath, { force: true });
+    await rm(result.zipPath, { force: true });
+  });
+
+  it('does not overwrite a previous default-path export when run again', async () => {
+    const tmp = await makeTempDir();
+    const sid = 'session_repeated_export';
+    const sessionDir = join(tmp, 'sessions', sid);
+    await mkdir(sessionDir, { recursive: true });
+    await writeFile(join(sessionDir, 'state.json'), '{}', 'utf-8');
+    const summary = makeSummary({ id: sid, sessionDir, workDir: tmp });
+
+    const first = await exportSessionDirectory({
+      request: { sessionId: sid, version: '1.0.0-test' },
+      summary,
+    });
+    // Cross the next second boundary so the second export gets a distinct timestamp.
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 1100 - (Date.now() % 1000)));
+    const second = await exportSessionDirectory({
+      request: { sessionId: sid, version: '1.0.0-test' },
+      summary,
+    });
+
+    try {
+      expect(second.zipPath).not.toBe(first.zipPath);
+      expect(existsSync(first.zipPath)).toBe(true);
+      expect(existsSync(second.zipPath)).toBe(true);
+    } finally {
+      await rm(first.zipPath, { force: true });
+      await rm(second.zipPath, { force: true });
+    }
   });
 
   it('omits global log manifest path when the global log cannot be bundled', async () => {
@@ -245,7 +274,7 @@ describe('exportSessionDirectory', () => {
 
     expect(result.manifest.sessionFirstActivity).toBeUndefined();
     expect(result.manifest.sessionLastActivity).toBeUndefined();
-    await rm(resolve(`${sid}.zip`), { force: true });
+    await rm(result.zipPath, { force: true });
   });
 
   it('rejects empty or missing session directories', async () => {
diff --git a/packages/node-sdk/test/list-sessions.test.ts b/packages/node-sdk/test/list-sessions.test.ts
index 44d046132..02c17192e 100644
--- a/packages/node-sdk/test/list-sessions.test.ts
+++ b/packages/node-sdk/test/list-sessions.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: Node SDK sessions persist and list through the public harness.
+ * Responsibilities: workDir scoping, index recovery, fork metadata, and native path-safe listing.
+ * Wiring: real in-process harness/session storage; no remote provider calls.
+ * Run: pnpm exec vitest run test/list-sessions.test.ts
+ */
 import { existsSync } from 'node:fs';
 import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -364,6 +370,26 @@ describe('KimiHarness.listSessions', () => {
     }
   });
 
+  it('lists a session from a workDir containing spaces and non-ASCII characters', async () => {
+    const homeDir = await makeTempDir();
+    const root = await makeTempDir();
+    const workDir = join(root, 'Workspace With Spaces', '项目');
+    await mkdir(workDir, { recursive: true });
+    const harness = createKimiHarness({
+      identity: TEST_IDENTITY,
+      homeDir,
+    });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_unicode_workdir', workDir });
+
+      const sessions = await harness.listSessions({ workDir });
+      expect(sessions.map((item) => item.id)).toEqual([session.id]);
+    } finally {
+      await harness.close();
+    }
+  });
+
   it('resolves relative workDir inputs before filtering', async () => {
     const homeDir = await makeTempDir();
     const workDir = await makeTempDir();
diff --git a/packages/node-sdk/test/mcp-config.test.ts b/packages/node-sdk/test/mcp-config.test.ts
new file mode 100644
index 000000000..ae36419e9
--- /dev/null
+++ b/packages/node-sdk/test/mcp-config.test.ts
@@ -0,0 +1,329 @@
+/**
+ * Scenario: a host manages and checks user-global MCP servers without a session.
+ * Responsibilities: global-only CRUD, safe malformed-file handling, standalone
+ * connection checks, and host-driven OAuth URL/cancellation orchestration.
+ * Wiring: real KimiHarness/Core/filesystem and stdio transport; only the OAuth
+ * RPC boundary is stubbed so no external authorization service is contacted.
+ * Run: pnpm exec vitest run packages/node-sdk/test/mcp-config.test.ts
+ */
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  createKimiHarness,
+  KimiHarness,
+  SDKRpcClientBase,
+} from '#/index';
+import { afterEach, describe, expect, it } from 'vitest';
+
+const tempDirs: string[] = [];
+const stdioFixture = join(
+  import.meta.dirname,
+  '../../agent-core/test/mcp/fixtures/mock-stdio-server.mjs',
+);
+
+afterEach(async () => {
+  await Promise.all(
+    tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })),
+  );
+});
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), 'kimi-sdk-mcp-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+async function writeMcpConfig(homeDir: string, value: unknown): Promise<void> {
+  await mkdir(homeDir, { recursive: true });
+  await writeFile(join(homeDir, 'mcp.json'), JSON.stringify(value), 'utf-8');
+}
+
+async function readMcpConfig(homeDir: string): Promise<Record<string, unknown>> {
+  return JSON.parse(await readFile(join(homeDir, 'mcp.json'), 'utf-8')) as Record<
+    string,
+    unknown
+  >;
+}
+
+describe('global MCP configuration (persisted user entries)', () => {
+  it('lists only user-global servers when project config also exists', async () => {
+    const homeDir = await makeTempDir();
+    const projectDir = await makeTempDir();
+    await writeMcpConfig(homeDir, {
+      mcpServers: { global: { command: 'global-command' } },
+    });
+    await writeFile(
+      join(projectDir, '.mcp.json'),
+      JSON.stringify({ mcpServers: { project: { command: 'project-command' } } }),
+      'utf-8',
+    );
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await expect(harness.listMcpServers()).resolves.toEqual([
+        { name: 'global', transport: 'stdio', command: 'global-command' },
+      ]);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('preserves unrelated file content when a server is added', async () => {
+    const homeDir = await makeTempDir();
+    await writeMcpConfig(homeDir, {
+      custom: { keep: true },
+      mcpServers: { existing: { command: 'existing-command' } },
+    });
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await harness.addMcpServer({
+        name: 'added',
+        transport: 'stdio',
+        command: 'added-command',
+      });
+
+      await expect(readMcpConfig(homeDir)).resolves.toEqual({
+        custom: { keep: true },
+        mcpServers: {
+          existing: { command: 'existing-command' },
+          added: { transport: 'stdio', command: 'added-command' },
+        },
+      });
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('replaces the named entry when an existing server is updated', async () => {
+    const homeDir = await makeTempDir();
+    await writeMcpConfig(homeDir, {
+      mcpServers: { docs: { command: 'old-command', args: ['old'] } },
+    });
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await harness.updateMcpServer({
+        name: 'docs',
+        transport: 'http',
+        url: 'https://example.test/mcp',
+        auth: 'oauth',
+      });
+
+      await expect(harness.listMcpServers()).resolves.toEqual([
+        {
+          name: 'docs',
+          transport: 'http',
+          url: 'https://example.test/mcp',
+          auth: 'oauth',
+        },
+      ]);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('removes only the named entry when a server is deleted', async () => {
+    const homeDir = await makeTempDir();
+    await writeMcpConfig(homeDir, {
+      mcpServers: {
+        remove: { command: 'remove-command' },
+        keep: { command: 'keep-command' },
+      },
+    });
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await harness.removeMcpServer('remove');
+
+      await expect(harness.listMcpServers()).resolves.toEqual([
+        { name: 'keep', transport: 'stdio', command: 'keep-command' },
+      ]);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('rejects a mutation when mcp.json is malformed without changing its bytes', async () => {
+    const homeDir = await makeTempDir();
+    const malformed = '{ not valid json';
+    await writeFile(join(homeDir, 'mcp.json'), malformed, 'utf-8');
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await expect(
+        harness.addMcpServer({
+          name: 'unsafe',
+          transport: 'stdio',
+          command: 'unsafe-command',
+        }),
+      ).rejects.toMatchObject({ code: 'config.invalid' });
+      await expect(readFile(join(homeDir, 'mcp.json'), 'utf-8')).resolves.toBe(malformed);
+    } finally {
+      await harness.close();
+    }
+  });
+});
+
+describe('standalone MCP check (connection result)', () => {
+  it('reports discovered tools when a stdio server connects', async () => {
+    const homeDir = await makeTempDir();
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await harness.addMcpServer({
+        name: 'working',
+        transport: 'stdio',
+        command: process.execPath,
+        args: [stdioFixture],
+      });
+
+      await expect(harness.testMcpServer('working')).resolves.toMatchObject({
+        success: true,
+        output: expect.stringContaining('Available tools: 3'),
+      });
+    } finally {
+      await harness.close();
+    }
+  }, 15_000);
+
+  it('returns a failed result when the stdio executable is missing', async () => {
+    const homeDir = await makeTempDir();
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await harness.addMcpServer({
+        name: 'missing',
+        transport: 'stdio',
+        command: '/definitely/not/a/real/mcp-executable',
+      });
+
+      const result = await harness.testMcpServer('missing');
+
+      expect(result.success).toBe(false);
+      expect(result.output).toMatch(/ENOENT|not found|spawn/i);
+    } finally {
+      await harness.close();
+    }
+  });
+});
+
+describe('MCP OAuth facade (host-controlled browser flow)', () => {
+  it('resets authorization for a configured remote server', async () => {
+    const homeDir = await makeTempDir();
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await harness.addMcpServer({
+        name: 'remote',
+        transport: 'http',
+        url: 'https://mcp.example.test/mcp',
+        auth: 'oauth',
+      });
+
+      await expect(harness.resetMcpServerAuth('remote')).resolves.toBeUndefined();
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('rejects authorization when the configured server uses stdio', async () => {
+    const homeDir = await makeTempDir();
+    const harness = createKimiHarness({ homeDir });
+
+    try {
+      await harness.addMcpServer({
+        name: 'local',
+        transport: 'stdio',
+        command: process.execPath,
+      });
+
+      await expect(
+        harness.authenticateMcpServer('local', { onAuthorizationUrl: () => undefined }),
+      ).rejects.toMatchObject({ code: 'request.invalid' });
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('completes the flow after the host receives the authorization URL', async () => {
+    const rpc = new OAuthRpc();
+    const harness = oauthHarness(rpc);
+    const urls: string[] = [];
+
+    try {
+      await harness.authenticateMcpServer('remote', {
+        onAuthorizationUrl: (url) => {
+          urls.push(url);
+        },
+      });
+
+      expect(urls).toEqual(['https://auth.example.test/authorize?state=test']);
+      expect(rpc.completedFlowIds).toEqual(['flow_test']);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('cancels the core flow when the host aborts OAuth authorization', async () => {
+    const rpc = new OAuthRpc();
+    const harness = oauthHarness(rpc);
+    const controller = new AbortController();
+
+    try {
+      await expect(
+        harness.authenticateMcpServer('remote', {
+          onAuthorizationUrl: () => {
+            controller.abort(new Error('OAuth authorization cancelled by user'));
+          },
+          signal: controller.signal,
+        }),
+      ).rejects.toThrow('OAuth authorization cancelled by user');
+      expect(rpc.cancelledFlowIds).toEqual(['flow_test']);
+    } finally {
+      await harness.close();
+    }
+  });
+});
+
+class OAuthRpc extends SDKRpcClientBase {
+  readonly completedFlowIds: string[] = [];
+  readonly cancelledFlowIds: string[] = [];
+
+  protected async getRpc(): Promise<never> {
+    throw new Error('not used');
+  }
+
+  override async beginGlobalMcpServerAuth() {
+    return {
+      status: 'authorization-required' as const,
+      flowId: 'flow_test',
+      authorizationUrl: 'https://auth.example.test/authorize?state=test',
+    };
+  }
+
+  override async completeGlobalMcpServerAuth(
+    input: { readonly flowId: string },
+    signal?: AbortSignal,
+  ): Promise<void> {
+    signal?.throwIfAborted();
+    this.completedFlowIds.push(input.flowId);
+  }
+
+  override async cancelGlobalMcpServerAuth(flowId: string): Promise<void> {
+    this.cancelledFlowIds.push(flowId);
+  }
+}
+
+function oauthHarness(rpc: OAuthRpc): KimiHarness {
+  return new KimiHarness(rpc, {
+    homeDir: '/tmp/kimi-sdk-mcp-oauth-home',
+    configPath: '/tmp/kimi-sdk-mcp-oauth-home/config.toml',
+    auth: {} as never,
+    telemetry: { track: () => undefined },
+    ensureConfigFile: async () => undefined,
+    onClose: async () => undefined,
+  });
+}
diff --git a/packages/node-sdk/test/session-context.test.ts b/packages/node-sdk/test/session-context.test.ts
new file mode 100644
index 000000000..503c416de
--- /dev/null
+++ b/packages/node-sdk/test/session-context.test.ts
@@ -0,0 +1,232 @@
+/**
+ * Scenario: host-managed context changes through the public Session API.
+ * Responsibilities: clear/import behavior, validation, status, and persisted resume.
+ * Wiring: real in-process core and filesystem storage; no model boundary is invoked.
+ * Run: pnpm exec vitest run packages/node-sdk/test/session-context.test.ts
+ */
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { createKimiHarness, type KimiError } from '#/index';
+
+import {
+  makeTempDir,
+  removeTempDirs,
+  waitForSDKEvent,
+} from './session-runtime-helpers';
+import { TEST_IDENTITY } from './test-identity';
+
+const tempDirs: string[] = [];
+const toPosix = (path: string): string => path.replaceAll('\\', '/');
+
+afterEach(async () => {
+  await removeTempDirs(tempDirs);
+});
+
+describe('Session context', () => {
+  it('restores a session-only additional directory after close and resume', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-additional-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-additional-work-');
+    const additionalDir = await makeTempDir(tempDirs, 'kimi-sdk-additional-dir-');
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_additional_resume', workDir });
+      await session.addAdditionalDir(additionalDir, { persist: false });
+      await session.close();
+
+      const resumed = await harness.resumeSession({ id: 'ses_additional_resume' });
+
+      expect(resumed.summary?.additionalDirs).toEqual([toPosix(additionalDir)]);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('clears context without replacing the session', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-context-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-context-work-');
+    const additionalDir = await makeTempDir(tempDirs, 'kimi-sdk-context-additional-');
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_context_clear', workDir });
+      await session.addAdditionalDir(additionalDir, { persist: false });
+      await expect(session.getContext()).resolves.toMatchObject({
+        history: [{ role: 'user' }],
+      });
+
+      await session.clearContext();
+
+      expect(session.id).toBe('ses_context_clear');
+      await expect(session.getContext()).resolves.toEqual({ history: [], tokenCount: 0 });
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('appends old-compatible user context markup when importing raw content', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-context-import-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-context-import-work-');
+    await writeTestConfig(homeDir, 200_000);
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_context_import', workDir });
+
+      await session.importContext('Earlier user: keep the API stable.', "file 'notes.md'");
+
+      expect(session.id).toBe('ses_context_import');
+      await expect(session.getContext()).resolves.toMatchObject({
+        history: [
+          {
+            role: 'user',
+            origin: { kind: 'user' },
+            content: [
+              {
+                type: 'text',
+                text:
+                  "<system>The user has imported context from file 'notes.md'. " +
+                  'This is a prior conversation history that may be relevant to the current session. ' +
+                  'Please review this context and use it to inform your responses.</system>',
+              },
+              {
+                type: 'text',
+                text:
+                  '<imported_context source="file \'notes.md\'">\n' +
+                  'Earlier user: keep the API stable.\n' +
+                  '</imported_context>',
+              },
+            ],
+          },
+        ],
+        tokenCount: expect.any(Number),
+      });
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('emits the estimated context token status after an import', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-context-status-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-context-status-work-');
+    await writeTestConfig(homeDir, 200_000);
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_context_status', workDir });
+      const status = waitForSDKEvent(
+        session,
+        (event) =>
+          event.type === 'agent.status.updated' && (event.contextTokens ?? 0) > 0,
+      );
+
+      await session.importContext('Prior context.', "file 'status.md'");
+
+      await expect(status).resolves.toMatchObject({
+        type: 'agent.status.updated',
+        maxContextTokens: 200_000,
+        contextTokens: expect.any(Number),
+      });
+      const context = await session.getContext();
+      expect(context.tokenCount).toBeGreaterThan(0);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('restores the imported message with its estimated token count after resume', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-context-resume-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-context-resume-work-');
+    await writeTestConfig(homeDir, 200_000);
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_context_resume', workDir });
+      await session.importContext('A decision from the previous session.', "session 'old-session'");
+      const imported = await session.getContext();
+      await session.close();
+
+      const resumed = await harness.resumeSession({ id: 'ses_context_resume' });
+
+      await expect(resumed.getContext()).resolves.toEqual(imported);
+      expect(resumed.getResumeState()?.agents['main']?.replay).toContainEqual(
+        expect.objectContaining({
+          type: 'message',
+          message: imported.history[0],
+        }),
+      );
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('rejects whitespace-only imported content without mutating context', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-context-empty-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-context-empty-work-');
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_context_empty', workDir });
+
+      await expect(session.importContext(' \n\t ', "file 'empty.md'")).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'request.invalid',
+        details: { reason: 'import_content_empty' },
+      } satisfies Partial<KimiError>);
+      await expect(session.getContext()).resolves.toEqual({ history: [], tokenCount: 0 });
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('rejects an import that would push existing context beyond the model limit', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-context-overflow-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-context-overflow-work-');
+    await writeTestConfig(homeDir, 100);
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const session = await harness.createSession({ id: 'ses_context_overflow', workDir });
+      await session.importContext('First import.', "file 'first.md'");
+      const contextBeforeRejectedImport = await session.getContext();
+
+      await expect(
+        session.importContext('Second import.', "file 'second.md'"),
+      ).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'context.overflow',
+        details: {
+          reason: 'import_context_overflow',
+          currentTokenCount: expect.any(Number),
+          maxContextTokens: 100,
+        },
+      } satisfies Partial<KimiError>);
+      await expect(session.getContext()).resolves.toEqual(contextBeforeRejectedImport);
+    } finally {
+      await harness.close();
+    }
+  });
+});
+
+async function writeTestConfig(homeDir: string, maxContextSize: number): Promise<void> {
+  await writeFile(
+    join(homeDir, 'config.toml'),
+    `
+default_model = "test-model"
+
+[providers.local]
+type = "openai"
+base_url = "https://example.test/v1"
+api_key = "YOUR_API_KEY"
+
+[models.test-model]
+provider = "local"
+model = "test-model"
+max_context_size = ${String(maxContextSize)}
+`,
+    'utf-8',
+  );
+}
diff --git a/packages/node-sdk/test/session-event-types.test.ts b/packages/node-sdk/test/session-event-types.test.ts
index b30558189..dabddd251 100644
--- a/packages/node-sdk/test/session-event-types.test.ts
+++ b/packages/node-sdk/test/session-event-types.test.ts
@@ -70,6 +70,7 @@ describe('Event public types', () => {
         case 'session.meta.updated':
         case 'event.session.created':
         case 'event.session.status_changed':
+        case 'event.session.work_changed':
         case 'event.workspace.created':
         case 'event.workspace.updated':
         case 'event.workspace.deleted':
diff --git a/packages/node-sdk/test/session-goal.test.ts b/packages/node-sdk/test/session-goal.test.ts
index 99a83db72..01b7656c8 100644
--- a/packages/node-sdk/test/session-goal.test.ts
+++ b/packages/node-sdk/test/session-goal.test.ts
@@ -67,4 +67,12 @@ describe('Session goal methods', () => {
     expect((session as unknown as { clearGoal?: unknown }).clearGoal).toBeUndefined();
     expect((session as unknown as { updateGoal?: unknown }).updateGoal).toBeUndefined();
   });
+
+  it('keeps the goal metadata key reserved for lifecycle methods', async () => {
+    const { session } = makeSession();
+
+    await expect(
+      session.updateMetadata({ goal: { status: 'complete' } }),
+    ).rejects.toMatchObject({ code: 'goal.metadata_reserved' });
+  });
 });
diff --git a/packages/node-sdk/test/session-prompt-events.test.ts b/packages/node-sdk/test/session-prompt-events.test.ts
index 6845ee6bc..da1241431 100644
--- a/packages/node-sdk/test/session-prompt-events.test.ts
+++ b/packages/node-sdk/test/session-prompt-events.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: prompt-driven session behavior, including historical-turn forks.
+ * Responsibilities: public SDK events, persisted replay, metadata, and input errors.
+ * Wiring: real in-process core/storage with only the remote model provider stubbed.
+ * Run: pnpm exec vitest run packages/node-sdk/test/session-prompt-events.test.ts
+ */
 import { existsSync } from 'node:fs';
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -94,6 +100,38 @@ async function removeTempDir(dir: string): Promise<void> {
 }
 
 describe('Session.prompt events', () => {
+  it('preserves existing custom metadata when an SDK metadata patch is resumed', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const session = await harness.createSession({
+        id: 'ses_update_metadata',
+        workDir,
+        metadata: { source: 'vscode' },
+      });
+      await session.createGoal({ objective: 'Keep core-owned metadata' });
+      await session.updateMetadata({
+        vscode_legacy_approval: { yolo: true, afk: false },
+      });
+      await session.close();
+
+      const resumed = await harness.resumeSession({ id: session.id });
+
+      expect(resumed.summary?.metadata).toEqual({
+        source: 'vscode',
+        vscode_legacy_approval: { yolo: true, afk: false },
+      });
+      await expect(resumed.getGoal()).resolves.toMatchObject({
+        goal: { objective: 'Keep core-owned metadata' },
+      });
+    } finally {
+      await harness.close();
+    }
+  });
+
   it('persists sanitized prompt metadata without marking the title custom', async () => {
     const homeDir = await makeTempDir();
     const workDir = await makeTempDir();
@@ -309,6 +347,41 @@ describe('Session.prompt events', () => {
     }
   });
 
+  it('includes persisted subagent replay only when resume explicitly requests it', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const session = await harness.createSession({ id: 'ses_subagent_replay', workDir });
+      const events: Event[] = [];
+      const unsubscribe = session.onEvent((event) => events.push(event));
+      await session.init();
+      unsubscribe();
+      const spawned = events.find((event) => event.type === 'subagent.spawned');
+      if (spawned?.type !== 'subagent.spawned') throw new Error('Expected persisted subagent');
+      await session.close();
+
+      const defaultResume = await harness.resumeSession({ id: session.id });
+      expect(defaultResume.getResumeState()?.agents).not.toHaveProperty(spawned.subagentId);
+      await defaultResume.close();
+
+      const fullResume = await harness.resumeSession({
+        id: session.id,
+        includeSubagents: true,
+      });
+      expect(fullResume.getResumeState()?.agents[spawned.subagentId]?.replay).toContainEqual(
+        expect.objectContaining({
+          type: 'message',
+          message: expect.objectContaining({ role: 'assistant' }),
+        }),
+      );
+    } finally {
+      await harness.close();
+    }
+  });
+
   it('starts btw through RPC as a forked subagent without prompt metadata updates', async () => {
     const homeDir = await makeTempDir();
     const workDir = await makeTempDir();
@@ -391,6 +464,199 @@ describe('Session.prompt events', () => {
     }
   });
 
+  it('persists only conversation through the selected turn across resume', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const source = await harness.createSession({ id: 'ses_turn_fork_source', workDir });
+      await runPrompt(source, 'first question', 'first answer');
+      await runPrompt(source, 'second question', 'second answer');
+      await runPrompt(source, 'third question', 'third answer');
+
+      const fork = await harness.forkSession({
+        id: source.id,
+        forkId: 'ses_turn_fork_child',
+        turnIndex: 1,
+      });
+      await fork.close();
+      const resumed = await harness.resumeSession({ id: fork.id });
+      const replayText = visibleReplayText(resumed.getResumeState()?.agents['main']?.replay ?? []);
+
+      expect(replayText).toEqual([
+        'user:first question',
+        'assistant:first answer',
+        'user:second question',
+        'assistant:second answer',
+      ]);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('returns the requested identity for a historical fork', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const source = await harness.createSession({
+        id: 'ses_turn_fork_metadata_source',
+        workDir,
+        metadata: { source: 'vscode' },
+      });
+      await runPrompt(source, 'branch here', 'kept answer');
+      await runPrompt(source, 'future prompt', 'discarded answer');
+
+      const fork = await harness.forkSession({
+        id: source.id,
+        forkId: 'ses_turn_fork_metadata_child',
+        title: 'Historical branch',
+        metadata: { branch: 'historical' },
+        turnIndex: 0,
+      });
+      const state = fork.getResumeState();
+
+      expect(fork.id).toBe('ses_turn_fork_metadata_child');
+      expect(fork.workDir).toBe(source.workDir);
+      expect(state?.sessionMetadata.forkedFrom).toBe(source.id);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('derives historical fork metadata from the selected turn', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const source = await harness.createSession({
+        id: 'ses_turn_fork_state_source',
+        workDir,
+        metadata: { source: 'vscode' },
+      });
+      await runPrompt(source, 'branch here', 'kept answer');
+      await runPrompt(source, 'future prompt', 'discarded answer');
+
+      const fork = await harness.forkSession({
+        id: source.id,
+        forkId: 'ses_turn_fork_state_child',
+        title: 'Historical branch',
+        metadata: { branch: 'historical' },
+        turnIndex: 0,
+      });
+
+      expect(fork.summary).toMatchObject({
+        title: 'Historical branch',
+        lastPrompt: 'branch here',
+        metadata: { source: 'vscode', branch: 'historical' },
+      });
+      expect(fork.getResumeState()?.sessionMetadata).toMatchObject({
+        title: 'Historical branch',
+        lastPrompt: 'branch here',
+        custom: { source: 'vscode', branch: 'historical' },
+      });
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('continues with the next turn id after a historical fork', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const source = await harness.createSession({ id: 'ses_turn_fork_id_source', workDir });
+      await runPrompt(source, 'kept prompt', 'kept answer');
+      await runPrompt(source, 'future prompt', 'future answer');
+      const fork = await harness.forkSession({ id: source.id, turnIndex: 0 });
+      const started = waitForEvent(fork, (event) => event.type === 'turn.started');
+      const ended = waitForEvent(fork, (event) => event.type === 'turn.ended');
+
+      await fork.prompt('branch continuation');
+
+      await expect(started).resolves.toMatchObject({ type: 'turn.started', turnId: 1 });
+      await ended;
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('omits subagents created after the selected historical turn', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const source = await harness.createSession({ id: 'ses_turn_fork_agents_source', workDir });
+      await runPrompt(source, 'kept prompt', 'kept answer');
+      await runPrompt(source, 'future prompt', 'future answer');
+      await source.init();
+
+      const fork = await harness.forkSession({ id: source.id, turnIndex: 0 });
+
+      expect(Object.keys(fork.getResumeState()?.sessionMetadata.agents ?? {})).toEqual(['main']);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('rejects a negative historical turn index with request.invalid', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      const source = await harness.createSession({ id: 'ses_turn_fork_negative', workDir });
+
+      await expect(
+        harness.forkSession({ id: source.id, turnIndex: -1 }),
+      ).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'request.invalid',
+      });
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('rejects an out-of-range historical turn without creating the fork', async () => {
+    const homeDir = await makeTempDir();
+    const workDir = await makeTempDir();
+    const harness = createKimiHarness({ identity: TEST_IDENTITY, homeDir });
+
+    try {
+      await configureFakeProvider(harness);
+      const source = await harness.createSession({ id: 'ses_turn_fork_range_source', workDir });
+      await runPrompt(source, 'only question', 'only answer');
+
+      await expect(
+        harness.forkSession({
+          id: source.id,
+          forkId: 'ses_turn_fork_range_child',
+          turnIndex: 1,
+        }),
+      ).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'request.invalid',
+        details: { turnIndex: 1, availableTurns: 1 },
+      });
+      await expect(
+        harness.listSessions({ sessionId: 'ses_turn_fork_range_child' }),
+      ).resolves.toEqual([]);
+    } finally {
+      await harness.close();
+    }
+  });
+
   it('rejects empty prompt input', async () => {
     const homeDir = await makeTempDir();
     const workDir = await makeTempDir();
@@ -411,6 +677,42 @@ describe('Session.prompt events', () => {
   });
 });
 
+async function runPrompt(
+  session: Parameters<typeof waitForEvent>[0] & { prompt(input: string): Promise<void> },
+  input: string,
+  response: string,
+): Promise<void> {
+  fakeProviderState.responseText = response;
+  const done = waitForEvent(session, (event) => event.type === 'turn.ended');
+  await session.prompt(input);
+  await done;
+}
+
+function visibleReplayText(
+  records: readonly {
+    readonly type: string;
+    readonly message?: {
+      readonly role: string;
+      readonly content: ReadonlyArray<{ readonly type: string; readonly text?: string }>;
+      readonly origin?: { readonly kind: string };
+    };
+  }[],
+): readonly string[] {
+  const entries: string[] = [];
+  for (const record of records) {
+    if (record.type !== 'message' || record.message === undefined) continue;
+    const { message } = record;
+    if (message.role === 'user' && message.origin?.kind !== 'user') continue;
+    if (message.role !== 'user' && message.role !== 'assistant') continue;
+    const text = message.content
+      .filter((part) => part.type === 'text')
+      .map((part) => part.text ?? '')
+      .join('');
+    entries.push(`${message.role}:${text}`);
+  }
+  return entries;
+}
+
 async function configureFakeProvider(harness: KimiHarness): Promise<void> {
   await harness.setConfig({
     providers: {
diff --git a/packages/node-sdk/test/session-skills.test.ts b/packages/node-sdk/test/session-skills.test.ts
index 49e8e355c..4d6f4051a 100644
--- a/packages/node-sdk/test/session-skills.test.ts
+++ b/packages/node-sdk/test/session-skills.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: public SDK skill discovery and activation.
+ * Responsibilities: list workspace/session skills and activate a session skill through KimiHarness.
+ * Wiring: the in-process core and filesystem are real; only the remote model provider is stubbed.
+ * Run: pnpm exec vitest run packages/node-sdk/test/session-skills.test.ts
+ */
 import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
@@ -298,6 +304,65 @@ describe('Session skills', () => {
   });
 });
 
+describe('KimiHarness workspace skills', () => {
+  it('returns project skills when no session exists', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-workspace-skills-home-');
+    const workDir = await makeTempDir(tempDirs, 'kimi-sdk-workspace-skills-work-');
+    await writeSkill(workDir, 'workspace-review', [
+      '---',
+      'name: workspace-review',
+      'description: Review workspace changes',
+      '---',
+      '',
+      'Inspect every changed file.',
+    ]);
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      const skills = await harness.listWorkspaceSkills(workDir);
+
+      expect(skills.find((skill) => skill.name === 'workspace-review')).toMatchObject({
+        name: 'workspace-review',
+        description: 'Review workspace changes',
+        source: 'project',
+      });
+      expect(harness.sessions.size).toBe(0);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('preserves the core error when workDir is empty', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-workspace-skills-home-');
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      await expect(harness.listWorkspaceSkills('   ')).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'request.work_dir_required',
+        message: 'listWorkspaceSkills requires workDir',
+      } satisfies Partial<KimiError>);
+    } finally {
+      await harness.close();
+    }
+  });
+
+  it('preserves the core error when workDir is not a string', async () => {
+    const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-workspace-skills-home-');
+    const harness = createKimiHarness({ homeDir, identity: TEST_IDENTITY });
+
+    try {
+      await expect(harness.listWorkspaceSkills(null as never)).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'request.work_dir_required',
+        message: 'listWorkspaceSkills requires workDir',
+      } satisfies Partial<KimiError>);
+    } finally {
+      await harness.close();
+    }
+  });
+});
+
 async function writeSkill(workDir: string, name: string, lines: readonly string[]): Promise<void> {
   const dir = join(workDir, '.kimi-code', 'skills', name);
   await mkdir(dir, { recursive: true });
diff --git a/packages/protocol/src/__tests__/envelope.test.ts b/packages/protocol/src/__tests__/envelope.test.ts
index ba4135092..cc72a134b 100644
--- a/packages/protocol/src/__tests__/envelope.test.ts
+++ b/packages/protocol/src/__tests__/envelope.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Scenario: protocol success/error envelopes and canonical error codes.
+ * Responsibilities: verify schema round-trips, stable numeric codes, and reason labels.
+ * Wiring: pure protocol schemas and constructors; no external boundaries.
+ * Run: `pnpm --filter @moonshot-ai/protocol exec vitest run src/__tests__/envelope.test.ts`.
+ */
 import { describe, expect, it } from 'vitest';
 import { z } from 'zod';
 
@@ -78,6 +84,7 @@ describe('error-codes', () => {
     expect(ErrorCode.SUCCESS).toBe(0);
     expect(ErrorCode.VALIDATION_FAILED).toBe(40001);
     expect(ErrorCode.SESSION_NOT_FOUND).toBe(40401);
+    expect(ErrorCode.GOAL_UNSUPPORTED_AGENT).toBe(40920);
     expect(ErrorCode.APPROVAL_EXPIRED).toBe(41001);
     expect(ErrorCode.FS_WATCH_LIMIT_EXCEEDED).toBe(42902);
     expect(ErrorCode.INTERNAL_ERROR).toBe(50001);
@@ -90,6 +97,7 @@ describe('error-codes', () => {
     expect(ErrorCodeReason[ErrorCode.MODEL_NOT_FOUND]).toBe('model.not_found');
     expect(ErrorCodeReason[ErrorCode.VALIDATION_FAILED]).toBe('validation.failed');
     expect(ErrorCodeReason[ErrorCode.FS_WATCH_LIMIT_EXCEEDED]).toBe('fs.watch_limit_exceeded');
+    expect(ErrorCodeReason[ErrorCode.GOAL_UNSUPPORTED_AGENT]).toBe('goal.unsupported_agent');
   });
 
   it('reserved codes are not redefined (40101, 50002 absent)', () => {
diff --git a/packages/protocol/src/__tests__/events.test.ts b/packages/protocol/src/__tests__/events.test.ts
index 365fd7b9e..b4ca42de8 100644
--- a/packages/protocol/src/__tests__/events.test.ts
+++ b/packages/protocol/src/__tests__/events.test.ts
@@ -154,7 +154,7 @@ describe('events / display re-exports', () => {
         title: 'Created session',
         created_at: '2026-06-11T00:00:00.000Z',
         updated_at: '2026-06-11T00:00:00.000Z',
-        status: 'idle',
+        busy: false,
         metadata: { cwd: '/tmp/project' },
         agent_config: { model: 'kimi-k2' },
         usage: {
@@ -182,8 +182,6 @@ describe('events / display re-exports', () => {
       id: 'wd_project_123456abcdef',
       root: '/tmp/project',
       name: 'project',
-      is_git_repo: true,
-      branch: 'main',
       created_at: '2026-06-11T00:00:00.000Z',
       last_opened_at: '2026-06-11T00:00:00.000Z',
       session_count: 1,
@@ -232,6 +230,23 @@ describe('events / display re-exports', () => {
     expect((parsed as { current_prompt_id: string }).current_prompt_id).toBe('prompt_1');
   });
 
+  it('validates orthogonal session work facts for unsubscribed clients', () => {
+    const parsed = eventSchema.parse({
+      type: 'event.session.work_changed',
+      agentId: 'main',
+      sessionId: 'sess_1',
+      busy: true,
+      main_turn_active: false,
+      pending_interaction: 'question',
+      last_turn_reason: 'completed',
+    });
+
+    expect(parsed).toMatchObject({
+      main_turn_active: false,
+      pending_interaction: 'question',
+    });
+  });
+
   it('rejects event.session.status_changed with invalid status', () => {
     expect(
       eventSchema.safeParse({
diff --git a/packages/protocol/src/__tests__/rest-fs-browse.test.ts b/packages/protocol/src/__tests__/rest-fs-browse.test.ts
index 33e71a857..0a0124a0c 100644
--- a/packages/protocol/src/__tests__/rest-fs-browse.test.ts
+++ b/packages/protocol/src/__tests__/rest-fs-browse.test.ts
@@ -24,23 +24,11 @@ describe('fsBrowseQuerySchema', () => {
 });
 
 describe('fsBrowseEntrySchema', () => {
-  it('round-trips a non-git dir entry without branch', () => {
+  it('round-trips a dir entry', () => {
     const entry = {
       name: 'src',
       path: '/Users/foo/code/src',
       is_dir: true as const,
-      is_git_repo: false,
-    };
-    expect(fsBrowseEntrySchema.parse(entry)).toEqual(entry);
-  });
-
-  it('round-trips a git dir entry with branch', () => {
-    const entry = {
-      name: 'kimi-code',
-      path: '/Users/foo/code/kimi-code',
-      is_dir: true as const,
-      is_git_repo: true,
-      branch: 'main',
     };
     expect(fsBrowseEntrySchema.parse(entry)).toEqual(entry);
   });
@@ -50,7 +38,6 @@ describe('fsBrowseEntrySchema', () => {
       name: 'README.md',
       path: '/Users/foo/code/README.md',
       is_dir: false,
-      is_git_repo: false,
     };
     expect(fsBrowseEntrySchema.safeParse(bad).success).toBe(false);
   });
@@ -66,8 +53,6 @@ describe('fsBrowseResponseSchema', () => {
           name: 'kimi-code',
           path: '/Users/foo/code/kimi-code',
           is_dir: true as const,
-          is_git_repo: true,
-          branch: 'main',
         },
       ],
     };
diff --git a/packages/protocol/src/__tests__/rest-session.test.ts b/packages/protocol/src/__tests__/rest-session.test.ts
index 6e5f9612d..721b59650 100644
--- a/packages/protocol/src/__tests__/rest-session.test.ts
+++ b/packages/protocol/src/__tests__/rest-session.test.ts
@@ -119,12 +119,12 @@ describe('listSessionsQuerySchema', () => {
     expect(listSessionsQuerySchema.safeParse({ page_size: 101 }).success).toBe(false);
   });
 
-  it('accepts a status filter', () => {
-    expect(listSessionsQuerySchema.parse({ status: 'idle' })).toEqual({ status: 'idle' });
+  it('accepts a busy filter', () => {
+    expect(listSessionsQuerySchema.parse({ busy: true })).toEqual({ busy: true });
   });
 
-  it('rejects an unknown status value', () => {
-    expect(listSessionsQuerySchema.safeParse({ status: 'frozen' }).success).toBe(false);
+  it('rejects a non-boolean busy value', () => {
+    expect(listSessionsQuerySchema.safeParse({ busy: 'frozen' }).success).toBe(false);
   });
 
   it('parses include_archive string values to boolean', () => {
@@ -179,7 +179,7 @@ describe('getSessionProfileResponseSchema', () => {
       title: 'Profile',
       created_at: '2026-01-01T00:00:00.000Z',
       updated_at: '2026-01-01T00:00:00.000Z',
-      status: 'idle',
+      busy: true,
       metadata: { cwd: '/tmp/foo' },
       agent_config: { model: '' },
       usage: {
@@ -271,7 +271,7 @@ describe('forkSessionResponseSchema', () => {
       title: 'Fork: source',
       created_at: '2026-01-01T00:00:00.000Z',
       updated_at: '2026-01-01T00:00:00.000Z',
-      status: 'idle',
+      busy: true,
       metadata: { cwd: '/tmp/foo', origin: 'web' },
       agent_config: { model: '' },
       usage: {
@@ -317,7 +317,7 @@ describe('createSessionChildResponseSchema', () => {
       title: 'Child: source',
       created_at: '2026-01-01T00:00:00.000Z',
       updated_at: '2026-01-01T00:00:00.000Z',
-      status: 'idle',
+      busy: true,
       metadata: { cwd: '/tmp/foo', parent_session_id: 'sess_parent' },
       agent_config: { model: '' },
       usage: {
@@ -348,7 +348,7 @@ describe('listSessionChildrenResponseSchema', () => {
           title: 'Child: source',
           created_at: '2026-01-01T00:00:00.000Z',
           updated_at: '2026-01-01T00:00:00.000Z',
-          status: 'idle',
+          busy: true,
           metadata: { cwd: '/tmp/foo', parent_session_id: 'sess_parent' },
           agent_config: { model: '' },
           usage: {
@@ -375,7 +375,7 @@ describe('listSessionChildrenResponseSchema', () => {
 describe('sessionStatusResponseSchema', () => {
   it('accepts a full valid shape', () => {
     const parsed = sessionStatusResponseSchema.parse({
-      status: 'running',
+      busy: true,
       model: 'moonshot-v1-128k',
       thinking_level: 'on',
       permission: 'ask',
@@ -385,7 +385,7 @@ describe('sessionStatusResponseSchema', () => {
       max_context_tokens: 128000,
       context_usage: 0.008,
     });
-    expect(parsed.status).toBe('running');
+    expect(parsed.busy).toBe(true);
     expect(parsed.model).toBe('moonshot-v1-128k');
     expect(parsed.plan_mode).toBe(true);
     expect(parsed.context_usage).toBe(0.008);
@@ -393,7 +393,7 @@ describe('sessionStatusResponseSchema', () => {
 
   it('accepts minimal shape without model', () => {
     const parsed = sessionStatusResponseSchema.parse({
-      status: 'idle',
+      busy: false,
       thinking_level: 'off',
       permission: 'auto',
       plan_mode: false,
@@ -402,11 +402,11 @@ describe('sessionStatusResponseSchema', () => {
       max_context_tokens: 0,
       context_usage: 0,
     });
-    expect(parsed.status).toBe('idle');
+    expect(parsed.busy).toBe(false);
     expect(parsed.model).toBeUndefined();
   });
 
-  it('rejects missing status', () => {
+  it('rejects missing busy', () => {
     expect(
       sessionStatusResponseSchema.safeParse({
         thinking_level: 'off',
@@ -420,10 +420,10 @@ describe('sessionStatusResponseSchema', () => {
     ).toBe(false);
   });
 
-  it('rejects invalid status', () => {
+  it('rejects invalid busy', () => {
     expect(
       sessionStatusResponseSchema.safeParse({
-        status: 'unknown',
+        busy: 'unknown',
         thinking_level: 'off',
         permission: 'auto',
         plan_mode: false,
@@ -438,7 +438,7 @@ describe('sessionStatusResponseSchema', () => {
   it('rejects negative context_tokens', () => {
     expect(
       sessionStatusResponseSchema.safeParse({
-        status: 'idle',
+        busy: true,
         thinking_level: 'off',
         permission: 'auto',
         plan_mode: false,
@@ -453,7 +453,7 @@ describe('sessionStatusResponseSchema', () => {
   it('rejects context_usage > 1', () => {
     expect(
       sessionStatusResponseSchema.safeParse({
-        status: 'idle',
+        busy: true,
         thinking_level: 'off',
         permission: 'auto',
         plan_mode: false,
@@ -526,7 +526,7 @@ describe('undoSessionResponseSchema', () => {
         has_more: false,
       },
       status: {
-        status: 'idle',
+        busy: true,
         model: 'kimi-k2',
         thinking_level: 'auto',
         permission: 'manual',
@@ -560,7 +560,7 @@ describe('restoreSessionResponseSchema', () => {
       title: 'Restored',
       created_at: '2026-01-01T00:00:00.000Z',
       updated_at: '2026-01-01T00:00:00.000Z',
-      status: 'idle',
+      busy: true,
       archived: false,
       metadata: { cwd: '/tmp/foo' },
       agent_config: { model: '' },
diff --git a/packages/protocol/src/__tests__/rest-workspace.test.ts b/packages/protocol/src/__tests__/rest-workspace.test.ts
index 6f53ea141..47a17c467 100644
--- a/packages/protocol/src/__tests__/rest-workspace.test.ts
+++ b/packages/protocol/src/__tests__/rest-workspace.test.ts
@@ -13,8 +13,6 @@ const sampleWorkspace: Workspace = {
   id: 'wd_kimi-code_0123456789ab',
   root: '/Users/foo/code/kimi-code',
   name: 'kimi-code',
-  is_git_repo: true,
-  branch: 'main',
   created_at: '2026-06-08T09:00:00.000Z',
   last_opened_at: '2026-06-08T09:30:00.000Z',
   session_count: 3,
@@ -49,11 +47,6 @@ describe('workspaceSchema', () => {
     expect(workspaceSchema.parse(sampleWorkspace)).toEqual(sampleWorkspace);
   });
 
-  it('accepts branch=null (detached HEAD / no git)', () => {
-    const detached = { ...sampleWorkspace, is_git_repo: true, branch: null };
-    expect(workspaceSchema.parse(detached).branch).toBeNull();
-  });
-
   it('rejects name longer than 100 chars', () => {
     const tooLong = { ...sampleWorkspace, name: 'x'.repeat(101) };
     expect(workspaceSchema.safeParse(tooLong).success).toBe(false);
diff --git a/packages/protocol/src/__tests__/session.test.ts b/packages/protocol/src/__tests__/session.test.ts
index 2420c5ed5..ef78b8f4b 100644
--- a/packages/protocol/src/__tests__/session.test.ts
+++ b/packages/protocol/src/__tests__/session.test.ts
@@ -5,25 +5,11 @@ import {
   permissionRuleSchema,
   sessionCreateSchema,
   sessionSchema,
-  sessionStatusSchema,
   sessionUpdateSchema,
   sessionUsageSchema,
   type Session,
 } from '../session';
 
-describe('sessionStatusSchema', () => {
-  it.each(['idle', 'running', 'awaiting_approval', 'awaiting_question', 'aborted'] as const)(
-    'accepts %s',
-    (status) => {
-      expect(sessionStatusSchema.parse(status)).toBe(status);
-    },
-  );
-
-  it('rejects unknown status', () => {
-    expect(sessionStatusSchema.safeParse('chilling').success).toBe(false);
-  });
-});
-
 describe('sessionUsageSchema + emptySessionUsage', () => {
   it('emptySessionUsage is parseable as zero usage', () => {
     const parsed = sessionUsageSchema.parse(emptySessionUsage());
@@ -65,7 +51,9 @@ describe('sessionSchema', () => {
     title: 'Test session',
     created_at: '2026-06-04T10:30:00.000Z',
     updated_at: '2026-06-04T10:35:00.000Z',
-    status: 'idle',
+    busy: true,
+    main_turn_active: true,
+    pending_interaction: 'approval',
     archived: false,
     metadata: { cwd: '/tmp/test' },
     agent_config: { model: 'moonshot-v1-128k' },
diff --git a/packages/protocol/src/__tests__/snapshot.test.ts b/packages/protocol/src/__tests__/snapshot.test.ts
index 30e752aab..91baee620 100644
--- a/packages/protocol/src/__tests__/snapshot.test.ts
+++ b/packages/protocol/src/__tests__/snapshot.test.ts
@@ -14,7 +14,7 @@ const SESSION = {
   title: 'demo',
   created_at: TS,
   updated_at: TS,
-  status: 'running',
+  busy: true,
   metadata: { cwd: '/tmp/demo' },
   agent_config: { model: 'kimi' },
   usage: {
diff --git a/packages/protocol/src/error-codes.ts b/packages/protocol/src/error-codes.ts
index 9205830f1..9c4eaccce 100644
--- a/packages/protocol/src/error-codes.ts
+++ b/packages/protocol/src/error-codes.ts
@@ -97,6 +97,8 @@ export const ErrorCode = {
   GOAL_OBJECTIVE_TOO_LONG: 40918,
   /** fs.mkdir 目标路径已存在（文件或目录） */
   FS_ALREADY_EXISTS: 40919,
+  /** goal 只允许主 agent 使用 */
+  GOAL_UNSUPPORTED_AGENT: 40920,
 
   /** approval 60s 超时 */
   APPROVAL_EXPIRED: 41001,
@@ -191,6 +193,7 @@ export const ErrorCodeReason: Readonly<Record<ErrorCode, string>> = {
   [ErrorCode.GOAL_OBJECTIVE_EMPTY]: 'goal.objective_empty',
   [ErrorCode.GOAL_OBJECTIVE_TOO_LONG]: 'goal.objective_too_long',
   [ErrorCode.FS_ALREADY_EXISTS]: 'fs.already_exists',
+  [ErrorCode.GOAL_UNSUPPORTED_AGENT]: 'goal.unsupported_agent',
 
   [ErrorCode.APPROVAL_EXPIRED]: 'approval.expired',
   [ErrorCode.QUESTION_EXPIRED]: 'question.expired',
diff --git a/packages/protocol/src/events.ts b/packages/protocol/src/events.ts
index 4091443fd..3b2eceaaf 100644
--- a/packages/protocol/src/events.ts
+++ b/packages/protocol/src/events.ts
@@ -2,7 +2,12 @@ import { z } from 'zod';
 
 import { ToolInputDisplaySchema, type ToolInputDisplay } from './display';
 import { messageContentSchema, type MessageContent } from './message';
-import { sessionSchema, sessionStatusSchema, type Session, type SessionStatus } from './session';
+import {
+  sessionPendingInteractionSchema,
+  sessionSchema,
+  type Session,
+  type SessionPendingInteraction,
+} from './session';
 import { isoDateTimeSchema } from './time';
 import { configResponseSchema, type ConfigResponse } from './rest/config';
 import {
@@ -231,12 +236,6 @@ export type KimiErrorCode =
   | 'session.question_handler_error'
   | 'session.init_failed'
   | 'agent.not_found'
-  | 'activity.agent_busy'
-  | 'activity.cancelling'
-  | 'activity.disposing'
-  | 'activity.disposed'
-  | 'activity.initializing'
-  | 'activity.session_rejected'
   | 'turn.agent_busy'
   | 'goal.already_exists'
   | 'goal.not_found'
@@ -245,6 +244,7 @@ export type KimiErrorCode =
   | 'goal.status_invalid'
   | 'goal.metadata_reserved'
   | 'goal.not_resumable'
+  | 'goal.unsupported_agent'
   | 'model.not_configured'
   | 'model.config_invalid'
   | 'profile.thinking_alias_conflict'
@@ -518,10 +518,27 @@ export interface WorkspaceDeletedEvent {
   readonly root: string;
 }
 
+export interface SessionWorkChangedEvent {
+  readonly type: 'event.session.work_changed';
+  readonly busy: boolean;
+  /** Main-agent turn liveness, excluding background and sub-agent work. */
+  readonly main_turn_active?: boolean;
+  /** Highest-priority pending interaction for clients without a session subscription. */
+  readonly pending_interaction?: SessionPendingInteraction;
+  /** Outcome of the MAIN agent's most recent turn, when one has ended since
+   *  activation (see `Session.last_turn_reason`). */
+  readonly last_turn_reason?: 'completed' | 'cancelled' | 'failed';
+}
+
+/**
+ * @deprecated Replaced by {@link SessionWorkChangedEvent}: awaiting states
+ * ride the approval/question channels and outcomes ride turn.ended. Kept so
+ * pre-change journals still parse during replay.
+ */
 export interface SessionStatusChangedEvent {
   readonly type: 'event.session.status_changed';
-  readonly status: SessionStatus;
-  readonly previous_status: SessionStatus;
+  readonly status: 'idle' | 'running' | 'awaiting_approval' | 'awaiting_question' | 'aborted';
+  readonly previous_status: 'idle' | 'running' | 'awaiting_approval' | 'awaiting_question' | 'aborted';
   readonly current_prompt_id?: string;
 }
 
@@ -876,6 +893,7 @@ export type AgentEvent =
   | WorkspaceCreatedEvent
   | WorkspaceUpdatedEvent
   | WorkspaceDeletedEvent
+  | SessionWorkChangedEvent
   | SessionStatusChangedEvent
   | ConfigChangedEvent
   | ModelCatalogChangedEvent
@@ -1134,12 +1152,6 @@ export const kimiErrorCodeSchema = z.enum([
   'session.question_handler_error',
   'session.init_failed',
   'agent.not_found',
-  'activity.agent_busy',
-  'activity.cancelling',
-  'activity.disposing',
-  'activity.disposed',
-  'activity.initializing',
-  'activity.session_rejected',
   'turn.agent_busy',
   'goal.already_exists',
   'goal.not_found',
@@ -1148,6 +1160,7 @@ export const kimiErrorCodeSchema = z.enum([
   'goal.status_invalid',
   'goal.metadata_reserved',
   'goal.not_resumable',
+  'goal.unsupported_agent',
   'model.not_configured',
   'model.config_invalid',
   'profile.thinking_alias_conflict',
@@ -1387,10 +1400,19 @@ export const workspaceDeletedEventSchema = z.object({
   root: z.string().min(1),
 }) satisfies z.ZodType<WorkspaceDeletedEvent>;
 
+export const sessionWorkChangedEventSchema = z.object({
+  type: z.literal('event.session.work_changed'),
+  busy: z.boolean(),
+  main_turn_active: z.boolean().optional(),
+  pending_interaction: sessionPendingInteractionSchema.optional(),
+  last_turn_reason: z.enum(['completed', 'cancelled', 'failed']).optional(),
+}) satisfies z.ZodType<SessionWorkChangedEvent>;
+
+/** @deprecated See {@link SessionStatusChangedEvent}. */
 export const sessionStatusChangedEventSchema = z.object({
   type: z.literal('event.session.status_changed'),
-  status: sessionStatusSchema,
-  previous_status: sessionStatusSchema,
+  status: z.enum(['idle', 'running', 'awaiting_approval', 'awaiting_question', 'aborted']),
+  previous_status: z.enum(['idle', 'running', 'awaiting_approval', 'awaiting_question', 'aborted']),
   current_prompt_id: z.string().min(1).optional(),
 }) satisfies z.ZodType<SessionStatusChangedEvent>;
 
@@ -1717,6 +1739,7 @@ export const agentEventSchema = z.discriminatedUnion('type', [
   workspaceCreatedEventSchema,
   workspaceUpdatedEventSchema,
   workspaceDeletedEventSchema,
+  sessionWorkChangedEventSchema,
   sessionStatusChangedEventSchema,
   modelCatalogChangedEventSchema,
   goalUpdatedEventSchema,
diff --git a/packages/protocol/src/rest/fsBrowse.ts b/packages/protocol/src/rest/fsBrowse.ts
index adae5ebfd..803c5c0cf 100644
--- a/packages/protocol/src/rest/fsBrowse.ts
+++ b/packages/protocol/src/rest/fsBrowse.ts
@@ -22,8 +22,6 @@ export const fsBrowseEntrySchema = z.object({
   name: z.string().min(1),
   path: z.string().min(1),
   is_dir: z.literal(true),
-  is_git_repo: z.boolean(),
-  branch: z.string().optional(),
 });
 export type FsBrowseEntry = z.infer<typeof fsBrowseEntrySchema>;
 
diff --git a/packages/protocol/src/rest/session.ts b/packages/protocol/src/rest/session.ts
index 14c82254a..25dabb6a4 100644
--- a/packages/protocol/src/rest/session.ts
+++ b/packages/protocol/src/rest/session.ts
@@ -8,7 +8,7 @@
  *   POST    /v1/sessions/{id}:btw         -                     data: StartBtwSession
  *   GET     /v1/sessions/{id}/children    query: ListSessions   data: Page<Session>
  *   POST    /v1/sessions/{id}/children    body: SessionChild    data: Session
- *   GET     /v1/sessions/{id}/status      -                     data: SessionStatus
+ *   GET     /v1/sessions/{id}/status      -                     data: SessionStatusResponse
  *   POST    /v1/sessions/{id}:compact     body: CompactSession  data: {}
  *   POST    /v1/sessions/{id}:undo        body: UndoSession     data: UndoSession
  *   POST    /v1/sessions/{id}:archive     -                     data: { archived: true }
@@ -25,7 +25,6 @@ import {
   sessionCreateSchema,
   sessionForkSchema,
   sessionSchema,
-  sessionStatusSchema,
   sessionUpdateSchema,
 } from '../session';
 
@@ -46,7 +45,7 @@ const booleanQueryParam = z.preprocess(
 
 export const listSessionsQuerySchema = cursorQuerySchema.and(
   z.object({
-    status: sessionStatusSchema.optional(),
+    busy: booleanQueryParam,
     include_archive: booleanQueryParam,
     archived_only: booleanQueryParam,
     exclude_empty: booleanQueryParam,
@@ -112,7 +111,7 @@ export type StartBtwSessionResponse = z.infer<typeof startBtwSessionResponseSche
 // does not filter by it, so advertising it would mislead generated clients.
 export const listSessionChildrenQuerySchema = cursorQuerySchema.and(
   z.object({
-    status: sessionStatusSchema.optional(),
+    busy: booleanQueryParam,
     include_archive: booleanQueryParam,
   }),
 );
@@ -128,7 +127,9 @@ export const createSessionChildResponseSchema = sessionSchema;
 export type CreateSessionChildResponse = z.infer<typeof createSessionChildResponseSchema>;
 
 export const sessionStatusResponseSchema = z.object({
-  status: sessionStatusSchema,
+  /** Any agent in the session holds an active turn. Replaces the derived
+   *  status enum; awaiting states ride the approval/question channels. */
+  busy: z.boolean(),
   model: z.string().optional(),
   thinking_level: z.string(),
   permission: z.string(),
diff --git a/packages/protocol/src/session.ts b/packages/protocol/src/session.ts
index ea8aff647..8d10164e8 100644
--- a/packages/protocol/src/session.ts
+++ b/packages/protocol/src/session.ts
@@ -7,16 +7,6 @@ import {
 import { isoDateTimeSchema } from './time';
 import { workspaceIdSchema } from './workspace';
 
-export const sessionStatusSchema = z.enum([
-  'idle',
-  'running',
-  'awaiting_approval',
-  'awaiting_question',
-  'aborted',
-]);
-
-export type SessionStatus = z.infer<typeof sessionStatusSchema>;
-
 export const sessionUsageSchema = z.object({
   input_tokens: z.number().int().nonnegative(),
   output_tokens: z.number().int().nonnegative(),
@@ -85,13 +75,32 @@ export const sessionMetadataSchema = z
 
 export type SessionMetadata = z.infer<typeof sessionMetadataSchema>;
 
+export const sessionPendingInteractionSchema = z.enum(['none', 'approval', 'question']);
+export type SessionPendingInteraction = z.infer<typeof sessionPendingInteractionSchema>;
+
 export const sessionSchema = z.object({
   id: z.string().min(1),
   workspace_id: workspaceIdSchema,
   title: z.string(),
   created_at: isoDateTimeSchema,
   updated_at: isoDateTimeSchema,
-  status: sessionStatusSchema,
+  /** Any agent in the session holds an active turn or background lease.
+   *  Replaces the derived five-value `status` enum: awaiting
+   *  states ride the approval/question channels, and turn outcomes ride
+   *  turn.ended — clients compose their own presentation from the facts. */
+  busy: z.boolean(),
+  /** Whether the MAIN agent currently owns an active turn. Unlike `busy`,
+   *  this excludes background tasks and sub-agent turns. Optional for wire
+   *  compatibility with older servers. */
+  main_turn_active: z.boolean().optional(),
+  /** Highest-priority pending human interaction, so list clients can restore
+   *  the pre-status attention badge without subscribing to every session. */
+  pending_interaction: sessionPendingInteractionSchema.optional(),
+  /** Outcome of the MAIN agent's most recent turn, when the session is live
+   *  and a turn has ended since activation. A fact, not a state: clients
+   *  decide how to present it (e.g. an "aborted" tag when `!busy` and the
+   *  reason is cancelled/failed). */
+  last_turn_reason: z.enum(['completed', 'cancelled', 'failed']).optional(),
   archived: z.boolean().optional(),
   current_prompt_id: z.string().min(1).optional(),
   /** Text of the most recent user prompt, for search/preview. Absent for empty sessions. */
diff --git a/packages/protocol/src/workspace.ts b/packages/protocol/src/workspace.ts
index b349a20c2..1a00f1875 100644
--- a/packages/protocol/src/workspace.ts
+++ b/packages/protocol/src/workspace.ts
@@ -14,8 +14,6 @@ export const workspaceSchema = z.object({
   id: workspaceIdSchema,
   root: z.string().min(1),
   name: z.string().min(1).max(100),
-  is_git_repo: z.boolean(),
-  branch: z.string().nullable(),
   created_at: isoDateTimeSchema,
   last_opened_at: isoDateTimeSchema,
   session_count: z.number().int().nonnegative(),
diff --git a/packages/server-e2e/.gitignore b/packages/server-e2e/.gitignore
deleted file mode 100644
index a9a1bd38a..000000000
--- a/packages/server-e2e/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-reports/
diff --git a/packages/server-e2e/AGENTS.md b/packages/server-e2e/AGENTS.md
deleted file mode 100644
index 91274482e..000000000
--- a/packages/server-e2e/AGENTS.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# server-e2e Agent Guide
-
-This file contains package-local rules for `packages/server-e2e`.
-
-## Package layout
-
-This package ships two clients:
-
-- **Legacy `/api/v1` client** — `DaemonClient` (`src/client.ts`), `HttpClient`
-  (`src/http.ts`), `WsClient` (`src/ws.ts`) and the helpers under `src/`
-  (`wait.ts`, `reverse-rpc.ts`, `report.ts`, `envelope.ts`). This is the
-  original wire-level test client; the existing `test/*.test.ts` cases and
-  `scenarios/*.ts` scripts are built on it and **must keep running unchanged**.
-  Do not break or rewrite those tests when extending the package.
-- **server-v2 SDK** — `ServerClient` under `src/v2/`. A lark-style typed client
-  for the `server-v2` `/api/v2` RPC + WS surface. `src/v2/resources/manifest.ts`
-  mirrors `server-v2/src/transport/actionMap.ts`; `test/v2/actionMap.test.ts`
-  is a drift test that fails when the server surface and the manifest diverge.
-  The legacy REST surface is reachable via `ServerClient#v1`.
-
-## Testing Principle
-
-- Keep observability inside each server-e2e case. Do not add a separate "observable" test or scenario as a substitute for making the existing cases explain what they drove and what the server returned.
-- Every live server case should print structured, case-scoped details for the flow it exercises: key REST requests, response envelopes or unwrapped responses, WebSocket handshakes / acks / replay summaries, prompt terminal frames, and error envelopes.
-- Prefer a shared logging helper over ad hoc `console.log` formatting. Logs must be visible for passing Vitest cases, so write through stdout when Vitest would otherwise capture console output.
-- Keep logs factual and diagnostic. Print enough detail to debug the wire contract, but avoid unrelated narration.
-
-## Workflow
-
-- When adding or changing a server-e2e case, update that case's observability at the same time.
-- Do not add a new scenario solely to print data that an existing scenario or Vitest case should already expose.
-- Run the relevant server-e2e tests against `KIMI_SERVER_URL=http://127.0.0.1:58627` when a server is available, and confirm the output includes the case-scoped diagnostic blocks.
-- Run Docker e2e with `pnpm --filter @moonshot-ai/server-e2e docker:e2e`; each run must derive its Docker runner name/namespace from the current workspace to avoid cross-workspace conflicts.
-
-## Command Reference
-
-- Start a local server from the repo root before validating live cases: `pnpm dev:server`.
-- Run only the undo helper/live e2e coverage: `KIMI_SERVER_URL=http://127.0.0.1:58627 pnpm --filter @moonshot-ai/server-e2e test -- test/client.test.ts -t undoSession`.
-- Run the full server client Vitest file: `KIMI_SERVER_URL=http://127.0.0.1:58627 pnpm --filter @moonshot-ai/server-e2e test -- test/client.test.ts`.
-- Run all server-e2e Vitest tests: `KIMI_SERVER_URL=http://127.0.0.1:58627 pnpm --filter @moonshot-ai/server-e2e test`.
-- Run all executable scenarios against the local server: `KIMI_SERVER_URL=http://127.0.0.1:58627 pnpm --filter @moonshot-ai/server-e2e test:scenarios`.
-- Run the server-v2 SDK drift test (no server needed): `pnpm --filter @moonshot-ai/server-e2e exec vitest run test/v2/actionMap.test.ts`.
-- Run the server-v2 SDK smoke test (boots server-v2 in-process): `pnpm --filter @moonshot-ai/server-e2e exec vitest run test/v2/smoke.test.ts`.
-- Run type checking for this package: `pnpm --filter @moonshot-ai/server-e2e typecheck`.
diff --git a/packages/server-e2e/README.md b/packages/server-e2e/README.md
deleted file mode 100644
index fffe84bfa..000000000
--- a/packages/server-e2e/README.md
+++ /dev/null
@@ -1,151 +0,0 @@
-# @moonshot-ai/server-e2e
-
-Wire-level test client for the kimi-code server (HTTP + WS). This package is
-**private** — it ships scenario scripts that double as smoke tests and a small
-typed `DaemonClient` you can reuse in vitest e2e files.
-
-## When to use this
-
-- You want to drive a real, running server process from a Node script and
-  observe HTTP + WS behavior end to end.
-- You're writing a vitest e2e that covers server REST + WS lifecycle as a
-  whole — not a single in-process unit (those belong in `packages/kap-server/test/`).
-- You need a reference for the wire shape of approval / question / events.
-
-## When NOT to use this
-
-- You're testing the WS gateway in isolation — keep using
-  `packages/kap-server/test/` in-process `startServer` boots (faster, and they
-  assert on the server's internal services directly).
-- You want a typed in-process facade over the server for user-facing code —
-  use `@moonshot-ai/node-sdk` instead (`KimiHarness`, `Session`).
-
-## Quick start (server-v2 — recommended)
-
-`ServerClient` is a lark-style typed client for the `server-v2` `/api/v2` RPC
-+ WebSocket surface. The resource tree mirrors the server's `actionMap`; a drift
-test (`test/v2/actionMap.test.ts`) keeps it in lockstep.
-
-```ts
-import { ServerClient } from '@moonshot-ai/server-e2e';
-
-const sdk = new ServerClient({ baseUrl: 'http://127.0.0.1:58627', token });
-
-// Core scope — /api/v2/<resource>:<action>
-const { items } = await sdk.sessions.list({ page_size: 20 });
-await sdk.workspaces.createOrTouch(process.cwd());
-
-// Session scope — the `session` resource is flattened onto the handle
-const s = sdk.session(items[0].id);
-await s.setTitle('renamed');
-await s.status();
-await s.approvals.decide(approvalId, { decision: 'approved' });
-
-// Agent scope
-const { turn_id } = await s.agent('main').prompts.submit({
-  input: [{ type: 'text', text: 'hello' }],
-});
-await s.agent('main').shell.run({ command: 'ls' });
-
-// Events over /api/v2/ws
-const events = await sdk.connect();
-const off = events.onAgentEvents(items[0].id, 'main', (e) => {
-  console.log('agent event', e);
-});
-// ...
-off();
-await sdk.close();
-```
-
-Anything not (yet) in the typed tree is reachable via the escape hatches
-`sdk.core<T>(resource)`, `sdk.session(sid).service<T>(resource)`, and
-`sdk.session(sid).agent(aid).service<T>(resource)`. The legacy `/api/v1` REST
-surface is reachable via `sdk.v1` (the unchanged `HttpClient`).
-
-## Quick start (legacy `/api/v1` client)
-
-```ts
-import { DaemonClient } from '@moonshot-ai/server-e2e';
-
-const client = new DaemonClient(); // http://127.0.0.1:58627 by default
-
-const session = await client.createSession({ metadata: { cwd: process.cwd() } });
-await client.connect();              // server_hello + client_hello ack
-await client.subscribe(session.id);
-
-client.onApprovalRequested(() => ({ decision: 'approved' }));
-
-const { prompt_id, finalFrame } = await client.submitAndWait(session.id, {
-  content: [{ type: 'text', text: 'Echo hello' }],
-});
-
-await client.close();
-await client.archiveSession(session.id);
-```
-
-> The exported facade is still spelled `DaemonClient` to keep the diff small;
-> conceptually it is the **server** client.
-
-## Scripts
-
-```sh
-pnpm --filter @moonshot-ai/server-e2e typecheck
-pnpm --filter @moonshot-ai/server-e2e test            # vitest self-tests
-pnpm --filter @moonshot-ai/server-e2e test:scenarios  # run every scenarios/*.ts
-pnpm --filter @moonshot-ai/server-e2e docker:e2e      # run server + scenarios in docker
-```
-
-Both `test` and `test:scenarios` require a running server (set `KIMI_SERVER_URL`
-to override the default `http://127.0.0.1:58627`). The vitest suite skips its
-live-dependent cases when no server is reachable so CI stays green. Scenarios
-are run via `tsx` because they execute TypeScript directly.
-
-Both commands write a browser-readable report to
-`packages/server-e2e/reports/latest/index.html` (override with
-`KIMI_SERVER_E2E_REPORT_DIR`). The report groups events by case and shows a compact
-timeline of case logs, HTTP request / response envelopes, WebSocket frames, and
-test results. JSON payloads are kept in collapsed detail blocks so the terminal
-can stay concise while the full wire trace remains available.
-
-`docker:e2e` builds `kimi-server:dev` from the root `Dockerfile`, layers
-`packages/server-e2e/Dockerfile` on top, then runs a one-shot Docker container.
-The container starts the server on container-local `127.0.0.1:58627` and runs
-`pnpm test:scenarios` in the same container. The launcher intentionally does
-not pass `-p` / `--publish`, so it does not expose a server port on the host and
-can coexist with the `docker-compose.yml` server that publishes host port 58627.
-Reports are written under
-`~/.kimi-code-server-dev/server-e2e-reports/docker/<run-id>/latest/index.html`;
-the server log is written beside them as `server.log`.
-
-The Docker workflow uses an isolated KIMI home at
-`~/.kimi-code-server-dev/docker-e2e/<run-id>/kimi-code-home` to avoid sharing
-server locks with Compose. `<run-id>` is deterministic by default:
-`<repo-basename>-<cksum-of-repo-path>`, so different worktrees do not collide.
-On first run it seeds `config.toml` and `credentials/` from
-`~/.kimi-code-server-dev/kimi-home/kimi-code-home` when those files exist.
-Override the namespace with `KIMI_SERVER_E2E_RUN_ID`, or override paths with
-`KIMI_SERVER_E2E_STATE_ROOT`, `KIMI_SERVER_E2E_KIMI_HOME_HOST`,
-`KIMI_SERVER_E2E_SEED_KIMI_HOME_HOST`, or `KIMI_SERVER_E2E_REPORT_DIR_HOST`.
-
-## Public API summary
-
-| Symbol | Purpose |
-|---|---|
-| `ServerClient` | **server-v2** lark-style client — typed `/api/v2` resource tree (HTTP) + events (WS), with `sdk.v1` for the legacy REST surface. |
-| `DaemonClient` | Main facade — HTTP + WS, handshake plumbing, reverse-RPC handlers. |
-| `HttpClient` | REST helpers only (no WS). Useful when you don't need event observation. |
-| `WsClient` | Raw WS wrapper — queue, waiters, ack correlation. |
-| `EnvelopeError` | Thrown by `unwrap()` / HTTP helpers when `envelope.code !== 0`. |
-| `fetchWithReport` / `writeHtmlReport` | Capture direct fetch calls and render the JSONL trace as a single HTML report. |
-| `installReverseRpcHandler` | Uniform helper powering `onApprovalRequested` / `onQuestionAsked`. |
-| `waitForFrame` / `waitForSessionStatus` | Standalone wait helpers reused by scenarios. |
-
-See `scenarios/README.md` for the executable script catalog and conventions.
-
-## Scope notes
-
-- **No in-process server bootstrap** — point at an already-running server.
-  An in-process `startServer(port:0)` helper is intentionally out of scope.
-- **No auto-discovery** — the WS endpoint is hard-coded to `${apiPrefix}/ws`.
-  Override via `apiPrefix` only.
-- **Not published** — `private: true`. Internal tooling only.
diff --git a/packages/server-e2e/package.json b/packages/server-e2e/package.json
deleted file mode 100644
index a551cfa17..000000000
--- a/packages/server-e2e/package.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
-  "name": "@moonshot-ai/server-e2e",
-  "version": "0.1.0",
-  "private": true,
-  "description": "Wire-level E2E test client for the kimi-code server (HTTP + WS). Powers scenario scripts and self-tests against a real server process.",
-  "license": "MIT",
-  "author": "Moonshot AI",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MoonshotAI/kimi-code.git",
-    "directory": "packages/server-e2e"
-  },
-  "bugs": {
-    "url": "https://github.com/MoonshotAI/kimi-code/issues"
-  },
-  "type": "module",
-  "imports": {
-    "#/*": "./src/*.ts"
-  },
-  "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
-    }
-  },
-  "scripts": {
-    "build": "tsdown",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
-    "test:scenarios": "tsx scripts/run-scenarios.ts",
-    "docker:e2e": "bash scripts/run-docker-e2e.sh",
-    "clean": "rm -rf dist"
-  },
-  "dependencies": {
-    "@moonshot-ai/protocol": "workspace:^",
-    "ulid": "^3.0.1",
-    "ws": "^8.18.0",
-    "zod": "catalog:"
-  },
-  "devDependencies": {
-    "@moonshot-ai/agent-core-v2": "workspace:^",
-    "@moonshot-ai/kap-server": "workspace:^",
-    "@moonshot-ai/klient": "workspace:^",
-    "@types/ws": "^8.18.0"
-  }
-}
diff --git a/packages/server-e2e/scenarios/01-create-and-send.ts b/packages/server-e2e/scenarios/01-create-and-send.ts
deleted file mode 100644
index a20519683..000000000
--- a/packages/server-e2e/scenarios/01-create-and-send.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 01 — create a session, submit a prompt asking for a 1-word reply,
- * poll messages, assert the assistant text contains the expected token.
- *
- * Usage:
- *   KIMI_SERVER_URL=http://127.0.0.1:58627 npx tsx scenarios/01-create-and-send.ts
- *
- * Exit codes:
- *   0  — pass
- *   1  — assertion failure or server error
- */
-import assert from 'node:assert/strict';
-
-import { DaemonClient } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const EXPECTED_TOKEN = 'OK';
-
-async function main() {
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-
-  let sid: string | undefined;
-  try {
-    const session = await client.createSession({ metadata: { cwd: process.cwd() } });
-    sid = session.id;
-    console.log(`▶ session ${sid} created`);
-
-    await client.connect();
-    await client.subscribe(sid);
-
-    const { prompt_id, finalFrame } = await client.submitAndWait(
-      sid,
-      {
-        content: [
-          {
-            type: 'text',
-            text: `Reply with the single word "${EXPECTED_TOKEN}" and nothing else.`,
-          },
-        ],
-      },
-      { waitFor: 'prompt.completed', timeoutMs: 60_000 },
-    );
-    console.log(`▶ prompt ${prompt_id} → finalFrame=${finalFrame.type}`);
-
-    const { items } = await client.listMessages(sid, { page_size: 100 });
-    // `prompt_id` on Message is optional (the adapter from agent-core doesn't
-    // always populate it). Fall back to the latest assistant message, which
-    // is unambiguous in a single-prompt scenario.
-    const assistant =
-      items.find((m) => m.role === 'assistant' && m.prompt_id === prompt_id) ??
-      [...items].reverse().find((m) => m.role === 'assistant');
-    assert.ok(assistant, 'expected at least one assistant message');
-
-    const text = assistant.content
-      .filter((part) => part.type === 'text')
-      .map((part) => part.text)
-      .join('');
-    assert.ok(
-      text.toUpperCase().includes(EXPECTED_TOKEN),
-      `expected assistant text to contain "${EXPECTED_TOKEN}", got: ${JSON.stringify(text)}`,
-    );
-
-    console.log(`✓ 01-create-and-send: assistant replied "${text.trim()}"`);
-  } finally {
-    try {
-      if (sid) await client.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    await client.close();
-  }
-}
-
-main().catch((err) => {
-  console.error('✗ 01-create-and-send failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/02-tool-call-with-approval.ts b/packages/server-e2e/scenarios/02-tool-call-with-approval.ts
deleted file mode 100644
index 4fe74e3b6..000000000
--- a/packages/server-e2e/scenarios/02-tool-call-with-approval.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 02 — tool call with approval.
- *
- * Asks the agent to run Bash and echo a canary token. The Bash tool triggers
- * an approval prompt; the framework's built-in `onApprovalRequested` handler
- * auto-approves it. We wait for `prompt.completed`, then assert:
- *
- *   - The tool emitted a `tool_result` whose output contains the canary.
- *   - The assistant message also surfaced the canary.
- *
- * Usage:
- *   KIMI_SERVER_URL=http://127.0.0.1:58627 npx tsx scenarios/02-tool-call-with-approval.ts
- *
- * Exit codes:
- *   0  — pass
- *   1  — assertion failure, timeout, or server error
- */
-import assert from 'node:assert/strict';
-
-import { DaemonClient } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const CANARY = `HELLO_FROM_AUDIT_${process.pid}`;
-
-async function main() {
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-
-  let sid: string | undefined;
-  let approvalCount = 0;
-  try {
-    const session = await client.createSession({ metadata: { cwd: process.cwd() } });
-    sid = session.id;
-    console.log(`▶ session ${sid} created`);
-
-    await client.connect();
-    await client.subscribe(sid);
-
-    client.onApprovalRequested((req) => {
-      approvalCount++;
-      console.log(`▶ approval ${req.approval_id} requested for tool=${req.tool_name}`);
-      return { decision: 'approved' };
-    });
-
-    const { prompt_id } = await client.submitAndWait(
-      sid,
-      {
-        content: [
-          {
-            type: 'text',
-            text: `Use the Bash tool to run \`echo ${CANARY}\` and then tell me the exact output you observed.`,
-          },
-        ],
-      },
-      { waitFor: 'prompt.completed', timeoutMs: 120_000 },
-    );
-    console.log(`▶ prompt ${prompt_id} completed; approvals=${approvalCount}`);
-
-    assert.ok(approvalCount >= 1, 'expected at least one approval request');
-
-    const { items } = await client.listMessages(sid, { page_size: 100 });
-    // `prompt_id` on Message is optional (see scenario 01) — match by role
-    // and accept any tool / assistant messages emitted in this session.
-    const toolMessages = items.filter(
-      (m) => m.role === 'tool' && (m.prompt_id === prompt_id || m.prompt_id === undefined),
-    );
-    const sawCanaryInTool = toolMessages.some((m) =>
-      m.content.some(
-        (part) =>
-          part.type === 'tool_result' &&
-          typeof part.output === 'string' &&
-          part.output.includes(CANARY),
-      ),
-    );
-    assert.ok(sawCanaryInTool, `expected canary "${CANARY}" in a tool_result`);
-
-    const assistantText = items
-      .filter(
-        (m) => m.role === 'assistant' && (m.prompt_id === prompt_id || m.prompt_id === undefined),
-      )
-      .flatMap((m) => m.content)
-      .filter((part) => part.type === 'text')
-      .map((part) => part.text)
-      .join('\n');
-    assert.ok(
-      assistantText.includes(CANARY),
-      `expected canary "${CANARY}" in assistant text, got: ${JSON.stringify(assistantText.slice(0, 300))}`,
-    );
-
-    // Session should be quiescent after prompt.completed.
-    const final = await client.waitForSessionStatus(sid, 'idle', { timeoutMs: 10_000 });
-    assert.equal(final.status, 'idle');
-
-    console.log(`✓ 02-tool-call-with-approval: canary round-tripped end-to-end`);
-  } finally {
-    try {
-      if (sid) await client.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    await client.close();
-  }
-}
-
-main().catch((err) => {
-  console.error('✗ 02-tool-call-with-approval failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/03-refresh-replay.ts b/packages/server-e2e/scenarios/03-refresh-replay.ts
deleted file mode 100644
index 222670cce..000000000
--- a/packages/server-e2e/scenarios/03-refresh-replay.ts
+++ /dev/null
@@ -1,323 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 03 — "user refreshes the browser" / "user clicks an existing session
- * from the history list" wire-level walkthrough.
- *
- * This is the worst-case page-load sequence a web client runs while the
- * server is already up. The phases (REST.md §3, WS.md §3) are:
- *
- *   Phase 0  environment probes        GET /healthz, /meta, /auth
- *   Phase 1  open WS BEFORE history    server_hello → client_hello(cursors) → ack
- *   Phase 2  pull persisted snapshot   GET /sessions/{sid}, /messages, /tasks
- *   Phase 5  steady state              POST /prompts → observe events on WS
- *
- * Phase ordering matters: if Phase 2 ran before Phase 1, turn events emitted
- * in the gap would have no subscriber on this connection — they'd still land
- * in the ring buffer, but REST `/messages` only reflects flushed-to-store
- * content, so the "in-flight" delta would be invisible to the UI.
- *
- * What this scenario exercises end-to-end against a running server:
- *   - All three Phase 0 endpoints respond and `meta.server_id` is non-empty.
- *   - A first WS session completes one prompt; we record the current ring-buffer
- *     seq for the session.
- *   - We close the WS, open a fresh one, and on `client_hello` pass
- *     `cursors: { [sid]: { seq: currentSeq } }` — the server should ack
- *     with `accepted_subscriptions: [sid]`, `resync_required: []`, and NOT
- *     replay any events (we are caught up).
- *   - We then open a THIRD connection, this time with
- *     `cursors: { [sid]: { seq: 0 } }` — the server should replay every
- *     durable event (seq 1..N) BEFORE the ack lands.
- *   - Phase 2 REST snapshot reflects the user + assistant messages persisted
- *     during the first run.
- *   - Phase 5: a new prompt over the third connection delivers events on WS.
- *
- * Usage:
- *   KIMI_SERVER_URL=http://127.0.0.1:58627 npx tsx scenarios/03-refresh-replay.ts
- *
- * Exit codes:
- *   0  — pass
- *   1  — assertion failure, timeout, or server error
- */
-import assert from 'node:assert/strict';
-
-import { DaemonClient, WsClient, type AnyFrame } from '../src/index';
-import { fetchWithReport } from '../src/report';
-import { WebSocket as WsWebSocket } from 'ws';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const API_PREFIX = '/api/v1';
-const HANDSHAKE_TIMEOUT_MS = 5_000;
-const PROMPT_TIMEOUT_MS = 60_000;
-
-interface Envelope<T> {
-  code: number;
-  msg?: string;
-  data: T;
-}
-
-interface MetaResponse {
-  server_id: string;
-  server_version: string;
-  started_at: string;
-}
-
-interface ClientHelloPayload extends Record<string, unknown> {
-  client_id: string;
-  subscriptions: string[];
-  cursors?: Record<string, { seq: number; epoch?: string }>;
-}
-
-interface AckPayload {
-  accepted_subscriptions?: string[];
-  resync_required?: string[];
-}
-
-interface OpenSocketResult {
-  ws: WsClient;
-  serverHello: unknown;
-  ack: AnyFrame;
-  replayed: AnyFrame[];
-  log: AnyFrame[];
-}
-
-interface PromptCompletedPayload {
-  prompt_id?: string;
-  promptId?: string;
-}
-
-async function fetchEnvelope<T>(url: string): Promise<T> {
-  const res = await fetchWithReport(url, { headers: { accept: 'application/json' } });
-  const body = (await res.json()) as Envelope<T>;
-  assert.equal(typeof body.code, 'number', `${url}: missing envelope.code`);
-  assert.equal(body.code, 0, `${url}: code=${body.code} msg=${body.msg ?? ''}`);
-  return body.data;
-}
-
-async function openSocketWithHello({
-  sid,
-  lastSeq,
-}: {
-  sid: string;
-  lastSeq?: number;
-}): Promise<OpenSocketResult> {
-  const wsUrl = `${KIMI_SERVER_URL.replace(/^http/, 'ws')}${API_PREFIX}/ws`;
-  const ws = new WsClient({ url: wsUrl, wsImpl: WsWebSocket, logger: () => {} });
-  await ws.open();
-
-  // Capture every frame on its arrival timeline (queue order). Used to
-  // distinguish replay events (arrive BEFORE ack) from steady-state events.
-  const log: AnyFrame[] = [];
-  ws.onFrame((f) => log.push(f));
-
-  // 1) server_hello
-  const helloFrame = await ws.waitForFrame((f) => f.type === 'server_hello', HANDSHAKE_TIMEOUT_MS);
-
-  // 2) client_hello
-  const helloId = `hello-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const payload: ClientHelloPayload = {
-    client_id: `scenario-03-${process.pid}`,
-    subscriptions: [sid],
-  };
-  if (lastSeq !== undefined) payload.cursors = { [sid]: { seq: lastSeq } };
-  ws.send({ type: 'client_hello', id: helloId, payload });
-
-  // 3) wait for the matching ack
-  const ack = await ws.waitForFrame(
-    (f) => f.type === 'ack' && f.id === helloId,
-    HANDSHAKE_TIMEOUT_MS,
-  );
-
-  // Replay events arrived before the ack — slice them out of the log by
-  // position. (Anything appended to `log` AFTER this point is steady-state.)
-  // The server emits agent-core event types without an `event.` prefix
-  // (`turn.started`, `assistant.delta`, …), so we filter on the structural
-  // shape (has `seq`, has `session_id`, isn't a system frame) instead of a
-  // type prefix.
-  const replayed = log.filter(
-    (f) =>
-      f.type !== 'server_hello' &&
-      f.type !== 'ack' &&
-      f.type !== 'ping' &&
-      f.type !== 'resync_required' &&
-      f.type !== 'error' &&
-      typeof f.seq === 'number' &&
-      f.session_id === sid &&
-      (lastSeq === undefined || f.seq > lastSeq),
-  );
-
-  return { ws, serverHello: helloFrame.payload, ack, replayed, log };
-}
-
-async function main() {
-  console.log(`▶ server at ${KIMI_SERVER_URL}`);
-
-  // ── Phase 0 ─────────────────────────────────────────────────────────────
-  const health = await fetchEnvelope<{ ok: boolean }>(`${KIMI_SERVER_URL}${API_PREFIX}/healthz`);
-  assert.equal(health.ok, true, 'healthz did not return ok=true');
-
-  const meta = await fetchEnvelope<MetaResponse>(`${KIMI_SERVER_URL}${API_PREFIX}/meta`);
-  assert.ok(typeof meta.server_id === 'string' && meta.server_id.length > 0, 'missing server_id');
-  assert.ok(typeof meta.started_at === 'string', 'missing started_at');
-  assert.ok(typeof meta.server_version === 'string', 'missing server_version');
-  const firstServerId = meta.server_id;
-  console.log(`▶ phase 0: server_id=${firstServerId} version=${meta.server_version}`);
-
-  const auth = await fetchEnvelope<{ ready: boolean; providers_count: number }>(
-    `${KIMI_SERVER_URL}${API_PREFIX}/auth`,
-  );
-  assert.equal(typeof auth.ready, 'boolean', 'auth.ready missing');
-  assert.equal(typeof auth.providers_count, 'number', 'auth.providers_count missing');
-  console.log(`▶ phase 0: auth.ready=${auth.ready}`);
-
-  // ── Initial flow: create + drive a prompt to populate the ring buffer ───
-  const initial = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-  let sid: string | undefined;
-  try {
-    const session = await initial.createSession({ metadata: { cwd: process.cwd() } });
-    sid = session.id;
-    console.log(`▶ session ${sid} created`);
-
-    await initial.connect();
-    await initial.subscribe(sid);
-
-    // Track every event we see on this connection so we know the max seq.
-    let maxSeq = 0;
-    initial.onFrame((f) => {
-      if (typeof f.seq === 'number' && f.session_id === sid && f.seq > maxSeq) {
-        maxSeq = f.seq;
-      }
-    });
-
-    const { prompt_id, finalFrame } = await initial.submitAndWait(
-      sid,
-      {
-        content: [{ type: 'text', text: 'Reply with the single word "REFRESH" and nothing else.' }],
-      },
-      { waitFor: 'prompt.completed', timeoutMs: PROMPT_TIMEOUT_MS },
-    );
-    if (typeof finalFrame.seq === 'number' && finalFrame.seq > maxSeq) maxSeq = finalFrame.seq;
-    assert.ok(maxSeq > 0, `expected at least one event before reconnect, maxSeq=${maxSeq}`);
-    console.log(`▶ prompt ${prompt_id} completed; maxSeq=${maxSeq}`);
-
-    await initial.close();
-
-    // ── Phase 0 again — simulate a browser refresh (cheap re-probe) ──────
-    const meta2 = await fetchEnvelope<MetaResponse>(`${KIMI_SERVER_URL}${API_PREFIX}/meta`);
-    assert.equal(meta2.server_id, firstServerId, 'server_id changed mid-scenario — server restarted?');
-
-    // ── Phase 1 (refresh #1): caught-up reconnect — no replay expected ───
-    const caughtUp = await openSocketWithHello({ sid, lastSeq: maxSeq });
-    assert.equal(caughtUp.ack.code, 0, `caught-up client_hello rejected: ${caughtUp.ack.msg}`);
-    const ackPayloadA = (caughtUp.ack.payload ?? {}) as AckPayload;
-    assert.deepEqual(
-      ackPayloadA.accepted_subscriptions ?? [],
-      [sid],
-      'expected accepted_subscriptions=[sid] for caught-up reconnect',
-    );
-    assert.deepEqual(
-      ackPayloadA.resync_required ?? [],
-      [],
-      'expected resync_required=[] for caught-up reconnect',
-    );
-    assert.equal(
-      caughtUp.replayed.length,
-      0,
-      `expected 0 replay events when caught up, got ${caughtUp.replayed.length}`,
-    );
-    console.log(`▶ refresh #1: caught-up; accepted=[${sid}], replayed=0`);
-    await caughtUp.ws.close();
-
-    // ── Phase 1 (refresh #2): seq=0 — server replays the whole buffer ────
-    const replay = await openSocketWithHello({ sid, lastSeq: 0 });
-    assert.equal(replay.ack.code, 0, `replay client_hello rejected: ${replay.ack.msg}`);
-    const ackPayloadB = (replay.ack.payload ?? {}) as AckPayload;
-    assert.deepEqual(
-      ackPayloadB.accepted_subscriptions ?? [],
-      [sid],
-      'expected accepted_subscriptions=[sid] for replay reconnect',
-    );
-    assert.deepEqual(
-      ackPayloadB.resync_required ?? [],
-      [],
-      'expected resync_required=[] when buffer covers seq=1..maxSeq',
-    );
-    assert.ok(
-      replay.replayed.length > 0,
-      `expected server to replay buffered events on last_seq=0, got 0`,
-    );
-    const seqs = replay.replayed
-      .map((f) => f.seq)
-      .filter((n): n is number => typeof n === 'number');
-    assert.equal(
-      Math.min(...seqs),
-      1,
-      `expected replay to start at seq=1, got ${Math.min(...seqs)}`,
-    );
-    assert.equal(
-      Math.max(...seqs),
-      maxSeq,
-      `expected replay to end at seq=maxSeq (${maxSeq}), got ${Math.max(...seqs)}`,
-    );
-    console.log(`▶ refresh #2: replay seq=1..${maxSeq} (${replay.replayed.length} events)`);
-
-    // ── Phase 2: persisted REST snapshot reflects the first prompt ───────
-    const fetched = await initial.http.getSession(sid);
-    assert.equal(fetched.id, sid, 'getSession returned wrong session id');
-
-    const { items: messages } = await initial.http.listMessages(sid, { page_size: 100 });
-    assert.ok(
-      messages.some((m) => m.role === 'user'),
-      'expected at least one user message in /messages snapshot',
-    );
-    assert.ok(
-      messages.some((m) => m.role === 'assistant'),
-      'expected at least one assistant message in /messages snapshot',
-    );
-
-    // No `listTasks` helper on HttpClient — call the endpoint directly to
-    // verify it responds with the documented `{items: []}` envelope.
-    const tasks = await fetchEnvelope<{ items: unknown[] }>(
-      `${KIMI_SERVER_URL}${API_PREFIX}/sessions/${encodeURIComponent(sid)}/tasks`,
-    );
-    assert.ok(Array.isArray(tasks.items), 'GET /tasks must return items[]');
-    console.log(`▶ phase 2: messages=${messages.length} tasks=${tasks.items.length}`);
-
-    // ── Phase 5: steady state — issue a new prompt over the live socket ──
-    // The third socket (`replay.ws`) is still open and subscribed; we drive
-    // a follow-up prompt via REST and assert events arrive on this WS.
-    const followUp = await initial.submitPrompt(sid, {
-      content: [{ type: 'text', text: 'Reply with the single word "DONE" and nothing else.' }],
-    });
-    const completed = await replay.ws.waitForFrame(
-      (f) => {
-        if (f.type !== 'prompt.completed') return false;
-        const p = (f.payload ?? {}) as PromptCompletedPayload;
-        const pid = p.prompt_id ?? p.promptId;
-        return pid === followUp.prompt_id;
-      },
-      PROMPT_TIMEOUT_MS,
-    );
-    assert.ok(typeof completed.seq === 'number' && completed.seq > maxSeq, 'follow-up seq did not advance');
-    console.log(`▶ phase 5: follow-up prompt completed at seq=${completed.seq}`);
-
-    await replay.ws.close();
-
-    console.log('✓ 03-refresh-replay: refresh round-trip preserves subscription + replay semantics');
-  } finally {
-    try {
-      if (sid) await initial.http.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    try {
-      await initial.close();
-    } catch {
-      // ignore
-    }
-  }
-}
-
-main().catch((err) => {
-  console.error('✗ 03-refresh-replay failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/05-workspace.ts b/packages/server-e2e/scenarios/05-workspace.ts
deleted file mode 100644
index 5da0045fe..000000000
--- a/packages/server-e2e/scenarios/05-workspace.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 05 — workspace registry + folder picker happy path.
- *
- * Flow:
- *   1. `GET /fs:home`   — picker landing payload (home + recent roots)
- *   2. `GET /fs:browse` — list child dirs of $HOME (sanity check the wire)
- *   3. `POST /workspaces { root }` — register a workspace on a fresh tmpdir
- *   4. `POST /sessions { workspace_id }` — server resolves cwd from workspace
- *   5. `GET /sessions?workspace_id=` — fast-path filter returns just our session
- *   6. Round-trip a real prompt through that session (depends on DAEMON_AUTH)
- *   7. `DELETE /workspaces/{id}` — unregister (does NOT remove the session)
- *
- * Usage:
- *   KIMI_SERVER_URL=http://127.0.0.1:58627 npx tsx scenarios/05-workspace.ts
- *
- * Exit codes:
- *   0  — pass
- *   1  — assertion failure or server error
- */
-import assert from 'node:assert/strict';
-import { mkdtempSync, realpathSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { DaemonClient } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const EXPECTED_TOKEN = 'OK';
-
-async function main() {
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-
-  // Use a fresh tmpdir as the workspace root so the scenario doesn't pollute
-  // the server's workspace registry with persistent entries. realpathSync()
-  // matches what the picker / server registry surface (avoids macOS
-  // `/var` ↔ `/private/var` mismatch with the session cwd).
-  const wsRoot = realpathSync(mkdtempSync(join(tmpdir(), 'kimi-e2e-workspace-')));
-  let workspaceId: string | undefined;
-  let sid: string | undefined;
-
-  try {
-    // 1. fs:home — sanity check the landing payload shape.
-    const home = await client.fsHome();
-    assert.ok(typeof home.home === 'string' && home.home.startsWith('/'), 'home.home is an absolute path');
-    assert.ok(Array.isArray(home.recent_roots), 'home.recent_roots is an array');
-    console.log(`▶ fs:home returned home=${home.home}`);
-
-    // 2. fs:browse — list immediate subdirs of $HOME. We only check the shape
-    //    of the response; the exact directory tree depends on the host.
-    const browseHome = await client.fsBrowse(home.home);
-    assert.ok(typeof browseHome.path === 'string', 'fs:browse path is set');
-    assert.ok(Array.isArray(browseHome.entries), 'fs:browse entries is an array');
-    for (const e of browseHome.entries) {
-      assert.equal(e.is_dir, true, 'fs:browse entries are directories only');
-    }
-    console.log(`▶ fs:browse $HOME returned ${browseHome.entries.length} subdir(s)`);
-
-    // 3. Register the workspace. Idempotent + returns derived id.
-    const workspace = await client.createWorkspace({ root: wsRoot, name: 'e2e-workspace' });
-    workspaceId = workspace.id;
-    assert.match(workspace.id, /^wd_[a-z0-9._-]+_[0-9a-f]{12}$/, 'workspace.id matches wd-key shape');
-    assert.equal(workspace.name, 'e2e-workspace');
-    assert.equal(workspace.session_count, 0, 'no sessions in fresh workspace');
-    console.log(`▶ POST /workspaces → ${workspaceId} (root=${workspace.root})`);
-
-    // 4. Create a session BY workspace_id (server resolves cwd from the
-    //    registered root). The Session response carries workspace_id verbatim.
-    const session = await client.createSession({ workspace_id: workspaceId });
-    sid = session.id;
-    assert.equal(session.workspace_id, workspaceId, 'session.workspace_id mirrors POST input');
-    assert.equal(session.metadata.cwd, workspace.root, 'session.metadata.cwd resolved from workspace.root');
-    console.log(`▶ POST /sessions { workspace_id } → ${sid}`);
-
-    // 5. List by workspace_id (fast path via listSessions({ workDir })).
-    const filtered = await client.listSessions({ workspace_id: workspaceId });
-    assert.equal(filtered.items.length, 1, 'workspace filter returned exactly the new session');
-    const filteredSession = filtered.items[0];
-    assert.ok(filteredSession, 'workspace filter returned a session');
-    assert.equal(filteredSession.id, sid, 'session id round-trips through the filter');
-
-    // 6. Round-trip a real prompt. Skipped when DAEMON_AUTH isn't wired (the
-    //    server answers 401xx without an authenticated provider, which surfaces
-    //    in `submitAndWait` as a HTTP error — keep the scenario useful even
-    //    when run without provider creds).
-    if (process.env['DAEMON_AUTH'] !== 'skip') {
-      await client.connect();
-      await client.subscribe(sid);
-      try {
-        const { prompt_id, finalFrame } = await client.submitAndWait(
-          sid,
-          {
-            content: [
-              {
-                type: 'text',
-                text: `Reply with the single word "${EXPECTED_TOKEN}" and nothing else.`,
-              },
-            ],
-          },
-          { waitFor: 'prompt.completed', timeoutMs: 60_000 },
-        );
-        console.log(`▶ prompt ${prompt_id} finalFrame=${finalFrame.type}`);
-
-        const { items } = await client.listMessages(sid, { page_size: 100 });
-        const assistant =
-          items.find((m) => m.role === 'assistant' && m.prompt_id === prompt_id) ??
-          [...items].reverse().find((m) => m.role === 'assistant');
-        assert.ok(assistant, 'expected at least one assistant message');
-        const text = assistant.content
-          .filter((part) => part.type === 'text')
-          .map((part) => part.text)
-          .join('');
-        assert.ok(
-          text.toUpperCase().includes(EXPECTED_TOKEN),
-          `expected assistant text to contain "${EXPECTED_TOKEN}", got: ${JSON.stringify(text)}`,
-        );
-      } catch (error) {
-        console.log(`▶ prompt round-trip skipped (likely no DAEMON_AUTH): ${String(error)}`);
-      }
-    } else {
-      console.log('▶ prompt round-trip skipped via DAEMON_AUTH=skip');
-    }
-
-    // 7. Unregister. Workspace count drops; session is unaffected
-    //    (the registry entry is removed but the session subdir stays).
-    await client.deleteWorkspace(workspaceId);
-    workspaceId = undefined;
-    const after = await client.listWorkspaces();
-    assert.equal(
-      after.items.find((w) => w.id === workspace.id),
-      undefined,
-      'workspace removed from registry',
-    );
-    // The session can still be fetched directly (delete workspace ≠ delete sessions).
-    const stillThere = await client.getSession(sid);
-    assert.equal(stillThere.id, sid, 'session survives workspace delete');
-
-    console.log('✓ 05-workspace: end-to-end registry + picker + session round-trip');
-  } finally {
-    try {
-      if (sid) await client.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    try {
-      if (workspaceId) await client.deleteWorkspace(workspaceId);
-    } catch {
-      // ignore
-    }
-    await client.close();
-    try {
-      rmSync(wsRoot, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  }
-}
-
-main().catch((err) => {
-  console.error('✗ 05-workspace failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/06-model-catalog.ts b/packages/server-e2e/scenarios/06-model-catalog.ts
deleted file mode 100644
index 92bfd0e91..000000000
--- a/packages/server-e2e/scenarios/06-model-catalog.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 06 — model and provider catalog APIs.
- *
- * Exercises:
- *   - GET /auth
- *   - GET /models
- *   - GET /providers
- *   - GET /providers/{id}
- *   - POST /models/{id}:set_default when the current default appears in /models
- */
-import assert from 'node:assert/strict';
-
-import { DaemonClient } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-
-async function main() {
-  console.log(`▶ server at ${KIMI_SERVER_URL}`);
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-
-  try {
-    const auth = await client.getAuth();
-    const models = await client.listModels();
-    const providers = await client.listProviders();
-    assert.ok(Array.isArray(models.items), 'GET /models returns items[]');
-    assert.ok(Array.isArray(providers.items), 'GET /providers returns items[]');
-    console.log(
-      `▶ catalog: models=${models.items.length} providers=${providers.items.length} default=${auth.default_model ?? '<none>'}`,
-    );
-
-    const firstProvider = providers.items[0];
-    if (firstProvider !== undefined) {
-      const provider = await client.getProvider(firstProvider.id);
-      assert.equal(provider.id, firstProvider.id, 'GET /providers/{id} returns the requested provider');
-      console.log(`▶ catalog: provider ${provider.id} status=${provider.status}`);
-    }
-
-    const defaultModel = auth.default_model;
-    if (defaultModel === null || !models.items.some((item) => item.model === defaultModel)) {
-      console.log('▶ catalog: set_default skipped because current default is not in /models');
-      console.log('✓ 06-model-catalog: catalog reads round-tripped');
-      return;
-    }
-
-    const setDefault = await client.setDefaultModel(defaultModel);
-    assert.equal(setDefault.default_model, defaultModel);
-    assert.equal(setDefault.model.model, defaultModel);
-    console.log(`▶ catalog: POST /models/${defaultModel}:set_default returned current default`);
-
-    console.log('✓ 06-model-catalog: model/provider catalog round-tripped');
-  } finally {
-    await client.close();
-  }
-}
-
-main().catch((err) => {
-  console.error('✗ 06-model-catalog failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/07-session-children.ts b/packages/server-e2e/scenarios/07-session-children.ts
deleted file mode 100644
index f0f8734ec..000000000
--- a/packages/server-e2e/scenarios/07-session-children.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 07 — direct child sessions.
- *
- * Exercises:
- *   - POST /sessions/{id}/children
- *   - GET /sessions/{id}/children
- *   - parent sessions can run prompts before child creation
- *   - child sessions can run prompts
- *   - direct-child listing omits grandchildren
- *   - missing parent returns 40401
- */
-import assert from 'node:assert/strict';
-
-import { ErrorCode } from '@moonshot-ai/protocol';
-
-import { DaemonClient, EnvelopeError } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const PROMPT_TIMEOUT_MS = 120_000;
-const PARENT_PROMPT_TOKEN = 'PARENT_SESSION_OK';
-const CHILD_PROMPT_TOKEN = 'CHILD_SESSION_OK';
-
-async function main() {
-  console.log(`▶ server at ${KIMI_SERVER_URL}`);
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-  const sessions: string[] = [];
-
-  try {
-    const parent = await client.createSession({
-      title: 'server-e2e session children',
-      metadata: { cwd: process.cwd(), scenario: '07-session-children' },
-    });
-    sessions.push(parent.id);
-    console.log(`▶ children: parent session ${parent.id} created`);
-
-    await client.connect();
-    await client.subscribe(parent.id);
-    await submitPromptAndAssertToken(client, parent.id, PARENT_PROMPT_TOKEN, 'parent');
-
-    const child = await client.createChild(parent.id, {
-      title: 'server-e2e child',
-      metadata: { branch: 'direct-child' },
-    });
-    sessions.push(child.id);
-    assert.equal(child.metadata['parent_session_id'], parent.id);
-    assert.equal(child.metadata['child_session_kind'], 'child');
-    console.log(`▶ children: child session ${child.id} created`);
-
-    await client.subscribe(child.id);
-    await submitPromptAndAssertToken(client, child.id, CHILD_PROMPT_TOKEN, 'child');
-
-    const grandchild = await client.createChild(child.id, {
-      title: 'server-e2e grandchild',
-      metadata: { branch: 'grandchild' },
-    });
-    sessions.push(grandchild.id);
-    console.log(`▶ children: grandchild session ${grandchild.id} created`);
-
-    const parentChildren = await client.listChildren(parent.id, { page_size: 10 });
-    assert.ok(
-      parentChildren.items.some((item) => item.id === child.id),
-      'parent children list includes the direct child',
-    );
-    assert.equal(
-      parentChildren.items.some((item) => item.id === grandchild.id),
-      false,
-      'parent children list omits grandchildren',
-    );
-
-    const childChildren = await client.listChildren(child.id, { page_size: 10 });
-    assert.ok(
-      childChildren.items.some((item) => item.id === grandchild.id),
-      'child children list includes the grandchild',
-    );
-
-    await expectEnvelopeCode(
-      () => client.listChildren(`sess_missing_children_${process.pid}`, { page_size: 10 }),
-      ErrorCode.SESSION_NOT_FOUND,
-      'GET /sessions/{id}/children missing parent',
-    );
-
-    console.log('✓ 07-session-children: child session creation, execution, and listing round-tripped');
-  } finally {
-    for (const sid of sessions.toReversed()) {
-      try {
-        await client.archiveSession(sid);
-      } catch {
-        // ignore
-      }
-    }
-    await client.close();
-  }
-}
-
-async function submitPromptAndAssertToken(
-  client: DaemonClient,
-  sid: string,
-  token: string,
-  label: 'parent' | 'child',
-): Promise<void> {
-  const prompt = await client.submitAndWait(
-    sid,
-    {
-      content: [
-        {
-          type: 'text',
-          text: `Reply with the exact token ${token} and nothing else.`,
-        },
-      ],
-    },
-    { waitFor: 'prompt.completed', timeoutMs: PROMPT_TIMEOUT_MS },
-  );
-
-  const messages = await client.listMessages(sid, { page_size: 100 });
-  const assistant =
-    messages.items.find(
-      (message) => message.role === 'assistant' && message.prompt_id === prompt.prompt_id,
-    ) ??
-    messages.items.find((message) => message.role === 'assistant');
-  assert.ok(assistant, `${label} prompt should produce an assistant message`);
-  const assistantText = assistant.content
-    .filter((part) => part.type === 'text')
-    .map((part) => part.text)
-    .join('');
-  assert.ok(
-    assistantText.includes(token),
-    `${label} assistant text should contain ${token}, got ${JSON.stringify(assistantText)}`,
-  );
-  console.log(`▶ children: ${label} prompt ${prompt.prompt_id} completed via ${prompt.finalFrame.type}`);
-}
-
-async function expectEnvelopeCode(
-  action: () => Promise<unknown>,
-  code: ErrorCode,
-  label: string,
-): Promise<void> {
-  let caught: unknown;
-  try {
-    await action();
-  } catch (error) {
-    caught = error;
-  }
-  assert.ok(caught instanceof EnvelopeError, `${label}: expected EnvelopeError`);
-  assert.equal(caught.code, code, `${label}: expected code ${code}, got ${caught.code}`);
-  console.log(`▶ children: ${label} returned code=${caught.code}`);
-}
-
-main().catch((err) => {
-  console.error('✗ 07-session-children failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/08-pending-recovery.ts b/packages/server-e2e/scenarios/08-pending-recovery.ts
deleted file mode 100644
index f69a860cc..000000000
--- a/packages/server-e2e/scenarios/08-pending-recovery.ts
+++ /dev/null
@@ -1,204 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 08 — pending reverse-RPC recovery APIs.
- *
- * Exercises:
- *   - GET /sessions/{id}/approvals?status=pending
- *   - POST /sessions/{id}/approvals/{approval_id}
- *   - GET /sessions/{id}/questions?status=pending
- *   - POST /sessions/{id}/questions/{question_id}
- */
-import assert from 'node:assert/strict';
-
-import type { QuestionAnswer } from '@moonshot-ai/protocol';
-
-import { DaemonClient, type AnyFrame } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const PROMPT_TIMEOUT_MS = 120_000;
-const CANARY = `KIMI_SERVER_E2E_PENDING_${process.pid}`;
-
-interface ApprovalRequestedPayload {
-  approval_id: string;
-  session_id: string;
-  tool_call_id: string;
-  tool_name: string;
-  action: string;
-  created_at: string;
-  expires_at: string;
-}
-
-interface QuestionRequestedPayload {
-  question_id: string;
-  session_id: string;
-  questions: Array<{
-    id: string;
-    question: string;
-    options: Array<{ id: string; label: string }>;
-  }>;
-  created_at: string;
-}
-
-async function main() {
-  console.log(`▶ server at ${KIMI_SERVER_URL}`);
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-  let sid: string | undefined;
-
-  try {
-    const session = await client.createSession({
-      title: 'server-e2e pending recovery',
-      metadata: { cwd: process.cwd(), scenario: '08-pending-recovery' },
-    });
-    sid = session.id;
-    console.log(`▶ pending: session ${sid} created`);
-
-    await client.connect();
-    await client.subscribe(sid);
-
-    await exerciseApprovalRecovery(client, sid);
-    await exerciseQuestionRecovery(client, sid);
-
-    console.log('✓ 08-pending-recovery: pending approvals and questions round-tripped');
-  } finally {
-    try {
-      if (sid) await client.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    await client.close();
-  }
-}
-
-async function exerciseApprovalRecovery(client: DaemonClient, sid: string): Promise<void> {
-  const approvalFramePromise = client.waitForFrame(isApprovalRequestedFor(sid), {
-    timeoutMs: PROMPT_TIMEOUT_MS,
-  });
-  const submit = await client.submitPrompt(sid, {
-    content: [
-      {
-        type: 'text',
-        text: `Use the Bash tool to run \`echo ${CANARY}\`, then tell me the exact output you observed.`,
-      },
-    ],
-  });
-  console.log(`▶ approval: prompt ${submit.prompt_id} submitted`);
-
-  const frame = await approvalFramePromise;
-  const approval = payloadOf<ApprovalRequestedPayload>(frame);
-  assert.equal(approval.session_id, sid);
-
-  const pending = await client.listPendingApprovals(sid);
-  const listed = pending.items.find((item) => item.approval_id === approval.approval_id);
-  assert.ok(listed, 'pending approvals list includes the requested approval');
-  assert.equal(listed.tool_call_id, approval.tool_call_id);
-  assert.equal(listed.tool_name, approval.tool_name);
-  console.log(`▶ approval: pending approval ${approval.approval_id} tool=${approval.tool_name}`);
-
-  const resolved = await client.resolveApproval(sid, approval.approval_id, {
-    decision: 'approved',
-  });
-  assert.equal(resolved.resolved, true);
-
-  const after = await client.listPendingApprovals(sid);
-  assert.equal(
-    after.items.some((item) => item.approval_id === approval.approval_id),
-    false,
-    'resolved approval is removed from pending list',
-  );
-
-  const finalFrame = await client.waitForFrame(isPromptCompleted(submit.prompt_id), {
-    timeoutMs: PROMPT_TIMEOUT_MS,
-  });
-  console.log(`▶ approval: prompt completed via ${finalFrame.type}`);
-}
-
-async function exerciseQuestionRecovery(client: DaemonClient, sid: string): Promise<void> {
-  const questionFramePromise = client.waitForFrame(isQuestionRequestedFor(sid), {
-    timeoutMs: PROMPT_TIMEOUT_MS,
-  });
-  const submit = await client.submitPrompt(sid, {
-    content: [
-      {
-        type: 'text',
-        text: [
-          'Use the AskUserQuestion tool now.',
-          'Ask exactly one question: "Which server e2e recovery option should continue?"',
-          'Use header "E2E".',
-          'Use two options: "Continue (Recommended)" and "Stop".',
-          'After I answer, reply with the selected option label.',
-        ].join(' '),
-      },
-    ],
-  });
-  console.log(`▶ question: prompt ${submit.prompt_id} submitted`);
-
-  const frame = await questionFramePromise;
-  const question = payloadOf<QuestionRequestedPayload>(frame);
-  assert.equal(question.session_id, sid);
-
-  const pending = await client.listPendingQuestions(sid);
-  const listed = pending.items.find((item) => item.question_id === question.question_id);
-  assert.ok(listed, 'pending questions list includes the requested question');
-  assert.ok(listed.questions.length > 0, 'pending question carries questions[]');
-  console.log(`▶ question: pending question ${question.question_id} items=${listed.questions.length}`);
-
-  const answers: Record<string, QuestionAnswer> = {};
-  for (const item of listed.questions) {
-    const firstOption = item.options[0];
-    assert.ok(firstOption, `question ${item.id} should have at least one option`);
-    answers[item.id] = { kind: 'single', option_id: firstOption.id };
-  }
-
-  const resolved = await client.resolveQuestion(sid, question.question_id, {
-    answers,
-    method: 'click',
-  });
-  assert.equal(resolved.resolved, true);
-
-  const after = await client.listPendingQuestions(sid);
-  assert.equal(
-    after.items.some((item) => item.question_id === question.question_id),
-    false,
-    'resolved question is removed from pending list',
-  );
-
-  const finalFrame = await client.waitForFrame(isPromptCompleted(submit.prompt_id), {
-    timeoutMs: PROMPT_TIMEOUT_MS,
-  });
-  console.log(`▶ question: prompt completed via ${finalFrame.type}`);
-}
-
-function isApprovalRequestedFor(sid: string): (frame: AnyFrame) => boolean {
-  return (frame) =>
-    frame.type === 'event.approval.requested' &&
-    payloadSessionId(frame) === sid;
-}
-
-function isQuestionRequestedFor(sid: string): (frame: AnyFrame) => boolean {
-  return (frame) =>
-    frame.type === 'event.question.requested' &&
-    payloadSessionId(frame) === sid;
-}
-
-function isPromptCompleted(promptId: string): (frame: AnyFrame) => boolean {
-  return (frame) => {
-    if (frame.type !== 'prompt.completed') return false;
-    const payload = (frame.payload ?? {}) as { prompt_id?: string; promptId?: string };
-    return (payload.prompt_id ?? payload.promptId) === promptId;
-  };
-}
-
-function payloadSessionId(frame: AnyFrame): string | undefined {
-  const payload = frame.payload as { session_id?: string } | undefined;
-  return payload?.session_id;
-}
-
-function payloadOf<T>(frame: AnyFrame): T {
-  assert.ok(frame.payload !== undefined, `${frame.type} frame should carry payload`);
-  return frame.payload as T;
-}
-
-main().catch((err) => {
-  console.error('✗ 08-pending-recovery failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/09-image-file-prompts.ts b/packages/server-e2e/scenarios/09-image-file-prompts.ts
deleted file mode 100644
index 3cc7bb893..000000000
--- a/packages/server-e2e/scenarios/09-image-file-prompts.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 09 — uploaded image files in prompt content.
- *
- * Exercises:
- *   - missing prompt image file_id returns FILE_NOT_FOUND
- *   - non-image uploaded file used as image content returns VALIDATION_FAILED
- *   - uploaded PNG can be referenced by a prompt submission
- */
-import assert from 'node:assert/strict';
-
-import { ErrorCode } from '@moonshot-ai/protocol';
-
-import { DaemonClient, EnvelopeError } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const SHORT_TIMEOUT_MS = 15_000;
-
-const ONE_BY_ONE_PNG = Buffer.from(
-  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=',
-  'base64',
-);
-
-async function main() {
-  console.log(`▶ server at ${KIMI_SERVER_URL}`);
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-  const files: string[] = [];
-  let sid: string | undefined;
-
-  try {
-    const session = await client.createSession({
-      title: 'server-e2e image file prompts',
-      metadata: { cwd: process.cwd(), scenario: '09-image-file-prompts' },
-    });
-    sid = session.id;
-    console.log(`▶ image-file: session ${sid} created`);
-
-    await expectEnvelopeCode(
-      () =>
-        client.submitPrompt(sid!, {
-          content: [
-            {
-              type: 'image',
-              source: { kind: 'file', file_id: 'file_missing_daemon_e2e' },
-            },
-          ],
-        }),
-      ErrorCode.FILE_NOT_FOUND,
-      'missing prompt image file_id',
-    );
-
-    const textFile = await client.uploadFile({
-      name: 'not-an-image.txt',
-      data: 'not an image',
-      mediaType: 'text/plain',
-    });
-    files.push(textFile.id);
-    await expectEnvelopeCode(
-      () =>
-        client.submitPrompt(sid!, {
-          content: [
-            {
-              type: 'image',
-              source: { kind: 'file', file_id: textFile.id },
-            },
-          ],
-        }),
-      ErrorCode.VALIDATION_FAILED,
-      'non-image prompt file_id',
-    );
-
-    const png = await client.uploadFile({
-      name: 'tiny.png',
-      data: ONE_BY_ONE_PNG,
-      mediaType: 'image/png',
-    });
-    files.push(png.id);
-    assert.equal(png.media_type, 'image/png');
-    assert.equal(png.size, ONE_BY_ONE_PNG.length);
-
-    const submit = await client.submitPrompt(sid, {
-      content: [
-        { type: 'text', text: 'Reply with the single word "OK" after reading this image.' },
-        { type: 'image', source: { kind: 'file', file_id: png.id } },
-      ],
-    });
-    assert.ok(submit.prompt_id.length > 0, 'image file prompt returns a prompt_id');
-    console.log(`▶ image-file: uploaded ${png.id} and submitted prompt ${submit.prompt_id}`);
-
-    let terminalStatus: 'idle' | 'aborted' = 'idle';
-    try {
-      await client.abortPrompt(sid, submit.prompt_id);
-      terminalStatus = 'aborted';
-      console.log(`▶ image-file: prompt ${submit.prompt_id} aborted after submit`);
-    } catch (error) {
-      if (
-        error instanceof EnvelopeError &&
-        (error.code === ErrorCode.PROMPT_ALREADY_COMPLETED ||
-          error.code === ErrorCode.PROMPT_NOT_FOUND)
-      ) {
-        console.log(`▶ image-file: prompt ${submit.prompt_id} was already terminal before abort`);
-      } else {
-        throw error;
-      }
-    }
-    await client.waitForSessionStatus(sid, terminalStatus, { timeoutMs: SHORT_TIMEOUT_MS });
-
-    console.log('✓ 09-image-file-prompts: image file prompt references round-tripped');
-  } finally {
-    for (const fileId of files.toReversed()) {
-      try {
-        await client.deleteFile(fileId);
-      } catch {
-        // ignore
-      }
-    }
-    try {
-      if (sid) await client.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    await client.close();
-  }
-}
-
-async function expectEnvelopeCode(
-  action: () => Promise<unknown>,
-  code: ErrorCode,
-  label: string,
-): Promise<void> {
-  let caught: unknown;
-  try {
-    await action();
-  } catch (error) {
-    caught = error;
-  }
-  assert.ok(caught instanceof EnvelopeError, `${label}: expected EnvelopeError`);
-  assert.equal(caught.code, code, `${label}: expected code ${code}, got ${caught.code}`);
-  console.log(`▶ image-file: ${label} returned code=${caught.code}`);
-}
-
-main().catch((err) => {
-  console.error('✗ 09-image-file-prompts failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scenarios/11-terminal.ts b/packages/server-e2e/scenarios/11-terminal.ts
deleted file mode 100644
index 3cb67f94b..000000000
--- a/packages/server-e2e/scenarios/11-terminal.ts
+++ /dev/null
@@ -1,266 +0,0 @@
-#!/usr/bin/env node
-/**
- * Scenario 11 — server terminal REST + WS controls.
- *
- * Exercises:
- *   - POST /sessions/{id}/terminals
- *   - GET /sessions/{id}/terminals
- *   - GET /sessions/{id}/terminals/{terminal_id}
- *   - WS terminal_attach / terminal_input / terminal_resize / terminal_close
- *   - terminal_output and terminal_exit frames
- */
-import assert from 'node:assert/strict';
-
-import { DaemonClient, recordReportEvent, type AnyFrame } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-const TERMINAL_SHELL = process.env['KIMI_SERVER_E2E_TERMINAL_SHELL'] ?? '/bin/sh';
-const OUTPUT_TIMEOUT_MS = 20_000;
-const EXIT_TIMEOUT_MS = 5_000;
-const CANARY = `KIMI_SERVER_E2E_TERMINAL_${process.pid}_${Date.now()}`;
-
-async function main() {
-  log('server', { base_url: KIMI_SERVER_URL, shell: TERMINAL_SHELL });
-  const client = new DaemonClient({ baseUrl: KIMI_SERVER_URL });
-
-  let sid: string | undefined;
-  let terminalId: string | undefined;
-  let terminalClosed = false;
-
-  try {
-    const session = await client.createSession({
-      title: 'server-e2e terminal',
-      metadata: { cwd: process.cwd(), scenario: '11-terminal' },
-    });
-    sid = session.id;
-    const sessionId = session.id;
-    log('session created', { session_id: sessionId, cwd: session.metadata.cwd });
-
-    await client.connect();
-    await client.subscribe(sessionId);
-    log('ws subscribed', { session_id: sessionId });
-
-    const terminal = await client.createTerminal(sessionId, {
-      shell: TERMINAL_SHELL,
-      cols: 80,
-      rows: 24,
-    });
-    terminalId = terminal.id;
-    assert.equal(terminal.session_id, sessionId);
-    assert.equal(terminal.status, 'running');
-    assert.equal(terminal.cols, 80);
-    assert.equal(terminal.rows, 24);
-    log('terminal created', terminalForLog(terminal));
-
-    const listed = await client.listTerminals(sessionId);
-    assert.ok(
-      listed.items.some((item) => item.id === terminal.id),
-      'terminal list should include the created terminal',
-    );
-    log('terminal list', {
-      count: listed.items.length,
-      ids: listed.items.map((item) => item.id),
-    });
-
-    const observedOutput: string[] = [];
-    const unsubscribe = client.onFrame((frame) => {
-      if (!isTerminalOutputFor(frame, sessionId, terminal.id)) return;
-      observedOutput.push(payloadOf<TerminalOutputPayload>(frame).data);
-    });
-
-    try {
-      const attach = await client.attachTerminal(sessionId, terminal.id, { sinceSeq: 0 });
-      assert.equal(attach.attached, true);
-      assert.equal(typeof attach.replayed, 'number');
-      log('terminal attached', attach);
-
-      const input = `printf '%b\\n' '${toShellOctalEscapes(CANARY)}'\n`;
-      const inputAck = await client.writeTerminalInput(sessionId, terminal.id, input);
-      assert.deepEqual(inputAck, { accepted: true });
-      log('terminal input accepted', {
-        input_bytes: input.length,
-        expected_output: CANARY,
-      });
-
-      const output = await waitForTerminalText(observedOutput, CANARY, OUTPUT_TIMEOUT_MS);
-      log('terminal output observed', {
-        matched: CANARY,
-        output_tail: printableTail(output),
-      });
-
-      const resizeAck = await client.resizeTerminal(sessionId, terminal.id, 100, 31);
-      assert.deepEqual(resizeAck, { resized: true });
-      const resized = await client.getTerminal(sessionId, terminal.id);
-      assert.equal(resized.cols, 100);
-      assert.equal(resized.rows, 31);
-      log('terminal resized', terminalForLog(resized));
-
-      const exitFramePromise = client.waitForFrame(isTerminalExitFor(sessionId, terminal.id), {
-        timeoutMs: EXIT_TIMEOUT_MS,
-      });
-      const closeAck = await client.closeTerminalControl(sessionId, terminal.id);
-      terminalClosed = true;
-      assert.deepEqual(closeAck, { closed: true });
-      log('terminal close ack', closeAck);
-
-      const exitFrame = await exitFramePromise;
-      log('terminal exit frame', frameForLog(exitFrame));
-
-      const closed = await client.getTerminal(sessionId, terminal.id);
-      assert.equal(closed.status, 'exited');
-      log('terminal final state', terminalForLog(closed));
-    } finally {
-      unsubscribe();
-    }
-
-    writeLine(`✓ 11-terminal: terminal ${terminal.id} output, resize, and close round-tripped`);
-  } finally {
-    if (sid !== undefined && terminalId !== undefined && !terminalClosed) {
-      try {
-        await client.closeTerminal(sid, terminalId);
-      } catch {
-        // ignore
-      }
-    }
-    try {
-      if (sid) await client.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    await client.close();
-  }
-}
-
-interface TerminalOutputPayload {
-  data: string;
-}
-
-interface TerminalForLog {
-  id: string;
-  session_id: string;
-  cwd: string;
-  shell: string;
-  cols: number;
-  rows: number;
-  status: string;
-  exit_code?: number | null;
-}
-
-function isTerminalOutputFor(
-  frame: AnyFrame,
-  sid: string,
-  terminalId: string,
-): boolean {
-  const terminalFrame = frame as AnyFrame & { terminal_id?: string };
-  return (
-    frame.type === 'terminal_output' &&
-    frame.session_id === sid &&
-    terminalFrame.terminal_id === terminalId
-  );
-}
-
-function isTerminalExitFor(
-  sid: string,
-  terminalId: string,
-): (frame: AnyFrame) => boolean {
-  return (frame) => {
-    const terminalFrame = frame as AnyFrame & { terminal_id?: string };
-    return (
-      frame.type === 'terminal_exit' &&
-      frame.session_id === sid &&
-      terminalFrame.terminal_id === terminalId
-    );
-  };
-}
-
-async function waitForTerminalText(
-  chunks: readonly string[],
-  expected: string,
-  timeoutMs: number,
-): Promise<string> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const text = chunks.join('');
-    if (text.includes(expected)) return text;
-    await sleep(25);
-  }
-  throw new Error(
-    `terminal output did not include ${JSON.stringify(expected)} within ${timeoutMs}ms; ` +
-      `output tail=${JSON.stringify(printableTail(chunks.join('')))}`,
-  );
-}
-
-function toShellOctalEscapes(value: string): string {
-  return Array.from(value)
-    .map((char) => `\\${char.codePointAt(0)!.toString(8).padStart(3, '0')}`)
-    .join('');
-}
-
-function payloadOf<T>(frame: AnyFrame): T {
-  assert.ok(frame.payload !== undefined, `${frame.type} frame should carry payload`);
-  return frame.payload as T;
-}
-
-function terminalForLog(terminal: TerminalForLog): Record<string, unknown> {
-  return {
-    id: terminal.id,
-    session_id: terminal.session_id,
-    cwd: terminal.cwd,
-    shell: terminal.shell,
-    cols: terminal.cols,
-    rows: terminal.rows,
-    status: terminal.status,
-    exit_code: terminal.exit_code,
-  };
-}
-
-function frameForLog(frame: AnyFrame): Record<string, unknown> {
-  const terminalFrame = frame as AnyFrame & { terminal_id?: string };
-  return {
-    type: frame.type,
-    session_id: frame.session_id,
-    terminal_id: terminalFrame.terminal_id,
-    seq: frame.seq,
-    payload: frame.payload,
-  };
-}
-
-function printableTail(text: string): string {
-  return text
-    .slice(-1000)
-    .replaceAll('\r', '\\r')
-    .replaceAll('\u001B', '\\x1B');
-}
-
-function log(label: string, value?: unknown): void {
-  recordReportEvent({ kind: 'log', label: `terminal: ${label}`, value });
-  if (value === undefined) {
-    writeLine(`▶ terminal: ${label}`);
-    return;
-  }
-  writeLine(`▶ terminal: ${label} ${JSON.stringify(value)}`);
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-function writeLine(line: string): void {
-  process.stdout.write(`${line}\n`);
-}
-
-try {
-  await main();
-} catch (error) {
-  process.stderr.write(`✗ 11-terminal failed: ${formatError(error)}\n`);
-  process.exit(1);
-}
-
-function formatError(error: unknown): string {
-  if (error instanceof Error) {
-    return `${error.stack ?? error.message}`;
-  }
-  return String(error);
-}
diff --git a/packages/server-e2e/scenarios/README.md b/packages/server-e2e/scenarios/README.md
deleted file mode 100644
index 85c293a96..000000000
--- a/packages/server-e2e/scenarios/README.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# Scenarios
-
-Each `.ts` file under this directory is an executable wire-level test of a
-single user-facing flow against a running server.
-
-## Running
-
-Default base URL is `http://127.0.0.1:58627`. Start a server (`pnpm dev:server`
-from the repo root) before invoking scenarios.
-
-Scenarios import directly from the package's `src/*.ts` so they need a TS
-loader. `tsx` (a workspace devDependency) works out of the box:
-
-```sh
-# Single scenario
-npx tsx packages/server-e2e/scenarios/01-create-and-send.ts
-
-# All scenarios (sequential; first failure exits non-zero)
-pnpm --filter @moonshot-ai/server-e2e test:scenarios
-
-# Custom server URL
-KIMI_SERVER_URL=http://127.0.0.1:8080 npx tsx packages/server-e2e/scenarios/02-tool-call-with-approval.ts
-```
-
-`test:scenarios` writes `reports/latest/index.html` with the scenario timeline,
-including stdout/stderr milestones, HTTP request / response envelopes, and
-WebSocket frames. Set `KIMI_SERVER_E2E_REPORT_DIR=/tmp/server-e2e-report` to write it
-somewhere else.
-
-## Catalog
-
-| File | What it does |
-|---|---|
-| `_template.ts` | Copy-paste starting point. No assertions; smoke-tests the lifecycle. |
-| `01-create-and-send.ts` | Happy path: create session → submit prompt → assert assistant replied with the expected token. |
-| `02-tool-call-with-approval.ts` | Drives a Bash tool call; built-in approval handler auto-approves; asserts canary round-trips through `tool_result` AND assistant text; asserts session ends in `idle`. |
-| `03-refresh-replay.ts` | "User refreshes the browser" worst case: Phase 0 probes (`/healthz`, `/meta`, `/auth`) → WS handshake → prompt to populate the ring buffer → fresh WS with `last_seq_by_session` (caught-up first, then `0` for full replay) → REST snapshot → steady-state follow-up prompt. Asserts replay ordering (seq 1..N) and that no `resync_required` fires while the buffer covers the gap. |
-| `05-workspace.ts` | Workspace registry + folder picker happy path: `fs:home` → `fs:browse $HOME` → `POST /workspaces { root }` → `POST /sessions { workspace_id }` → `GET /sessions?workspace_id=` → prompt round-trip (skipped without provider auth) → `DELETE /workspaces/{id}` (verifies the session survives). |
-| `06-model-catalog.ts` | Model/provider catalog reads and current-default `:set_default` round-trip. |
-| `07-session-children.ts` | Direct child session creation, child prompt execution, direct-child listing, and missing-parent `40401`. |
-| `08-pending-recovery.ts` | Pending approval and pending question recovery APIs, including resolve and pending-list cleanup. |
-| `09-image-file-prompts.ts` | Uploaded file prompt references: missing file, non-image validation, and PNG prompt submission. |
-| `11-terminal.ts` | Terminal flow: create/list/get a session terminal, attach over WS, write input, observe output, resize, close, and assert terminal exit/final state. |
-
-## Writing a new scenario
-
-Copy `_template.ts` and fill in the TODO block.
-
-Conventions:
-- Exit `0` on pass; non-zero on any assertion failure or unhandled rejection.
-- Always `try { ... } finally { close + delete session }`.
-- Print `▶` for milestones and `✓ / ✗` for the final outcome — `test:scenarios`
-  greps for those prefixes when surfacing CI logs.
-- Default timeouts to 60s; tool-call scenarios may want 120s.
-- Use `client.onApprovalRequested` / `client.onQuestionAsked` to auto-resolve
-  reverse-RPC requests — bypassing them risks 60s server-side timeouts that
-  look like flaky scenarios.
diff --git a/packages/server-e2e/scenarios/_template.ts b/packages/server-e2e/scenarios/_template.ts
deleted file mode 100644
index 67aa8ea21..000000000
--- a/packages/server-e2e/scenarios/_template.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/env node
-/**
- * Template scenario — copy-paste starting point.
- *
- * Usage:
- *   KIMI_SERVER_URL=http://127.0.0.1:58627 npx tsx scenarios/_template.ts
- *
- * (`tsx` is a workspace devDependency; it handles the `.ts` imports below.
- * Plain `node` won't resolve them.)
- *
- * Each scenario:
- *   1. Constructs a `DaemonClient` pointed at the live server.
- *   2. Opens an HTTP session and a WS connection.
- *   3. Subscribes to the session, drives some flow, asserts on the result.
- *   4. Cleans up — close the WS, delete the session.
- */
-import { DaemonClient } from '../src/index';
-
-const KIMI_SERVER_URL = process.env['KIMI_SERVER_URL'] ?? 'http://127.0.0.1:58627';
-
-async function main() {
-  const client = new DaemonClient({
-    baseUrl: KIMI_SERVER_URL,
-    logger: (level, msg, meta) => console.log(`[${level}] ${msg}`, meta ?? ''),
-  });
-
-  let sid: string | undefined;
-  try {
-    const session = await client.createSession({ metadata: { cwd: process.cwd() } });
-    sid = session.id;
-
-    await client.connect();
-    await client.subscribe(sid);
-
-    // TODO: drive your scenario here. Examples:
-    //   - await client.submitAndWait(sid, { content: [{ type: 'text', text: '...' }] });
-    //   - client.onApprovalRequested((req) => ({ decision: 'approved' }));
-    //   - const final = await client.waitForFrame(f => f.type === 'turn.ended');
-
-    console.log('✓ scenario template ran (no assertions)');
-  } finally {
-    try {
-      if (sid) await client.archiveSession(sid);
-    } catch {
-      // ignore
-    }
-    await client.close();
-  }
-}
-
-main().catch((err) => {
-  console.error('✗ scenario failed:', err);
-  process.exit(1);
-});
diff --git a/packages/server-e2e/scripts/run-scenarios.ts b/packages/server-e2e/scripts/run-scenarios.ts
deleted file mode 100644
index ffed8b33a..000000000
--- a/packages/server-e2e/scripts/run-scenarios.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-import { createInterface } from 'node:readline';
-import { readdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { spawn } from 'node:child_process';
-
-import {
-  defaultReportDir,
-  recordReportEvent,
-  resetReportDir,
-  writeHtmlReport,
-} from '../src/report.js';
-
-const packageRoot = resolve(import.meta.dirname, '..');
-const scenariosDir = join(packageRoot, 'scenarios');
-const tsxBin = process.platform === 'win32' ? 'tsx.cmd' : 'tsx';
-
-async function main(): Promise<void> {
-  const reportDir = defaultReportDir();
-  resetReportDir(reportDir);
-
-  const scenarios = readdirSync(scenariosDir)
-    .filter((file) => file.endsWith('.ts'))
-    .toSorted();
-
-  let failed = false;
-  for (const file of scenarios) {
-    const caseName = file.slice(0, -'.ts'.length);
-    const scenarioPath = join('scenarios', file);
-    process.stdout.write(`▶ ${scenarioPath}\n`);
-    recordReportEvent(
-      { kind: 'log', caseName, label: 'scenario started', value: { file: scenarioPath } },
-      { reportDir },
-    );
-
-    const result = await runScenario(file, caseName, reportDir);
-    recordReportEvent(
-      {
-        kind: 'test-result',
-        caseName,
-        state: result.exitCode === 0 ? 'passed' : 'failed',
-        error: result.exitCode === 0 ? undefined : { exitCode: result.exitCode },
-      },
-      { reportDir },
-    );
-    if (result.exitCode !== 0) {
-      failed = true;
-      break;
-    }
-  }
-
-  const htmlPath = writeHtmlReport({
-    reportDir,
-    title: `server-e2e scenarios (${failed ? 'failed' : 'passed'})`,
-  });
-  process.stdout.write(`[server-e2e] HTML report: ${htmlPath}\n`);
-  if (failed) process.exit(1);
-}
-
-async function runScenario(
-  file: string,
-  caseName: string,
-  reportDir: string,
-): Promise<{ exitCode: number }> {
-  const child = spawn(tsxBin, [join('scenarios', file)], {
-    cwd: packageRoot,
-    env: {
-      ...process.env,
-      KIMI_SERVER_E2E_CASE_NAME: caseName,
-      KIMI_SERVER_E2E_REPORT_DIR: reportDir,
-    },
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  captureLines(child.stdout, caseName, 'stdout', reportDir);
-  captureLines(child.stderr, caseName, 'stderr', reportDir);
-
-  return new Promise((resolveScenario) => {
-    child.on('error', (error) => {
-      recordReportEvent(
-        {
-          kind: 'log',
-          caseName,
-          label: 'spawn error',
-          value: { name: error.name, message: error.message },
-        },
-        { reportDir },
-      );
-      resolveScenario({ exitCode: 1 });
-    });
-    child.on('close', (code) => {
-      resolveScenario({ exitCode: code ?? 1 });
-    });
-  });
-}
-
-function captureLines(
-  stream: NodeJS.ReadableStream,
-  caseName: string,
-  label: 'stdout' | 'stderr',
-  reportDir: string,
-): void {
-  const lines = createInterface({ input: stream });
-  lines.on('line', (line) => {
-    const output = label === 'stderr' ? process.stderr : process.stdout;
-    output.write(`${line}\n`);
-    recordReportEvent({ kind: 'log', caseName, label, value: line }, { reportDir });
-  });
-}
-
-try {
-  await main();
-} catch (error) {
-  recordReportEvent({
-    kind: 'test-result',
-    caseName: 'scenario runner',
-    state: 'failed',
-    error: error instanceof Error ? { name: error.name, message: error.message } : error,
-  });
-  const htmlPath = writeHtmlReport({
-    title: 'server-e2e scenarios (failed)',
-  });
-  process.stderr.write(`✗ scenario runner failed: ${String(error)}\n`);
-  process.stderr.write(`[server-e2e] HTML report: ${htmlPath}\n`);
-  process.exit(1);
-}
diff --git a/packages/server-e2e/src/v2/client.ts b/packages/server-e2e/src/v2/client.ts
deleted file mode 100644
index e3eef8903..000000000
--- a/packages/server-e2e/src/v2/client.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-/**
- * `ServerClient` — the lark-style client SDK for `server-v2` (`/api/v2`).
- *
- * Resource tree mirrors the server's `actionMap`:
- *   sdk.sessions.list({ page_size: 20 })               // core
- *   sdk.workspaces.createOrTouch('/path')              // core
- *   sdk.session(sid).setTitle('renamed')               // session (flattened)
- *   sdk.session(sid).approvals.decide(aid, body)       // session resource
- *   sdk.session(sid).agent('main').prompts.submit({…}) // agent resource
- *
- * RPC runs over HTTP (`POST <resource>:<action>`); events run over a single
- * `/api/v2/ws` socket opened by `connect()`. The legacy `/api/v1` REST surface
- * is still reachable via `sdk.v1` (the unchanged v1 `HttpClient`).
- */
-import { HttpClient } from '../http.js';
-
-import { createCoreResources, type CoreResources } from './resources/core.js';
-import { EventsClient } from './resources/events.js';
-import { SessionScope } from './resources/session.js';
-import { HttpRpc, type ScopeKind, type ScopeParams } from './transport/http.js';
-import {
-  type AnyMethod,
-  type DynamicResource,
-  makeDynamicResource,
-} from './transport/rpcProxy.js';
-import { V2Socket, type V2SocketOptions } from './transport/ws.js';
-
-export interface ServerClientOptions {
-  /** Base URL of the server, e.g. `http://127.0.0.1:58627`. */
-  readonly baseUrl: string;
-  /** Default `/api/v2`. */
-  readonly apiPrefix?: string;
-  /** Optional bearer token (sent on HTTP + WS upgrade). */
-  readonly token?: string;
-  /** Override `fetch` (testing). */
-  readonly fetchImpl?: typeof fetch;
-  /** Override the WebSocket implementation (testing / browser). */
-  readonly wsImpl?: V2SocketOptions['wsImpl'];
-  /** Default 30s. Per-RPC-call deadline on the WS transport. */
-  readonly callTimeoutMs?: number;
-  /** Directory for v1 report capture (passed through to the v1 `HttpClient`). */
-  readonly reportDir?: string;
-}
-
-export class ServerClient implements CoreResources {
-  readonly baseUrl: string;
-  readonly apiPrefix: string;
-
-  /** Legacy `/api/v1` REST client (unchanged). */
-  readonly v1: HttpClient;
-
-  readonly sessions: CoreResources['sessions'];
-  readonly workspaces: CoreResources['workspaces'];
-  readonly config: CoreResources['config'];
-  readonly providers: CoreResources['providers'];
-  readonly oauth: CoreResources['oauth'];
-  readonly auth: CoreResources['auth'];
-  readonly flags: CoreResources['flags'];
-  readonly plugins: CoreResources['plugins'];
-  readonly fs: CoreResources['fs'];
-  readonly meta: CoreResources['meta'];
-
-  private readonly rpc: HttpRpc;
-  private readonly token: string | undefined;
-  private readonly wsImpl: ServerClientOptions['wsImpl'];
-  private readonly callTimeoutMs: number | undefined;
-
-  private socket: V2Socket | null = null;
-  private eventsClient: EventsClient | null = null;
-
-  constructor(opts: ServerClientOptions) {
-    this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
-    this.apiPrefix = opts.apiPrefix ?? '/api/v2';
-    this.token = opts.token;
-    this.wsImpl = opts.wsImpl;
-    this.callTimeoutMs = opts.callTimeoutMs;
-
-    this.rpc = new HttpRpc({
-      baseUrl: this.baseUrl,
-      apiPrefix: this.apiPrefix,
-      token: opts.token,
-      fetchImpl: opts.fetchImpl,
-    });
-
-    const core = createCoreResources(this.rpc);
-    this.sessions = core.sessions;
-    this.workspaces = core.workspaces;
-    this.config = core.config;
-    this.providers = core.providers;
-    this.oauth = core.oauth;
-    this.auth = core.auth;
-    this.flags = core.flags;
-    this.plugins = core.plugins;
-    this.fs = core.fs;
-    this.meta = core.meta;
-
-    this.v1 = new HttpClient({
-      baseUrl: this.baseUrl,
-      apiPrefix: '/api/v1',
-      fetchImpl: opts.fetchImpl ?? fetch,
-      reportDir: opts.reportDir,
-      token: opts.token,
-    });
-  }
-
-  /** Enter the session scope for `sessionId`. */
-  session(sessionId: string): SessionScope {
-    return new SessionScope(this.rpc, sessionId);
-  }
-
-  /** Escape hatch for a core resource not (yet) in the manifest. */
-  core<T extends Record<string, AnyMethod> = DynamicResource>(resource: string): T {
-    return makeDynamicResource(this.rpc, 'core', {}, resource) as T;
-  }
-
-  /** Raw RPC — call any `<resource>:<action>` in any scope. */
-  call<T>(scope: ScopeKind, params: ScopeParams, sa: string, arg?: unknown): Promise<T> {
-    return this.rpc.call<T>(scope, params, sa, arg);
-  }
-
-  /** Open the `/api/v2/ws` socket and return the events client. Idempotent. */
-  async connect(): Promise<EventsClient> {
-    if (this.eventsClient) return this.eventsClient;
-    const socket = new V2Socket({
-      baseUrl: this.baseUrl,
-      apiPrefix: this.apiPrefix,
-      token: this.token,
-      wsImpl: this.wsImpl,
-      callTimeoutMs: this.callTimeoutMs,
-    });
-    await socket.connect();
-    this.socket = socket;
-    this.eventsClient = new EventsClient(socket);
-    return this.eventsClient;
-  }
-
-  /** The events client. Throws if `connect()` has not been called. */
-  get events(): EventsClient {
-    if (!this.eventsClient) {
-      throw new Error('events not connected — call `await client.connect()` first');
-    }
-    return this.eventsClient;
-  }
-
-  /** Close the WS socket (if open). HTTP RPC is stateless and needs no close. */
-  async close(): Promise<void> {
-    if (this.socket) {
-      await this.socket.close();
-      this.socket = null;
-      this.eventsClient = null;
-    }
-  }
-}
diff --git a/packages/server-e2e/src/v2/errors.ts b/packages/server-e2e/src/v2/errors.ts
deleted file mode 100644
index 5b7fa19fd..000000000
--- a/packages/server-e2e/src/v2/errors.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * v2 RPC error + unwrap helpers.
- *
- * The `/api/v2` surface uses the same `{ code, msg, data, request_id }`
- * envelope as v1, but unlike v1 it legitimately returns `code: 0` with
- * `data: null` for "no body" actions (e.g. `session:setTitle`). The v1
- * `unwrap()` in `envelope.ts` treats `data === null` as a hard error, so v2
- * needs its own unwrap that only rejects on `code !== 0`.
- */
-import type { Envelope } from '@moonshot-ai/protocol';
-
-/** Thrown when an `/api/v2` call lands with a non-zero `code`. */
-export class RpcError extends Error {
-  readonly code: number;
-  readonly requestId: string | undefined;
-  readonly details: unknown;
-
-  constructor(envelope: Envelope<unknown>) {
-    super(`server-v2 returned code=${envelope.code}: ${envelope.msg}`);
-    this.name = 'RpcError';
-    this.code = envelope.code;
-    this.requestId = envelope.request_id;
-    this.details = (envelope as { details?: unknown }).details;
-  }
-}
-
-/**
- * Unwrap a v2 envelope. Returns `data` (which may be `null`) on `code === 0`;
- * throws {@link RpcError} otherwise.
- */
-export function unwrapData<T>(envelope: Envelope<T>): T {
-  if (envelope.code !== 0) throw new RpcError(envelope as Envelope<unknown>);
-  // The protocol envelope types `data` as `T | null`; v2 actions that return a
-  // body are typed `T` (non-null) by the caller, and `code: 0` + null data is a
-  // legitimate "no body" success for actions typed `T = null`. Cast through.
-  return envelope.data as T;
-}
diff --git a/packages/server-e2e/src/v2/index.ts b/packages/server-e2e/src/v2/index.ts
deleted file mode 100644
index 7c606fb39..000000000
--- a/packages/server-e2e/src/v2/index.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * `@moonshot-ai/server-e2e` v2 SDK — a lark-style, typed client for the
- * `server-v2` `/api/v2` RPC + WS surface.
- *
- *   import { ServerClient } from '@moonshot-ai/server-e2e';
- *
- *   const sdk = new ServerClient({ baseUrl: 'http://127.0.0.1:58627', token });
- *   const { items } = await sdk.sessions.list({ page_size: 20 });
- *   await sdk.session(items[0].id).setTitle('renamed');
- *   await sdk.session(items[0].id).agent('main').prompts.submit({ input: [...] });
- *
- *   const events = await sdk.connect();
- *   const off = events.onAgentEvents(sid, 'main', (e) => { ... });
- *
- * The legacy `/api/v1` REST surface is reachable via `sdk.v1`.
- */
-export { ServerClient } from './client.js';
-export type { ServerClientOptions } from './client.js';
-
-export { SessionScope } from './resources/session.js';
-export { AgentScope } from './resources/agent.js';
-export { EventsClient } from './resources/events.js';
-export type { Unlisten } from './resources/events.js';
-
-export type {
-  CoreResources,
-  SessionsResource,
-  WorkspacesResource,
-  ConfigResource,
-  ProvidersResource,
-  OAuthResource,
-  AuthResource,
-  FlagsResource,
-  PluginsResource,
-  CoreFsResource,
-  MetaResource,
-} from './resources/core.js';
-export type {
-  SessionResource,
-  ApprovalsResource,
-  QuestionsResource,
-  InteractionsResource,
-  SessionWorkspaceResource,
-  SessionFsResource,
-} from './resources/session.js';
-export type {
-  GoalResource,
-  PlanResource,
-  TasksResource,
-  UsageResource,
-  ContextResource,
-  SwarmResource,
-  PermissionResource,
-  PermissionRulesResource,
-  ProfileResource,
-  MessagesResource,
-  McpResource,
-  ToolsResource,
-  PromptsResource,
-  ShellResource,
-  AgentPluginsResource,
-} from './resources/agent.js';
-
-export type {
-  SessionMeta,
-  SessionActivityStatus,
-  WorkspaceInfo,
-  ListResult,
-  PromptSubmitArg,
-  PromptInputPart,
-  PromptSubmitResult,
-  ShellRunArg,
-  ShellRunResult,
-} from './resources/types.js';
-
-export { CORE, SESSION, AGENT, flattenManifest } from './resources/manifest.js';
-export type { CoreManifest, SessionManifest, AgentManifest } from './resources/manifest.js';
-
-export { HttpRpc } from './transport/http.js';
-export type { HttpRpcOptions, ScopeKind, ScopeParams } from './transport/http.js';
-export {
-  makeResource,
-  makeDynamicResource,
-  type ActionMeta,
-  type AnyMethod,
-  type DynamicResource,
-  type ResourceShape,
-} from './transport/rpcProxy.js';
-export { V2Socket } from './transport/ws.js';
-export type { V2SocketOptions } from './transport/ws.js';
-
-export { RpcError, unwrapData } from './errors.js';
diff --git a/packages/server-e2e/src/v2/resources/agent.ts b/packages/server-e2e/src/v2/resources/agent.ts
deleted file mode 100644
index b90dfd274..000000000
--- a/packages/server-e2e/src/v2/resources/agent.ts
+++ /dev/null
@@ -1,109 +0,0 @@
-/**
- * Agent-scope resources — `/api/v2/session/<sid>/agent/<aid>/<resource>:<action>`.
- *
- * Exposes one typed resource per entry in the `AGENT` manifest, plus a
- * `service<T>(resource)` escape hatch for actions not (yet) in the manifest.
- */
-import type { HttpRpc } from '../transport/http.js';
-import {
-  type AnyMethod,
-  type DynamicResource,
-  makeDynamicResource,
-  makeResource,
-  type ResourceShape,
-} from '../transport/rpcProxy.js';
-
-import { AGENT, type AgentManifest } from './manifest.js';
-import type { ProfilePrecise, PromptsPrecise, ShellPrecise } from './types.js';
-
-export type GoalResource = ResourceShape<AgentManifest['goal']>;
-export type PlanResource = ResourceShape<AgentManifest['plan']>;
-export type TasksResource = ResourceShape<AgentManifest['tasks']>;
-export type UsageResource = ResourceShape<AgentManifest['usage']>;
-export type ContextResource = ResourceShape<AgentManifest['context']>;
-export type SwarmResource = ResourceShape<AgentManifest['swarm']>;
-export type PermissionResource = ResourceShape<AgentManifest['permission']>;
-export type PermissionRulesResource = ResourceShape<AgentManifest['permissionRules']>;
-export type ProfileResource = ResourceShape<AgentManifest['profile'], ProfilePrecise>;
-export type MessagesResource = ResourceShape<AgentManifest['messages']>;
-export type McpResource = ResourceShape<AgentManifest['mcp']>;
-export type ToolsResource = ResourceShape<AgentManifest['tools']>;
-export type PromptsResource = ResourceShape<AgentManifest['prompts'], PromptsPrecise>;
-export type ShellResource = ResourceShape<AgentManifest['shell'], ShellPrecise>;
-export type AgentPluginsResource = ResourceShape<AgentManifest['plugins']>;
-
-/** Agent scope handle — obtained via `session.agent(agentId)`. */
-export class AgentScope {
-  readonly goal: GoalResource;
-  readonly plan: PlanResource;
-  readonly tasks: TasksResource;
-  readonly usage: UsageResource;
-  readonly context: ContextResource;
-  readonly swarm: SwarmResource;
-  readonly permission: PermissionResource;
-  readonly permissionRules: PermissionRulesResource;
-  readonly profile: ProfileResource;
-  readonly messages: MessagesResource;
-  readonly mcp: McpResource;
-  readonly tools: ToolsResource;
-  readonly prompts: PromptsResource;
-  readonly shell: ShellResource;
-  readonly plugins: AgentPluginsResource;
-
-  constructor(
-    private readonly rpc: HttpRpc,
-    readonly sessionId: string,
-    readonly agentId: string,
-  ) {
-    const params = { sessionId, agentId };
-    this.goal = makeResource(rpc, 'agent', params, 'goal', AGENT.goal);
-    this.plan = makeResource(rpc, 'agent', params, 'plan', AGENT.plan);
-    this.tasks = makeResource(rpc, 'agent', params, 'tasks', AGENT.tasks);
-    this.usage = makeResource(rpc, 'agent', params, 'usage', AGENT.usage);
-    this.context = makeResource(rpc, 'agent', params, 'context', AGENT.context);
-    this.swarm = makeResource(rpc, 'agent', params, 'swarm', AGENT.swarm);
-    this.permission = makeResource(rpc, 'agent', params, 'permission', AGENT.permission);
-    this.permissionRules = makeResource(
-      rpc,
-      'agent',
-      params,
-      'permissionRules',
-      AGENT.permissionRules,
-    );
-    this.profile = makeResource<AgentManifest['profile'], ProfilePrecise>(
-      rpc,
-      'agent',
-      params,
-      'profile',
-      AGENT.profile,
-    );
-    this.messages = makeResource(rpc, 'agent', params, 'messages', AGENT.messages);
-    this.mcp = makeResource(rpc, 'agent', params, 'mcp', AGENT.mcp);
-    this.tools = makeResource(rpc, 'agent', params, 'tools', AGENT.tools);
-    this.prompts = makeResource<AgentManifest['prompts'], PromptsPrecise>(
-      rpc,
-      'agent',
-      params,
-      'prompts',
-      AGENT.prompts,
-    );
-    this.shell = makeResource<AgentManifest['shell'], ShellPrecise>(
-      rpc,
-      'agent',
-      params,
-      'shell',
-      AGENT.shell,
-    );
-    this.plugins = makeResource(rpc, 'agent', params, 'plugins', AGENT.plugins);
-  }
-
-  /** Escape hatch for an agent resource not (yet) in the manifest. */
-  service<T extends Record<string, AnyMethod> = DynamicResource>(resource: string): T {
-    return makeDynamicResource(
-      this.rpc,
-      'agent',
-      { sessionId: this.sessionId, agentId: this.agentId },
-      resource,
-    ) as T;
-  }
-}
diff --git a/packages/server-e2e/src/v2/resources/core.ts b/packages/server-e2e/src/v2/resources/core.ts
deleted file mode 100644
index a1bce109a..000000000
--- a/packages/server-e2e/src/v2/resources/core.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * Core-scope resources — `/api/v2/<resource>:<action>`.
- *
- * Exposes one typed resource per entry in the `CORE` manifest, plus the
- * resource-shape types for reuse by the client.
- */
-import type { HttpRpc } from '../transport/http.js';
-import { makeResource, type ResourceShape } from '../transport/rpcProxy.js';
-
-import { CORE, type CoreManifest } from './manifest.js';
-import type { SessionsPrecise, WorkspacesPrecise } from './types.js';
-
-export type SessionsResource = ResourceShape<CoreManifest['sessions'], SessionsPrecise>;
-export type WorkspacesResource = ResourceShape<CoreManifest['workspaces'], WorkspacesPrecise>;
-export type ConfigResource = ResourceShape<CoreManifest['config']>;
-export type ProvidersResource = ResourceShape<CoreManifest['providers']>;
-export type OAuthResource = ResourceShape<CoreManifest['oauth']>;
-export type AuthResource = ResourceShape<CoreManifest['auth']>;
-export type FlagsResource = ResourceShape<CoreManifest['flags']>;
-export type PluginsResource = ResourceShape<CoreManifest['plugins']>;
-export type CoreFsResource = ResourceShape<CoreManifest['fs']>;
-export type MetaResource = ResourceShape<CoreManifest['meta']>;
-
-/** The core-scope resource tree exposed on `ServerClient`. */
-export interface CoreResources {
-  readonly sessions: SessionsResource;
-  readonly workspaces: WorkspacesResource;
-  readonly config: ConfigResource;
-  readonly providers: ProvidersResource;
-  readonly oauth: OAuthResource;
-  readonly auth: AuthResource;
-  readonly flags: FlagsResource;
-  readonly plugins: PluginsResource;
-  readonly fs: CoreFsResource;
-  readonly meta: MetaResource;
-}
-
-export function createCoreResources(rpc: HttpRpc): CoreResources {
-  return {
-    sessions: makeResource<CoreManifest['sessions'], SessionsPrecise>(
-      rpc,
-      'core',
-      {},
-      'sessions',
-      CORE.sessions,
-    ),
-    workspaces: makeResource<CoreManifest['workspaces'], WorkspacesPrecise>(
-      rpc,
-      'core',
-      {},
-      'workspaces',
-      CORE.workspaces,
-    ),
-    config: makeResource(rpc, 'core', {}, 'config', CORE.config),
-    providers: makeResource(rpc, 'core', {}, 'providers', CORE.providers),
-    oauth: makeResource(rpc, 'core', {}, 'oauth', CORE.oauth),
-    auth: makeResource(rpc, 'core', {}, 'auth', CORE.auth),
-    flags: makeResource(rpc, 'core', {}, 'flags', CORE.flags),
-    plugins: makeResource(rpc, 'core', {}, 'plugins', CORE.plugins),
-    fs: makeResource(rpc, 'core', {}, 'fs', CORE.fs),
-    meta: makeResource(rpc, 'core', {}, 'meta', CORE.meta),
-  };
-}
diff --git a/packages/server-e2e/src/v2/resources/events.ts b/packages/server-e2e/src/v2/resources/events.ts
deleted file mode 100644
index dd02f195f..000000000
--- a/packages/server-e2e/src/v2/resources/events.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-/**
- * Typed `/api/v2/ws` event subscriptions.
- *
- * Wraps a {@link V2Socket} with one method per event the server exposes
- * (see `server-v2/src/transport/ws/eventMap.ts`):
- *   core    `events`                  — process-wide domain event bus
- *   session `interactions`            — pending human-in-the-loop requests
- *   session `interactions:resolved`   — request resolutions
- *   agent   `events`                  — per-agent event stream
- *
- * Payloads are typed as `unknown` by default (the concrete unions live in
- * `agent-core-v2`, which this wire client does not depend on); pass a type
- * parameter to narrow.
- */
-import type { RpcError } from '../errors.js';
-import type { ScopeKind, ScopeParams } from '../transport/http.js';
-import type { V2Socket } from '../transport/ws.js';
-
-/** An `unlisten` handle — call it to stop receiving events. */
-export type Unlisten = () => void;
-
-export class EventsClient {
-  constructor(private readonly socket: V2Socket) {}
-
-  /** Generic listen — prefer the typed helpers below. */
-  listen<T = unknown>(
-    scope: ScopeKind,
-    params: ScopeParams,
-    event: string,
-    handler: (data: T) => void,
-    onError?: (err: RpcError) => void,
-  ): Unlisten {
-    return this.socket.listen(
-      scope,
-      params,
-      event,
-      (data) => handler(data as T),
-      onError,
-    );
-  }
-
-  /** Subscribe to the core (process-wide) domain event bus. */
-  onCoreEvents<T = unknown>(handler: (data: T) => void): Unlisten {
-    return this.listen('core', {}, 'events', handler);
-  }
-
-  /** Subscribe to a session's pending human-in-the-loop interactions. */
-  onSessionInteractions<T = unknown>(sessionId: string, handler: (data: T) => void): Unlisten {
-    return this.listen('session', { sessionId }, 'interactions', handler);
-  }
-
-  /** Subscribe to a session's interaction resolutions. */
-  onSessionInteractionsResolved<T = unknown>(
-    sessionId: string,
-    handler: (data: T) => void,
-  ): Unlisten {
-    return this.listen('session', { sessionId }, 'interactions:resolved', handler);
-  }
-
-  /** Subscribe to an agent's event stream. */
-  onAgentEvents<T = unknown>(
-    sessionId: string,
-    agentId: string,
-    handler: (data: T) => void,
-  ): Unlisten {
-    return this.listen('agent', { sessionId, agentId }, 'events', handler);
-  }
-}
diff --git a/packages/server-e2e/src/v2/resources/manifest.ts b/packages/server-e2e/src/v2/resources/manifest.ts
deleted file mode 100644
index 28d42b34e..000000000
--- a/packages/server-e2e/src/v2/resources/manifest.ts
+++ /dev/null
@@ -1,115 +0,0 @@
-/**
- * `/api/v2` resource manifest — the SDK's view of the server surface.
- *
- * Mirrors `server-v2/src/transport/actionMap.ts` exactly (same
- * `resource:action` set, same `readonly` flags). The runtime proxies and the
- * derived TypeScript shapes are both built from these tables, so the resource
- * tree and its types can never disagree.
- *
- * A drift test (`test/v2/actionMap.test.ts`) cross-checks these manifests
- * against the server's `actionMap`; a server change that adds/removes an
- * action fails the test until the manifest (and types) catch up.
- */
-import type { ActionMeta } from '../transport/rpcProxy.js';
-
-type Manifest = Record<string, Record<string, ActionMeta>>;
-
-const RO: ActionMeta = { readonly: true };
-const RW: ActionMeta = {};
-
-/** Core scope — `/api/v2/<resource>:<action>`. */
-export const CORE = {
-  sessions: { list: RO, get: RO, countActive: RO },
-  workspaces: { list: RO, get: RO, createOrTouch: RW, update: RW, delete: RW },
-  config: {
-    get: RO,
-    getAll: RO,
-    inspect: RO,
-    diagnostics: RO,
-    set: RW,
-    replace: RW,
-    reload: RW,
-  },
-  providers: { list: RO, get: RO, set: RW, delete: RW },
-  oauth: { startLogin: RW, getFlow: RO, cancelLogin: RW, logout: RW, status: RO },
-  auth: { summarize: RO, ensureReady: RW },
-  flags: { snapshot: RO, enabled: RO, enabledIds: RO, explain: RO, explainAll: RO },
-  plugins: {
-    list: RO,
-    install: RW,
-    setEnabled: RW,
-    setMcpServerEnabled: RW,
-    remove: RW,
-    reload: RW,
-    getInfo: RO,
-    listCommands: RO,
-    checkUpdates: RO,
-  },
-  fs: { browse: RO, home: RO },
-  meta: { getEnv: RO, detect: RO },
-} as const satisfies Manifest;
-
-/** Session scope — `/api/v2/session/<sid>/<resource>:<action>`. */
-export const SESSION = {
-  session: {
-    read: RO,
-    update: RW,
-    setTitle: RW,
-    setArchived: RW,
-    status: RO,
-    isIdle: RO,
-    archive: RW,
-  },
-  approvals: { listPending: RO, request: RW, decide: RW },
-  questions: { listPending: RO, ask: RW, answer: RW },
-  interactions: { listPending: RO, request: RW, respond: RW },
-  workspace: {
-    resolve: RO,
-    isWithin: RO,
-    setWorkDir: RW,
-    addAdditionalDir: RW,
-    removeAdditionalDir: RW,
-  },
-  fs: { search: RO, grep: RO, gitStatus: RO, diff: RO },
-} as const satisfies Manifest;
-
-/** Agent scope — `/api/v2/session/<sid>/agent/<aid>/<resource>:<action>`. */
-export const AGENT = {
-  goal: { get: RO, create: RW, pause: RW, resume: RW, cancel: RW },
-  plan: { status: RO, enter: RW, exit: RW, cancel: RW, clear: RW },
-  tasks: { list: RO, get: RO, readOutput: RO, stop: RW, detach: RW },
-  usage: { status: RO },
-  context: { status: RO },
-  swarm: { isActive: RO, enter: RW, exit: RW },
-  permission: { getMode: RO, setMode: RW },
-  permissionRules: { list: RO, addRules: RW },
-  profile: {
-    get: RO,
-    getModel: RO,
-    getSystemPrompt: RO,
-    getActiveToolNames: RO,
-    setModel: RW,
-    setThinking: RW,
-  },
-  messages: { list: RO, splice: RW },
-  mcp: { list: RO, reconnect: RW },
-  tools: { list: RO },
-  prompts: { submit: RW, steer: RW, undo: RW, clear: RW, cancel: RW },
-  shell: { run: RW, cancel: RW },
-  plugins: { activateCommand: RW },
-} as const satisfies Manifest;
-
-export type CoreManifest = typeof CORE;
-export type SessionManifest = typeof SESSION;
-export type AgentManifest = typeof AGENT;
-
-/** Flatten a manifest to a sorted list of `resource:action` strings. */
-export function flattenManifest(manifest: Manifest): string[] {
-  const out: string[] = [];
-  for (const resource of Object.keys(manifest)) {
-    for (const action of Object.keys(manifest[resource]!)) {
-      out.push(`${resource}:${action}`);
-    }
-  }
-  return out.sort();
-}
diff --git a/packages/server-e2e/src/v2/resources/session.ts b/packages/server-e2e/src/v2/resources/session.ts
deleted file mode 100644
index 46cdad538..000000000
--- a/packages/server-e2e/src/v2/resources/session.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- * Session-scope resources — `/api/v2/session/<sid>/<resource>:<action>`.
- *
- * The `session` resource (read/update/setTitle/setArchived/status/isIdle/
- * archive) is flattened onto the {@link SessionScope} handle itself, since it
- * is the primary thing you do with a session; every other resource
- * (`approvals`, `questions`, `interactions`, `workspace`, `fs`) is
- * a sub-namespace. `agent(agentId)` enters the agent scope, and
- * `service<T>(resource)` is the escape hatch for actions not in the manifest.
- */
-import type { HttpRpc } from '../transport/http.js';
-import {
-  type AnyMethod,
-  type DynamicResource,
-  makeDynamicResource,
-  makeResource,
-  type ResourceShape,
-} from '../transport/rpcProxy.js';
-
-import { AgentScope } from './agent.js';
-import { SESSION, type SessionManifest } from './manifest.js';
-import type {
-  SessionActivityStatus,
-  SessionMeta,
-  SessionResourcePrecise,
-} from './types.js';
-
-export type SessionResource = ResourceShape<SessionManifest['session'], SessionResourcePrecise>;
-export type ApprovalsResource = ResourceShape<SessionManifest['approvals']>;
-export type QuestionsResource = ResourceShape<SessionManifest['questions']>;
-export type InteractionsResource = ResourceShape<SessionManifest['interactions']>;
-export type SessionWorkspaceResource = ResourceShape<SessionManifest['workspace']>;
-export type SessionFsResource = ResourceShape<SessionManifest['fs']>;
-
-/** Session scope handle — obtained via `client.session(sessionId)`. */
-export class SessionScope {
-  readonly approvals: ApprovalsResource;
-  readonly questions: QuestionsResource;
-  readonly interactions: InteractionsResource;
-  readonly workspace: SessionWorkspaceResource;
-  readonly fs: SessionFsResource;
-
-  private readonly sessionResource: SessionResource;
-
-  constructor(
-    private readonly rpc: HttpRpc,
-    readonly sessionId: string,
-  ) {
-    const params = { sessionId };
-    this.sessionResource = makeResource<SessionManifest['session'], SessionResourcePrecise>(
-      rpc,
-      'session',
-      params,
-      'session',
-      SESSION.session,
-    );
-    this.approvals = makeResource(rpc, 'session', params, 'approvals', SESSION.approvals);
-    this.questions = makeResource(rpc, 'session', params, 'questions', SESSION.questions);
-    this.interactions = makeResource(rpc, 'session', params, 'interactions', SESSION.interactions);
-    this.workspace = makeResource(rpc, 'session', params, 'workspace', SESSION.workspace);
-    this.fs = makeResource(rpc, 'session', params, 'fs', SESSION.fs);
-  }
-
-  // ── Flattened `session` resource ─────────────────────────────────────────
-  read(arg?: unknown): Promise<SessionMeta> {
-    return this.sessionResource.read(arg);
-  }
-  update(arg?: unknown): Promise<SessionMeta> {
-    return this.sessionResource.update(arg);
-  }
-  setTitle(arg?: string): Promise<null> {
-    return this.sessionResource.setTitle(arg);
-  }
-  setArchived(arg?: boolean): Promise<null> {
-    return this.sessionResource.setArchived(arg);
-  }
-  status(arg?: unknown): Promise<SessionActivityStatus> {
-    return this.sessionResource.status(arg);
-  }
-  isIdle(arg?: unknown): Promise<boolean> {
-    return this.sessionResource.isIdle(arg);
-  }
-  archive(arg?: unknown): Promise<null> {
-    return this.sessionResource.archive(arg ?? this.sessionId);
-  }
-
-  /** Enter the agent scope for `agentId`. */
-  agent(agentId: string): AgentScope {
-    return new AgentScope(this.rpc, this.sessionId, agentId);
-  }
-
-  /** Escape hatch for a session resource not (yet) in the manifest. */
-  service<T extends Record<string, AnyMethod> = DynamicResource>(resource: string): T {
-    return makeDynamicResource(this.rpc, 'session', { sessionId: this.sessionId }, resource) as T;
-  }
-}
diff --git a/packages/server-e2e/src/v2/resources/types.ts b/packages/server-e2e/src/v2/resources/types.ts
deleted file mode 100644
index 99ca2ea4d..000000000
--- a/packages/server-e2e/src/v2/resources/types.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-/**
- * Precise wire types for the high-value `/api/v2` actions.
- *
- * Only the actions the SDK wants strong typing for are listed here; everything
- * else falls back to `(arg?: unknown) => Promise<unknown>` via `ResourceShape`.
- * Shapes are derived from the server's own `server-v2/test/rpc.test.ts` wire
- * examples and are intentionally loose on unknown fields (`[k: string]: unknown`
- * or optional keys) so the server can evolve without breaking the client.
- *
- * Every override uses an optional arg to match the wire, where every action body
- * is optional.
- */
-
-// ── Shared wire shapes ─────────────────────────────────────────────────────
-
-/** Session metadata as returned by `sessions:get` / `session:read`. */
-export interface SessionMeta {
-  readonly id: string;
-  readonly title?: string;
-  readonly createdAt?: number;
-  readonly updatedAt?: number;
-  readonly archived?: boolean;
-  readonly [k: string]: unknown;
-}
-
-/** `session:status` result. The server may add new states; keep it open. */
-export type SessionActivityStatus =
-  | 'idle'
-  | 'running'
-  | 'awaiting_approval'
-  | 'awaiting_question'
-  | (string & {});
-
-/** Workspace record as returned by `workspaces:*`. */
-export interface WorkspaceInfo {
-  readonly id: string;
-  readonly root: string;
-  readonly name?: string;
-  readonly [k: string]: unknown;
-}
-
-/** Generic paginated list envelope used by list actions. */
-export interface ListResult<T> {
-  readonly items: readonly T[];
-  readonly has_more?: boolean;
-}
-
-/** `prompts:submit` argument. `input` is the only required field. */
-export interface PromptSubmitArg {
-  readonly input: readonly PromptInputPart[];
-  readonly [k: string]: unknown;
-}
-
-export type PromptInputPart = { readonly type: 'text'; readonly text: string } | {
-  readonly type: string;
-  readonly [k: string]: unknown;
-};
-
-/** `prompts:submit` result. */
-export interface PromptSubmitResult {
-  readonly turn_id: number;
-  readonly [k: string]: unknown;
-}
-
-/** `shell:run` argument. */
-export interface ShellRunArg {
-  readonly command: string;
-  readonly [k: string]: unknown;
-}
-
-/** `shell:run` result. */
-export interface ShellRunResult {
-  readonly stdout: string;
-  readonly stderr: string;
-  readonly isError?: boolean;
-  readonly [k: string]: unknown;
-}
-
-// ── Precise override maps (keyed by action name) ───────────────────────────
-
-export interface SessionsPrecise {
-  list(arg?: { page_size?: number; [k: string]: unknown }): Promise<ListResult<SessionMeta>>;
-  get(arg?: string): Promise<SessionMeta>;
-  countActive(arg?: string): Promise<number>;
-}
-
-export interface WorkspacesPrecise {
-  list(arg?: unknown): Promise<ListResult<WorkspaceInfo>>;
-  get(arg?: string): Promise<WorkspaceInfo>;
-  createOrTouch(arg?: string): Promise<WorkspaceInfo>;
-  update(arg?: [string, { name?: string }]): Promise<WorkspaceInfo>;
-  delete(arg?: string): Promise<null>;
-}
-
-/** The `session` resource at session scope (read/update/setTitle/…). */
-export interface SessionResourcePrecise {
-  read(arg?: unknown): Promise<SessionMeta>;
-  update(arg?: unknown): Promise<SessionMeta>;
-  setTitle(arg?: string): Promise<null>;
-  setArchived(arg?: boolean): Promise<null>;
-  status(arg?: unknown): Promise<SessionActivityStatus>;
-  isIdle(arg?: unknown): Promise<boolean>;
-  archive(arg?: unknown): Promise<null>;
-}
-
-export interface PromptsPrecise {
-  submit(arg?: PromptSubmitArg): Promise<PromptSubmitResult>;
-}
-
-export interface ShellPrecise {
-  run(arg?: ShellRunArg): Promise<ShellRunResult>;
-  cancel(arg?: unknown): Promise<null>;
-}
-
-export interface ProfilePrecise {
-  getModel(arg?: unknown): Promise<string>;
-}
diff --git a/packages/server-e2e/src/v2/transport/http.ts b/packages/server-e2e/src/v2/transport/http.ts
deleted file mode 100644
index 1908d76f9..000000000
--- a/packages/server-e2e/src/v2/transport/http.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * `/api/v2` HTTP transport — `POST`s a `resource:action` to the scope URL and
- * unwraps the envelope. One {@link HttpRpc} is shared by every resource proxy
- * on a client.
- *
- * URL shapes (mirror `server-v2/src/transport/registerRpcRoutes.ts`):
- *   POST /api/v2/<resource>:<action>                                   core
- *   POST /api/v2/session/<session_id>/<resource>:<action>              session
- *   POST /api/v2/session/<session_id>/agent/<agent_id>/<resource>:<action>  agent
- *
- * The server also accepts `GET ?arg=<json>` for `readonly` actions; this
- * transport always POSTs (write actions are POST-only, and POST works for
- * reads too) to keep the client single-path.
- */
-import type { Envelope } from '@moonshot-ai/protocol';
-
-import { unwrapData } from '../errors.js';
-
-/** Which scope a call resolves before dispatching. */
-export type ScopeKind = 'core' | 'session' | 'agent';
-
-/** Scope-identifying path params. */
-export interface ScopeParams {
-  readonly sessionId?: string;
-  readonly agentId?: string;
-}
-
-export interface HttpRpcOptions {
-  /** Base URL of the server, e.g. `http://127.0.0.1:58627`. */
-  readonly baseUrl: string;
-  /** Default `/api/v2`. */
-  readonly apiPrefix?: string;
-  /** Optional bearer token. */
-  readonly token?: string;
-  /** Override `fetch` (testing). */
-  readonly fetchImpl?: typeof fetch;
-}
-
-export class HttpRpc {
-  private readonly baseUrl: string;
-  private readonly apiPrefix: string;
-  private readonly token: string | undefined;
-  private readonly fetchImpl: typeof fetch;
-
-  constructor(opts: HttpRpcOptions) {
-    this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
-    this.apiPrefix = opts.apiPrefix ?? '/api/v2';
-    this.token = opts.token;
-    this.fetchImpl = opts.fetchImpl ?? fetch;
-  }
-
-  async call<T>(
-    scope: ScopeKind,
-    params: ScopeParams,
-    sa: string,
-    arg?: unknown,
-  ): Promise<T> {
-    const url = this.url(scope, params, sa);
-    const headers: Record<string, string> = { accept: 'application/json' };
-    let body: string | undefined;
-    if (arg !== undefined) {
-      headers['content-type'] = 'application/json';
-      body = JSON.stringify(arg);
-    }
-    if (this.token !== undefined) {
-      headers['authorization'] = `Bearer ${this.token}`;
-    }
-    const res = await this.fetchImpl(url, { method: 'POST', headers, body });
-    const text = await res.text();
-    let envelope: Envelope<T>;
-    try {
-      envelope = JSON.parse(text) as Envelope<T>;
-    } catch (error) {
-      throw new Error(
-        `server-v2 POST ${sa} returned non-JSON (HTTP ${res.status}): ${text.slice(0, 200)}`,
-        { cause: error },
-      );
-    }
-    return unwrapData<T>(envelope);
-  }
-
-  private url(scope: ScopeKind, params: ScopeParams, sa: string): string {
-    switch (scope) {
-      case 'core':
-        return `${this.baseUrl}${this.apiPrefix}/${sa}`;
-      case 'session':
-        return `${this.baseUrl}${this.apiPrefix}/session/${encodeURIComponent(params.sessionId ?? '')}/${sa}`;
-      case 'agent':
-        return `${this.baseUrl}${this.apiPrefix}/session/${encodeURIComponent(params.sessionId ?? '')}/agent/${encodeURIComponent(params.agentId ?? '')}/${sa}`;
-    }
-  }
-}
diff --git a/packages/server-e2e/src/v2/transport/rpcProxy.ts b/packages/server-e2e/src/v2/transport/rpcProxy.ts
deleted file mode 100644
index f1e51aa87..000000000
--- a/packages/server-e2e/src/v2/transport/rpcProxy.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * Resource proxy factory for the `/api/v2` SDK.
- *
- * A resource (e.g. `sessions`, `prompts`) is a set of actions declared in a
- * manifest. `makeResource` returns a Proxy that turns any declared action
- * into a `POST <resource>:<action>` call. The return type is derived from the
- * manifest so every action is reachable with autocomplete; a `Precise` map
- * can override individual actions with exact wire types.
- *
- *   type Sessions = ResourceShape<typeof CORE.sessions, SessionsPrecise>;
- *   const sessions = makeResource(rpc, 'core', {}, 'sessions', CORE.sessions);
- *   await sessions.list({ page_size: 20 }); // typed via SessionsPrecise.list
- */
-import type { HttpRpc, ScopeKind, ScopeParams } from './http.js';
-
-/** Per-action metadata in a resource manifest. `readonly` actions allow GET. */
-export interface ActionMeta {
-  readonly readonly?: boolean;
-}
-
-/** A loose resource method — used when no precise override is provided. */
-export type AnyMethod = (arg?: unknown) => Promise<unknown>;
-
-/**
- * Derive the typed shape of a resource from its manifest + precise overrides.
- * Every manifest action becomes a method; actions present in `Precise` keep
- * their exact signature, the rest fall back to {@link AnyMethod}.
- *
- * `Precise` is keyed by action name (a typo in a key fails the constraint) but
- * its values are unconstrained (`unknown`), so a precise method never has to be
- * assignable to {@link AnyMethod}. Precise methods are rebuilt with an optional
- * arg to match the wire (every action body is optional).
- */
-export type ResourceShape<
-  Actions extends Record<string, ActionMeta>,
-  Precise extends Partial<Record<keyof Actions, unknown>> = Record<never, never>,
-> = {
-  [A in keyof Actions]: A extends keyof Precise
-    ? Precise[A] extends (arg?: infer P) => Promise<infer R>
-      ? (arg?: P) => Promise<R>
-      : AnyMethod
-    : AnyMethod;
-};
-
-/** Build a resource proxy bound to a scope + resource name. */
-export function makeResource<
-  Actions extends Record<string, ActionMeta>,
-  Precise extends Partial<Record<keyof Actions, unknown>> = Record<never, never>,
->(
-  rpc: HttpRpc,
-  scope: ScopeKind,
-  params: ScopeParams,
-  resource: string,
-  actions: Actions,
-): ResourceShape<Actions, Precise> {
-  return new Proxy({} as ResourceShape<Actions, Precise>, {
-    get(_target, prop) {
-      if (typeof prop !== 'string') return undefined;
-      if (!Object.prototype.hasOwnProperty.call(actions, prop)) return undefined;
-      return (arg?: unknown) => rpc.call(scope, params, `${resource}:${prop}`, arg);
-    },
-  });
-}
-
-/**
- * Untyped escape hatch — a resource proxy that accepts ANY action name and
- * forwards it as `<resource>:<action>`. Used by `client.core<T>(resource)`,
- * `session.service<T>(resource)`, and `agent.service<T>(resource)` for actions
- * that are not (yet) in the manifest.
- */
-export type DynamicResource = Record<string, AnyMethod>;
-
-export function makeDynamicResource(
-  rpc: HttpRpc,
-  scope: ScopeKind,
-  params: ScopeParams,
-  resource: string,
-): DynamicResource {
-  return new Proxy({} as DynamicResource, {
-    get(_target, prop) {
-      if (typeof prop !== 'string') return undefined;
-      return (arg?: unknown) => rpc.call(scope, params, `${resource}:${prop}`, arg);
-    },
-  });
-}
diff --git a/packages/server-e2e/src/v2/transport/ws.ts b/packages/server-e2e/src/v2/transport/ws.ts
deleted file mode 100644
index 4134a27ca..000000000
--- a/packages/server-e2e/src/v2/transport/ws.ts
+++ /dev/null
@@ -1,301 +0,0 @@
-/**
- * `/api/v2/ws` client — a single multiplexed WebSocket for RPC `call`s and
- * event `listen`s.
- *
- * Protocol (see `server-v2/src/transport/ws/wsProtocol.ts`):
- *   server → { type:'ready' } on connect
- *   client → { type:'hello', token? } (no ack; server accepts synchronously)
- *   client → { type:'call', id, scope, sessionId?, agentId?, sa, arg? }
- *   server → { type:'result', id, data } | { type:'error', id, code, msg }
- *   client → { type:'listen', id, scope, sessionId?, agentId?, event }
- *   server → { type:'event', id, data } (streamed until `unlisten`)
- *   server → { type:'ping' } → client → { type:'pong' }
- *
- * Auth is enforced at the HTTP upgrade, so the bearer token is sent on the
- * upgrade request (`authorization` header). The post-connect `hello` is a
- * defense-in-depth handshake, not the real gate.
- */
-import { ulid } from 'ulid';
-import { WebSocket as NodeWebSocket } from 'ws';
-
-import { RpcError } from '../errors.js';
-
-import type { ScopeKind, ScopeParams } from './http.js';
-
-export interface V2SocketOptions {
-  /** Base URL of the server, e.g. `http://127.0.0.1:58627`. */
-  readonly baseUrl: string;
-  /** Default `/api/v2`. WS endpoint is `${apiPrefix}/ws`. */
-  readonly apiPrefix?: string;
-  /** Optional bearer token sent on the upgrade request. */
-  readonly token?: string;
-  /** Override the WebSocket implementation (testing / browser). */
-  readonly wsImpl?: typeof NodeWebSocket;
-  /** Default 30s. Per-`call` deadline. */
-  readonly callTimeoutMs?: number;
-}
-
-interface PendingCall {
-  resolve: (data: unknown) => void;
-  reject: (err: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-}
-
-interface Listener {
-  onEvent: (data: unknown) => void;
-  onError?: (err: RpcError) => void;
-}
-
-const DEFAULT_CALL_TIMEOUT_MS = 30_000;
-
-/** A low-level v2 WebSocket. Most callers want the `EventsClient` wrapper. */
-export class V2Socket {
-  private readonly baseUrl: string;
-  private readonly apiPrefix: string;
-  private readonly token: string | undefined;
-  private readonly wsImpl: typeof NodeWebSocket;
-  private readonly callTimeoutMs: number;
-
-  private ws: NodeWebSocket | null = null;
-  private readonly calls = new Map<string, PendingCall>();
-  private readonly listeners = new Map<string, Listener>();
-  private closed = false;
-  private readonly closeWaiters: Array<() => void> = [];
-
-  constructor(opts: V2SocketOptions) {
-    this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
-    this.apiPrefix = opts.apiPrefix ?? '/api/v2';
-    this.token = opts.token;
-    this.wsImpl = opts.wsImpl ?? NodeWebSocket;
-    this.callTimeoutMs = opts.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
-  }
-
-  /** Open the socket, wait for `ready`, and send `hello`. */
-  connect(): Promise<void> {
-    if (this.ws) return Promise.resolve();
-    return new Promise<void>((resolve, reject) => {
-      const wsUrl = `${this.baseUrl.replace(/^http/, 'ws')}${this.apiPrefix}/ws`;
-      const headers: Record<string, string> = {};
-      if (this.token !== undefined) headers['authorization'] = `Bearer ${this.token}`;
-      const ws = new this.wsImpl(wsUrl, { headers });
-      this.ws = ws;
-
-      let opened = false;
-      ws.once('error', (err) => {
-        if (!opened) reject(err as Error);
-      });
-      ws.on('message', (data) => {
-        if (!opened) {
-          const frame = parseFrame(data);
-          if (frame?.type === 'ready') {
-            opened = true;
-            this.send({ type: 'hello', token: this.token });
-            resolve();
-            return;
-          }
-        }
-        this.onMessage(data);
-      });
-      ws.on('close', () => this.onClose());
-      ws.on('error', () => this.onClose());
-    });
-  }
-
-  /** Fire an RPC call over the socket; resolves with `data` or rejects. */
-  call<T>(scope: ScopeKind, params: ScopeParams, sa: string, arg?: unknown): Promise<T> {
-    const ws = this.requireWs();
-    const id = `call-${ulid()}`;
-    return new Promise<T>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.calls.delete(id);
-        reject(new Error(`call ${sa} timed out after ${this.callTimeoutMs}ms`));
-      }, this.callTimeoutMs);
-      timer.unref?.();
-      this.calls.set(id, {
-        resolve: (data) => resolve(data as T),
-        reject,
-        timer,
-      });
-      this.send({
-        type: 'call',
-        id,
-        scope,
-        sessionId: params.sessionId,
-        agentId: params.agentId,
-        sa,
-        arg,
-      });
-      void ws;
-    });
-  }
-
-  /**
-   * Subscribe to an event stream. `onEvent` fires for each pushed event. Returns
-   * an `unlisten` handle (also sends `unlisten` to the server).
-   */
-  listen(
-    scope: ScopeKind,
-    params: ScopeParams,
-    event: string,
-    onEvent: (data: unknown) => void,
-    onError?: (err: RpcError) => void,
-  ): () => void {
-    this.requireWs();
-    const id = `listen-${ulid()}`;
-    this.listeners.set(id, { onEvent, onError });
-    this.send({
-      type: 'listen',
-      id,
-      scope,
-      sessionId: params.sessionId,
-      agentId: params.agentId,
-      event,
-    });
-    return () => {
-      if (!this.listeners.has(id)) return;
-      this.listeners.delete(id);
-      this.send({ type: 'unlisten', id });
-    };
-  }
-
-  /** Close the socket. Idempotent. */
-  close(): Promise<void> {
-    if (this.closed || !this.ws) return Promise.resolve();
-    this.closed = true;
-    return new Promise<void>((resolve) => {
-      this.closeWaiters.push(resolve);
-      this.ws?.close();
-    });
-  }
-
-  private requireWs(): NodeWebSocket {
-    if (!this.ws || this.closed) {
-      throw new Error('v2 ws not connected — call `await socket.connect()` first');
-    }
-    return this.ws;
-  }
-
-  private send(frame: ClientFrame): void {
-    if (!this.ws || this.closed) return;
-    try {
-      this.ws.send(JSON.stringify(frame));
-    } catch {
-      // best-effort
-    }
-  }
-
-  private onMessage(data: unknown): void {
-    const frame = parseFrame(data);
-    if (frame === null) return;
-    switch (frame.type) {
-      case 'ping':
-        this.send({ type: 'pong' });
-        return;
-      case 'result': {
-        const pending = this.calls.get(frame.id);
-        if (pending) {
-          this.calls.delete(frame.id);
-          clearTimeout(pending.timer);
-          pending.resolve(frame.data);
-        }
-        return;
-      }
-      case 'error': {
-        const pending = this.calls.get(frame.id);
-        if (pending) {
-          this.calls.delete(frame.id);
-          clearTimeout(pending.timer);
-          pending.reject(new RpcError({ code: frame.code, msg: frame.msg, data: null, request_id: frame.id }));
-          return;
-        }
-        const listener = this.listeners.get(frame.id);
-        if (listener?.onError) {
-          listener.onError(new RpcError({ code: frame.code, msg: frame.msg, data: null, request_id: frame.id }));
-        }
-        return;
-      }
-      case 'event': {
-        const listener = this.listeners.get(frame.id);
-        if (listener) listener.onEvent(frame.data);
-        return;
-      }
-      default:
-        return;
-    }
-  }
-
-  private onClose(): void {
-    if (this.closed && this.calls.size === 0 && this.listeners.size === 0) {
-      // already cleaned up
-    }
-    this.closed = true;
-    for (const pending of this.calls.values()) {
-      clearTimeout(pending.timer);
-      pending.reject(new Error('v2 ws closed before call result'));
-    }
-    this.calls.clear();
-    this.listeners.clear();
-    for (const waiter of this.closeWaiters.splice(0)) waiter();
-    this.ws = null;
-  }
-}
-
-// ── Wire frame shapes (client view; not validated) ─────────────────────────
-
-interface ReadyFrame {
-  readonly type: 'ready';
-  readonly heartbeatMs: number;
-}
-interface ResultFrame {
-  readonly type: 'result';
-  readonly id: string;
-  readonly data: unknown;
-}
-interface ErrorFrame {
-  readonly type: 'error';
-  readonly id: string;
-  readonly code: number;
-  readonly msg: string;
-}
-interface EventFrame {
-  readonly type: 'event';
-  readonly id: string;
-  readonly data: unknown;
-}
-interface PingFrame {
-  readonly type: 'ping';
-}
-type ServerFrame = ReadyFrame | ResultFrame | ErrorFrame | EventFrame | PingFrame;
-
-type ClientFrame =
-  | { readonly type: 'hello'; readonly token?: string }
-  | {
-      readonly type: 'call';
-      readonly id: string;
-      readonly scope: ScopeKind;
-      readonly sessionId?: string;
-      readonly agentId?: string;
-      readonly sa: string;
-      readonly arg?: unknown;
-    }
-  | { readonly type: 'cancel'; readonly id: string }
-  | {
-      readonly type: 'listen';
-      readonly id: string;
-      readonly scope: ScopeKind;
-      readonly sessionId?: string;
-      readonly agentId?: string;
-      readonly event: string;
-    }
-  | { readonly type: 'unlisten'; readonly id: string }
-  | { readonly type: 'pong' };
-
-function parseFrame(data: unknown): ServerFrame | null {
-  const raw = typeof data === 'string' ? data : Buffer.isBuffer(data) ? data.toString('utf8') : null;
-  if (raw === null) return null;
-  try {
-    return JSON.parse(raw) as ServerFrame;
-  } catch {
-    return null;
-  }
-}
diff --git a/packages/server-e2e/test/v2/smoke.test.ts b/packages/server-e2e/test/v2/smoke.test.ts
deleted file mode 100644
index 831e2670e..000000000
--- a/packages/server-e2e/test/v2/smoke.test.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * Smoke test for the v2 wire surface — boots `server-v2` in-process (port 0)
- * and exercises the typed `Klient` over HTTP (core/session/agent channels)
- * and WS (agent event stream).
- *
- * The test client is a pure wire client: server state is arranged through the
- * in-process `server.core` reference only where the RPC surface offers no way
- * (e.g. creating the main agent, server-v2 gap G10); session creation goes
- * through the legacy `/api/v1` REST surface, and every other assertion goes
- * through `Klient`.
- */
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  ensureMainAgent,
-  IAgentRPCService,
-  ISessionActivity,
-  ISessionIndex,
-  ISessionLifecycleService,
-  ISessionMetadata,
-  IWorkspaceRegistry,
-} from '@moonshot-ai/agent-core-v2';
-import { type RunningServer, startServer } from '@moonshot-ai/kap-server';
-import { Klient } from '@moonshot-ai/klient';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { HttpClient } from '../../src/http.js';
-
-describe('Klient (server-v2 smoke)', () => {
-  let server: RunningServer | undefined;
-  let home: string | undefined;
-  let client: Klient | undefined;
-  let v1: HttpClient | undefined;
-  let wsOpened = false;
-
-  beforeEach(async () => {
-    home = await mkdtemp(join(tmpdir(), 'kimi-sdk-smoke-'));
-    server = await startServer({ host: '127.0.0.1', port: 0, homeDir: home, logLevel: 'silent' });
-    const baseUrl = `http://127.0.0.1:${server.port}`;
-    const token = server.authTokenService.getToken();
-    client = new Klient({ url: baseUrl, token });
-    v1 = new HttpClient({ baseUrl, apiPrefix: '/api/v1', token, fetchImpl: fetch });
-    wsOpened = false;
-  });
-
-  afterEach(async () => {
-    if (wsOpened) {
-      client?.ws().close();
-      wsOpened = false;
-    }
-    client = undefined;
-    v1 = undefined;
-    if (server) {
-      await server.close();
-      server = undefined;
-    }
-    if (home) {
-      await rm(home, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 } as never);
-      home = undefined;
-    }
-  });
-
-  async function createSession(cwd: string): Promise<string> {
-    const session = await v1!.createSession({ metadata: { cwd } });
-    return session.id;
-  }
-
-  async function createMainAgent(sessionId: string): Promise<void> {
-    const session = server!.core.accessor.get(ISessionLifecycleService).get(sessionId);
-    if (session === undefined) throw new Error(`session ${sessionId} not found`);
-    await ensureMainAgent(session);
-  }
-
-  it('lists sessions (core)', async () => {
-    await createSession(home as string);
-    const page = await client!.core(ISessionIndex).list({ limit: 20 });
-    expect(page.items.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('creates and reads a workspace (core)', async () => {
-    const registry = client!.core(IWorkspaceRegistry);
-    const created = await registry.createOrTouch(home as string);
-    expect(created.root).toBe(home);
-
-    const got = await registry.get(created.id);
-    expect(got?.root).toBe(home);
-  });
-
-  it('reads, renames, and archives a session (session scope)', async () => {
-    const sid = await createSession(home as string);
-    const s = client!.session(sid);
-
-    const before = await s.service(ISessionMetadata).read();
-    expect(before.id).toBe(sid);
-
-    await s.service(ISessionMetadata).setTitle('renamed');
-    const after = await s.service(ISessionMetadata).read();
-    expect(after.title).toBe('renamed');
-
-    // `status()` is sync in the shared interface but async over the wire.
-    const status = await Promise.resolve(s.service(ISessionActivity).status());
-    expect(['idle', 'running', 'awaiting_approval', 'awaiting_question']).toContain(status);
-
-    await s.service(ISessionLifecycleService).archive(sid);
-  });
-
-  it('submits a prompt and runs a shell command (agent scope)', async () => {
-    const sid = await createSession(home as string);
-    await createMainAgent(sid);
-    const agent = client!.session(sid).agent('main').service(IAgentRPCService);
-
-    const submitted = await agent.prompt({
-      input: [{ type: 'text', text: 'hello' }],
-    });
-    expect(typeof submitted?.turn_id).toBe('number');
-
-    const shell = await agent.runShellCommand({ command: 'printf hello' });
-    expect(shell.stdout).toBe('hello');
-    expect(shell.stderr).toBe('');
-  });
-
-  it('streams agent events over ws', async () => {
-    const sid = await createSession(home as string);
-    await createMainAgent(sid);
-
-    const ws = client!.ws();
-    wsOpened = true;
-    const received: unknown[] = [];
-    const sub = ws.session(sid).agent('main').listen('events', (e) => {
-      received.push(e);
-    });
-
-    await client!.session(sid).agent('main').service(IAgentRPCService).prompt({
-      input: [{ type: 'text', text: 'hi' }],
-    });
-
-    const deadline = Date.now() + 10_000;
-    while (received.length === 0 && Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, 50));
-    }
-    sub.dispose();
-    expect(received.length).toBeGreaterThan(0);
-  });
-});
diff --git a/packages/server-e2e/tsconfig.json b/packages/server-e2e/tsconfig.json
deleted file mode 100644
index e1e0487d3..000000000
--- a/packages/server-e2e/tsconfig.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "experimentalDecorators": true
-  },
-  "include": ["src", "test", "scenarios", "../agent-core/src/prompt-modules.d.ts"],
-  "exclude": [
-    // The v2 smoke test boots `server-v2` in-process, which pulls in server-v2's
-    // full source graph. server-v2 currently has a pre-existing type error in
-    // `src/transport/ws/eventMap.ts` (`ISessionInteractionService.onDidChange`
-    // was removed upstream in agent-core-v2). The smoke test still runs under
-    // vitest (esbuild transpiles without typechecking); only `tsc` skips it.
-    "test/v2/smoke.test.ts"
-  ]
-}
diff --git a/packages/server-e2e/tsdown.config.ts b/packages/server-e2e/tsdown.config.ts
deleted file mode 100644
index b27e00afd..000000000
--- a/packages/server-e2e/tsdown.config.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { defineConfig } from 'tsdown';
-
-export default defineConfig({
-  entry: ['./src/index.ts'],
-  format: ['esm'],
-  dts: false,
-  outDir: 'dist',
-  clean: true,
-  deps: {
-    alwaysBundle: [/^@moonshot-ai\//],
-    neverBundle: [],
-  },
-});
diff --git a/packages/server-e2e/vitest.config.ts b/packages/server-e2e/vitest.config.ts
deleted file mode 100644
index 8f393810d..000000000
--- a/packages/server-e2e/vitest.config.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { fileURLToPath } from 'node:url';
-
-import { defineConfig } from 'vitest/config';
-
-import { rawTextPlugin } from '../../build/raw-text-plugin.mjs';
-
-// `rawTextPlugin` is required because importing `@moonshot-ai/kap-server` (for
-// the v2 SDK tests) pulls in agent-core-v2's barrel, which imports `*.md?raw`
-// prompt templates.
-export default defineConfig({
-  plugins: [rawTextPlugin()],
-  resolve: {
-    alias: {
-      '@moonshot-ai/protocol': fileURLToPath(
-        new URL('../protocol/src/index.ts', import.meta.url),
-      ),
-    },
-  },
-  test: {
-    name: 'server-e2e',
-    include: ['test/**/*.test.ts'],
-    reporters: ['default', './test/report/vitest-reporter.ts'],
-  },
-});
diff --git a/packages/telemetry/src/crash.ts b/packages/telemetry/src/crash.ts
index 4c501de2d..35674a834 100644
--- a/packages/telemetry/src/crash.ts
+++ b/packages/telemetry/src/crash.ts
@@ -7,6 +7,7 @@ let installed = false;
 let installedUncaughtHandler:
   | ((error: Error, origin: NodeJS.UncaughtExceptionOrigin) => void)
   | null = null;
+let installedRejectionHandler: ((reason: unknown) => void) | null = null;
 
 export function setCrashPhase(nextPhase: CrashPhase): void {
   phase = nextPhase;
@@ -17,11 +18,15 @@ export function installCrashHandlers(): () => void {
 }
 
 export function installCrashHandlersForClient(client: TelemetryClient): () => void {
-  if (installed && installedUncaughtHandler !== null) {
+  if (installed && installedUncaughtHandler !== null && installedRejectionHandler !== null) {
     return () => {
       uninstallCrashHandlers();
     };
   }
+  // Rejections recorded by the rejection handler below and then rethrown to
+  // preserve Node's default crash; the monitor must not report them twice.
+  // A Set (not WeakSet) so primitive reasons dedupe by value too.
+  const recordedRejections = new Set<unknown>();
   const trackCrash = (errorType: string, source: string) => {
     try {
       client.track('crash', {
@@ -36,9 +41,30 @@ export function installCrashHandlersForClient(client: TelemetryClient): () => vo
   };
   installedUncaughtHandler = (error, origin) => {
     if (isAbortError(error)) return;
-    trackCrash(error.name || error.constructor.name, origin);
+    if (recordedRejections.has(error)) return;
+    // `error` is typed Error but can be anything a rejection rethrow sent
+    // through (primitives, null) — classify it null-safely.
+    trackCrash(crashErrorType(error), origin);
   };
   process.on('uncaughtExceptionMonitor', installedUncaughtHandler);
+  // `uncaughtExceptionMonitor` never fires for a rejection that has a
+  // listener — and the TUI always registers one, converting the rejection
+  // into a silent exit(1) with no telemetry at all. Observe rejections
+  // directly so those crashes still leave a trace. Registering a real
+  // listener suppresses Node's default crash-on-rejection, so when we are
+  // the only listener (print / server modes) rethrow to preserve it; the
+  // dedupe set above keeps the monitor from double-reporting that path.
+  installedRejectionHandler = (reason: unknown) => {
+    const soleListener = process.listenerCount('unhandledRejection') === 1;
+    if (!isAbortError(reason)) {
+      trackCrash(crashErrorType(reason), 'unhandledRejection');
+      recordedRejections.add(reason);
+    }
+    if (soleListener) {
+      throw reason;
+    }
+  };
+  process.on('unhandledRejection', installedRejectionHandler);
   installed = true;
   return () => {
     uninstallCrashHandlers();
@@ -50,10 +76,19 @@ export function uninstallCrashHandlers(): void {
   if (installedUncaughtHandler !== null) {
     process.off('uncaughtExceptionMonitor', installedUncaughtHandler);
   }
+  if (installedRejectionHandler !== null) {
+    process.off('unhandledRejection', installedRejectionHandler);
+  }
   installedUncaughtHandler = null;
+  installedRejectionHandler = null;
   installed = false;
 }
 
+function crashErrorType(reason: unknown): string {
+  if (reason instanceof Error) return reason.name || reason.constructor.name;
+  return typeof reason;
+}
+
 function isAbortError(reason: unknown): boolean {
   return (
     typeof reason === 'object' &&
diff --git a/packages/telemetry/test/telemetry.test.ts b/packages/telemetry/test/telemetry.test.ts
index 0eee1b9c6..63d09b1b4 100644
--- a/packages/telemetry/test/telemetry.test.ts
+++ b/packages/telemetry/test/telemetry.test.ts
@@ -1000,7 +1000,7 @@ describe('crash handler', () => {
     ]);
   });
 
-  it('does not register duplicate monitor listeners when installed twice', () => {
+  it('does not register duplicate listeners when installed twice', () => {
     const client = new TelemetryClient();
     const beforeUncaught = process.listenerCount('uncaughtExceptionMonitor');
     const beforeRejection = process.listenerCount('unhandledRejection');
@@ -1009,13 +1009,192 @@ describe('crash handler', () => {
     const uninstallSecond = installCrashHandlersForClient(client);
 
     expect(process.listenerCount('uncaughtExceptionMonitor')).toBe(beforeUncaught + 1);
-    expect(process.listenerCount('unhandledRejection')).toBe(beforeRejection);
+    expect(process.listenerCount('unhandledRejection')).toBe(beforeRejection + 1);
     uninstallSecond();
     uninstallFirst();
     expect(process.listenerCount('uncaughtExceptionMonitor')).toBe(beforeUncaught);
     expect(process.listenerCount('unhandledRejection')).toBe(beforeRejection);
   });
 
+  it('observes and records unhandled rejections when another handler owns the lifecycle', () => {
+    const client = new TelemetryClient();
+    const transport = new RecordingTransport();
+    client.attachSink(makeSink(transport));
+    setCrashPhase('runtime');
+    installCrashHandlersForClient(client);
+    // The TUI registers its own rejection handler; while one exists the
+    // crash handler must observe (not rethrow) so the lifecycle is untouched.
+    const owner = (): void => {};
+    process.on('unhandledRejection', owner);
+    try {
+      (process.emit as (event: string, ...args: unknown[]) => boolean)(
+        'unhandledRejection',
+        new TypeError('promise failed'),
+        Promise.resolve(),
+      );
+    } finally {
+      process.off('unhandledRejection', owner);
+    }
+
+    expect(transport.saved[0]?.[0]).toMatchObject({
+      event: 'crash',
+      properties: {
+        error_type: 'TypeError',
+        where: 'runtime',
+        source: 'unhandledRejection',
+      },
+    });
+  });
+
+  it('ignores aborted-operation rejections while observing', () => {
+    const client = new TelemetryClient();
+    const transport = new RecordingTransport();
+    client.attachSink(makeSink(transport));
+    installCrashHandlersForClient(client);
+    const owner = (): void => {};
+    process.on('unhandledRejection', owner);
+    try {
+      (process.emit as (event: string, ...args: unknown[]) => boolean)(
+        'unhandledRejection',
+        new DOMException('The operation was aborted.', 'AbortError'),
+        Promise.resolve(),
+      );
+    } finally {
+      process.off('unhandledRejection', owner);
+    }
+
+    expect(transport.saved).toHaveLength(0);
+  });
+
+  it('rethrows when it is the only rejection listener, recording the crash exactly once', () => {
+    const client = new TelemetryClient();
+    const transport = new RecordingTransport();
+    client.attachSink(makeSink(transport));
+    setCrashPhase('runtime');
+    // Vitest keeps its own rejection listeners; temporarily drop every
+    // listener so the crash handler is the sole one, as in print/server mode.
+    const others = process.listeners('unhandledRejection');
+    process.removeAllListeners('unhandledRejection');
+    installCrashHandlersForClient(client);
+    const reason = new TypeError('promise failed');
+    try {
+      expect(() =>
+        (process.emit as (event: string, ...args: unknown[]) => boolean)(
+          'unhandledRejection',
+          reason,
+          Promise.resolve(),
+        ),
+      ).toThrow(reason);
+
+      // Tracked once as a rejection; when the rethrow later surfaces at the
+      // uncaughtException monitor it must not be reported a second time.
+      expect(transport.saved[0]?.[0]).toMatchObject({
+        event: 'crash',
+        properties: {
+          error_type: 'TypeError',
+          where: 'runtime',
+          source: 'unhandledRejection',
+        },
+      });
+      emitCrash(reason);
+      expect(transport.saved).toHaveLength(1);
+    } finally {
+      uninstallCrashHandlers();
+      for (const listener of others) {
+        process.on('unhandledRejection', listener as (...args: unknown[]) => void);
+      }
+    }
+  });
+
+  it('dedupes rethrown non-Error rejection reasons at the uncaught monitor', () => {
+    const client = new TelemetryClient();
+    const transport = new RecordingTransport();
+    client.attachSink(makeSink(transport));
+    setCrashPhase('runtime');
+    const others = process.listeners('unhandledRejection');
+    process.removeAllListeners('unhandledRejection');
+    installCrashHandlersForClient(client);
+    const reason = { code: 'E' };
+    try {
+      let caught: unknown;
+      try {
+        (process.emit as (event: string, ...args: unknown[]) => boolean)(
+          'unhandledRejection',
+          reason,
+          Promise.resolve(),
+        );
+      } catch (error) {
+        caught = error;
+      }
+      expect(caught).toBe(reason);
+
+      // The plain-object reason is rethrown through the monitor; it must be
+      // deduped there, not reported as a second crash.
+      (process.emit as (event: string, ...args: unknown[]) => boolean)(
+        'uncaughtExceptionMonitor',
+        reason,
+        'uncaughtException',
+      );
+      expect(transport.saved).toHaveLength(1);
+      expect(transport.saved[0]?.[0]).toMatchObject({
+        event: 'crash',
+        properties: {
+          error_type: 'object',
+          where: 'runtime',
+          source: 'unhandledRejection',
+        },
+      });
+    } finally {
+      uninstallCrashHandlers();
+      for (const listener of others) {
+        process.on('unhandledRejection', listener as (...args: unknown[]) => void);
+      }
+    }
+  });
+
+  it('dedupes null rejection reasons and classifies monitor crashes null-safely', () => {
+    const client = new TelemetryClient();
+    const transport = new RecordingTransport();
+    client.attachSink(makeSink(transport));
+    setCrashPhase('runtime');
+    const others = process.listeners('unhandledRejection');
+    process.removeAllListeners('unhandledRejection');
+    installCrashHandlersForClient(client);
+    try {
+      let caught: unknown = 'not-thrown';
+      try {
+        (process.emit as (event: string, ...args: unknown[]) => boolean)(
+          'unhandledRejection',
+          null,
+          Promise.resolve(),
+        );
+      } catch (error) {
+        caught = error;
+      }
+      expect(caught).toBe(null);
+
+      // The rethrown null reaches the monitor: deduped, and the error-type
+      // classification must not itself throw on null/undefined.
+      expect(() => {
+        emitCrash(null as unknown as Error);
+      }).not.toThrow();
+      expect(transport.saved).toHaveLength(1);
+      expect(transport.saved[0]?.[0]).toMatchObject({
+        event: 'crash',
+        properties: {
+          error_type: 'object',
+          where: 'runtime',
+          source: 'unhandledRejection',
+        },
+      });
+    } finally {
+      uninstallCrashHandlers();
+      for (const listener of others) {
+        process.on('unhandledRejection', listener as (...args: unknown[]) => void);
+      }
+    }
+  });
+
   it('ignores aborted-operation errors', () => {
     const client = new TelemetryClient();
     const transport = new RecordingTransport();
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6f351614b..829efa3ac 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -11,8 +11,10 @@ catalogs:
       version: 4.3.6
 
 overrides:
+  kimi-code>@tailwindcss/vite: 4.1.18
   ssh2@1.17.0>cpu-features: '-'
   ssh2@1.17.0>nan: '-'
+  kimi-code>tailwindcss: 4.1.18
 
 importers:
 
@@ -68,7 +70,7 @@ importers:
         version: 6.0.2
       vitest:
         specifier: 4.1.4
-        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
+        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
 
   apps/kimi-code:
     devDependencies:
@@ -226,7 +228,7 @@ importers:
         version: 6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)
       vitest:
         specifier: 4.1.4
-        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
       vue-tsc:
         specifier: ~3.2.0
         version: 3.2.9(typescript@6.0.2)
@@ -269,7 +271,7 @@ importers:
         version: 4.21.0
       vitest:
         specifier: 4.1.4
-        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
+        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
       yazl:
         specifier: ^3.3.1
         version: 3.3.1
@@ -318,7 +320,158 @@ importers:
         version: 2.3.3(rollup@4.60.2)(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
       vitest:
         specifier: 4.1.4
-        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+
+  apps/vscode:
+    dependencies:
+      '@base-ui/react':
+        specifier: ^1.0.0
+        version: 1.6.0(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@fontsource-variable/inter':
+        specifier: 5.2.8
+        version: 5.2.8
+      '@moonshot-ai/kimi-code-sdk':
+        specifier: workspace:^
+        version: link:../../packages/node-sdk
+      '@moonshot-ai/migration-legacy':
+        specifier: workspace:^
+        version: link:../../packages/migration-legacy
+      '@radix-ui/react-accordion':
+        specifier: ^1.2.12
+        version: 1.2.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@tabler/icons-react':
+        specifier: ^3.36.0
+        version: 3.44.0(react@19.2.5)
+      ahooks:
+        specifier: ^3.9.6
+        version: 3.9.7(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      class-variance-authority:
+        specifier: ^0.7.1
+        version: 0.7.1
+      clsx:
+        specifier: ^2.1.1
+        version: 2.1.1
+      cmdk:
+        specifier: ^1.1.1
+        version: 1.1.1(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      diff:
+        specifier: ^8.0.2
+        version: 8.0.4
+      fuse.js:
+        specifier: ^7.1.0
+        version: 7.5.0
+      heic-to:
+        specifier: ^1.0.2
+        version: 1.5.2
+      immer:
+        specifier: ^11.1.0
+        version: 11.1.11
+      katex:
+        specifier: ^0.17.0
+        version: 0.17.0
+      next-themes:
+        specifier: ^0.4.6
+        version: 0.4.6(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      radix-ui:
+        specifier: ^1.4.3
+        version: 1.6.2(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react:
+        specifier: ^19.1.0
+        version: 19.2.5
+      react-dom:
+        specifier: ^19.1.0
+        version: 19.2.5(react@19.2.5)
+      react-markdown:
+        specifier: ^10.1.0
+        version: 10.1.0(@types/react@19.2.14)(react@19.2.5)
+      react-scroll-to-bottom:
+        specifier: ^4.2.0
+        version: 4.2.0(@babel/core@7.29.0)(react@19.2.5)
+      react-syntax-highlighter:
+        specifier: ^16.1.0
+        version: 16.1.1(react@19.2.5)
+      rehype-katex:
+        specifier: ^7.0.1
+        version: 7.0.1
+      remark-gfm:
+        specifier: ^4.0.1
+        version: 4.0.1
+      remark-math:
+        specifier: ^6.0.0
+        version: 6.0.0
+      shadcn:
+        specifier: ^3.6.2
+        version: 3.8.5(@types/node@22.19.17)(babel-plugin-macros@3.1.0)(typescript@6.0.2)
+      sonner:
+        specifier: ^2.0.7
+        version: 2.0.7(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      tailwind-merge:
+        specifier: ^3.4.0
+        version: 3.6.0
+      tw-animate-css:
+        specifier: ^1.4.0
+        version: 1.4.0
+      zustand:
+        specifier: ^5
+        version: 5.0.14(@types/react@19.2.14)(immer@11.1.11)(react@19.2.5)(use-sync-external-store@1.6.0(react@19.2.5))
+    devDependencies:
+      '@tailwindcss/vite':
+        specifier: 4.1.18
+        version: 4.1.18(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+      '@types/diff':
+        specifier: ^8.0.0
+        version: 8.0.0
+      '@types/katex':
+        specifier: ^0.16.8
+        version: 0.16.8
+      '@types/node':
+        specifier: ^22.15.3
+        version: 22.19.17
+      '@types/react':
+        specifier: ^19.1.2
+        version: 19.2.14
+      '@types/react-dom':
+        specifier: ^19.1.2
+        version: 19.2.3(@types/react@19.2.14)
+      '@types/react-scroll-to-bottom':
+        specifier: ^4.2.5
+        version: 4.2.5
+      '@types/react-syntax-highlighter':
+        specifier: ^15.5.13
+        version: 15.5.13
+      '@types/vscode':
+        specifier: 1.100.0
+        version: 1.100.0
+      '@vitejs/plugin-react':
+        specifier: ^4.4.1
+        version: 4.7.0(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+      '@vscode/test-cli':
+        specifier: ^0.0.11
+        version: 0.0.11
+      '@vscode/test-electron':
+        specifier: ^2.5.2
+        version: 2.5.2
+      '@vscode/vsce':
+        specifier: 3.9.2
+        version: 3.9.2
+      acorn:
+        specifier: 8.17.0
+        version: 8.17.0
+      ovsx:
+        specifier: 1.0.2
+        version: 1.0.2
+      tailwindcss:
+        specifier: 4.1.18
+        version: 4.1.18
+      vite:
+        specifier: ^6.3.3
+        version: 6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)
+      vite-plugin-css-injected-by-js:
+        specifier: ^3.5.2
+        version: 3.5.2(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+      vitest:
+        specifier: 4.1.4
+        version: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
 
   docs:
     dependencies:
@@ -330,11 +483,11 @@ importers:
         version: 1.13.1
       vitepress-plugin-mermaid:
         specifier: ^2.0.17
-        version: 2.0.17(mermaid@11.15.0)(vitepress@1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2))
+        version: 2.0.17(mermaid@11.15.0)(vitepress@1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(fuse.js@7.5.0)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2))
     devDependencies:
       vitepress:
         specifier: ^1.5.0
-        version: 1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2)
+        version: 1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(fuse.js@7.5.0)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2)
 
   packages/acp-adapter:
     dependencies:
@@ -616,7 +769,7 @@ importers:
         version: 4.7.0(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
       '@xyflow/react':
         specifier: ^12.4.0
-        version: 12.11.1(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+        version: 12.11.1(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(immer@11.1.11)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
       react:
         specifier: ^19.1.0
         version: 19.2.5
@@ -660,9 +813,6 @@ importers:
       '@moonshot-ai/agent-core-v2':
         specifier: workspace:^
         version: link:../agent-core-v2
-      '@moonshot-ai/protocol':
-        specifier: workspace:^
-        version: link:../protocol
       bcryptjs:
         specifier: ^2.4.3
         version: 2.4.3
@@ -700,6 +850,25 @@ importers:
       '@moonshot-ai/agent-core-v2':
         specifier: workspace:^
         version: link:../agent-core-v2
+      zod:
+        specifier: 'catalog:'
+        version: 4.3.6
+    devDependencies:
+      '@moonshot-ai/kap-server':
+        specifier: workspace:^
+        version: link:../kap-server
+      '@moonshot-ai/protocol':
+        specifier: workspace:^
+        version: link:../protocol
+      '@types/ws':
+        specifier: ^8.18.0
+        version: 8.18.1
+      ulid:
+        specifier: ^3.0.1
+        version: 3.0.2
+      ws:
+        specifier: ^8.18.0
+        version: 8.20.0
 
   packages/kosong:
     dependencies:
@@ -816,34 +985,6 @@ importers:
         specifier: ^4.3.6
         version: 4.3.6
 
-  packages/server-e2e:
-    dependencies:
-      '@moonshot-ai/protocol':
-        specifier: workspace:^
-        version: link:../protocol
-      ulid:
-        specifier: ^3.0.1
-        version: 3.0.2
-      ws:
-        specifier: ^8.18.0
-        version: 8.20.0
-      zod:
-        specifier: 'catalog:'
-        version: 4.3.6
-    devDependencies:
-      '@moonshot-ai/agent-core-v2':
-        specifier: workspace:^
-        version: link:../agent-core-v2
-      '@moonshot-ai/kap-server':
-        specifier: workspace:^
-        version: link:../kap-server
-      '@moonshot-ai/klient':
-        specifier: workspace:^
-        version: link:../klient
-      '@types/ws':
-        specifier: ^8.18.0
-        version: 8.18.1
-
   packages/telemetry: {}
 
 packages:
@@ -938,6 +1079,10 @@ packages:
   '@antfu/install-pkg@1.1.0':
     resolution: {integrity: sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ==}
 
+  '@antfu/ni@25.0.0':
+    resolution: {integrity: sha512-9q/yCljni37pkMr4sPrI3G4jqdIk074+iukc5aFJl7kmDCCsiJrbZ6zKxnES1Gwg+i9RcDZwvktl23puGslmvA==}
+    hasBin: true
+
   '@antfu/utils@9.3.0':
     resolution: {integrity: sha512-9hFT4RauhcUzqOE4f1+frMKLZrgNog5b06I7VmZQV1BkvwvqrbC8EBZf3L1eEL2AKb6rNKjER0sEvJiSP1FXEA==}
 
@@ -962,10 +1107,64 @@ packages:
   '@asamuzakjp/css-color@3.2.0':
     resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==}
 
+  '@azu/format-text@1.0.2':
+    resolution: {integrity: sha512-Swi4N7Edy1Eqq82GxgEECXSSLyn6GOb5htRFPzBDdUkECGXtlf12ynO5oJSpWKPwCaUssOu7NfhDcCWpIC6Ywg==}
+
+  '@azu/style-format@1.0.1':
+    resolution: {integrity: sha512-AHcTojlNBdD/3/KxIKlg8sxIWHfOtQszLvOpagLTO+bjC3u7SAszu1lf//u7JJC50aUSH+BVWDD/KvaA6Gfn5g==}
+
+  '@azure/abort-controller@2.2.0':
+    resolution: {integrity: sha512-fNAjWnA/nZ2jz31kxR/AqRaUT8ewHBw/WuBIosK0moMy1C9e5ValbDfFdIxJzVOOYaYkV/b2F1S4H/aHiqfVQg==}
+    engines: {node: '>=22.0.0'}
+
+  '@azure/core-auth@1.11.0':
+    resolution: {integrity: sha512-IUZydyTUkDnYdstOW9pFOOUQlBjAepK5teihDE3x6yxsPJs/hsAaaYpeGxdxrgtOiJbBKSjKW7MDk7AEhb4LRg==}
+    engines: {node: '>=22.0.0'}
+
+  '@azure/core-client@1.11.0':
+    resolution: {integrity: sha512-JjQWO6akOck45PH/XBrxzsQGAiKrfFl4m5iggJ0ItMIz5omRufOXWpqCPpdjKN3vKDzlSUvFjaMb7Zwf0gvAdA==}
+    engines: {node: '>=22.0.0'}
+
+  '@azure/core-rest-pipeline@1.25.0':
+    resolution: {integrity: sha512-bMs8ekJLjX8wPV+9IPBges1SLPyuDtE9g5gLDWOpxzKcoOFQnpLGkbcT1tdw3FaAmDS1gnPmMmJ6y/T5B96kIA==}
+    engines: {node: '>=22.0.0'}
+
+  '@azure/core-tracing@1.4.0':
+    resolution: {integrity: sha512-eGwxD0AtncrxeBM4tG8R55Pc3rdX1hNW2WibJAgYpCVA6E93mvvVH+LcssoVjOBrSKWS55yEIHsk0X8ctHmfOQ==}
+    engines: {node: '>=22.0.0'}
+
+  '@azure/core-util@1.14.0':
+    resolution: {integrity: sha512-9n2pWK61veAuN0V20t9lOuoV4CFMdyAZ1ygZzvBGk/pBBJRib/PjL9PLXa/aI2CcPpyHfqVsxxqLCYl6uZlfDw==}
+    engines: {node: '>=22.0.0'}
+
+  '@azure/identity@4.13.1':
+    resolution: {integrity: sha512-5C/2WD5Vb1lHnZS16dNQRPMjN6oV/Upba+C9nBIs15PmOi6A3ZGs4Lr2u60zw4S04gi+u3cEXiqTVP7M4Pz3kw==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/logger@1.4.0':
+    resolution: {integrity: sha512-rbAE25KUfjU/s3XHUdJgceoCP5dEOpMx85J04kF+QMdta73XkuG9JGHHinch+XIoKpBdqljin+KqURpJriSzLA==}
+    engines: {node: '>=22.0.0'}
+
+  '@azure/msal-browser@5.17.1':
+    resolution: {integrity: sha512-zBhRGzABKSI7hfWh5EaZmril5ybZ7imBN1qEZl5sDTaelr+l8SnPjZO50Q4dnKnm347YPIlBMSnXKZyh3Yu5DQ==}
+    engines: {node: '>=0.8.0'}
+
+  '@azure/msal-common@16.11.2':
+    resolution: {integrity: sha512-yDhtBOGDCdK9ipQ9g3+wmlMEPnZx2pXaDicDd9jYyR1L+7lEbvEohTDmF5qejZDutZY3m9pWPxeYxzNC701A2w==}
+    engines: {node: '>=0.8.0'}
+
+  '@azure/msal-node@5.4.1':
+    resolution: {integrity: sha512-yqgoyOIMCH7TNaSLMBTP+4LUlbMMf1zgC8nzOFG95lmW82CmsAEtUT0J93e4BdqDcnX5qle/9X+yb7A8Mw9M0g==}
+    engines: {node: '>=20'}
+
   '@babel/code-frame@7.29.0':
     resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/code-frame@7.29.7':
+    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/compat-data@7.29.0':
     resolution: {integrity: sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==}
     engines: {node: '>=6.9.0'}
@@ -978,32 +1177,82 @@ packages:
     resolution: {integrity: sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/generator@7.29.7':
+    resolution: {integrity: sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/generator@8.0.0-rc.5':
     resolution: {integrity: sha512-nFZPWz3FHIS7y6rMIVoa/WBwjdutfIaRJIBQjzn+t3RnecZoRNlGmGcyR2wb0T/IgSd50Kz/6dG8/LvMCRunjg==}
     engines: {node: ^22.18.0 || >=24.11.0}
 
+  '@babel/helper-annotate-as-pure@7.29.7':
+    resolution: {integrity: sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/helper-compilation-targets@7.28.6':
     resolution: {integrity: sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/helper-create-class-features-plugin@7.29.7':
+    resolution: {integrity: sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
   '@babel/helper-globals@7.28.0':
     resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/helper-globals@7.29.7':
+    resolution: {integrity: sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-member-expression-to-functions@7.29.7':
+    resolution: {integrity: sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/helper-module-imports@7.28.6':
     resolution: {integrity: sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/helper-module-imports@7.29.7':
+    resolution: {integrity: sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/helper-module-transforms@7.28.6':
     resolution: {integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
 
+  '@babel/helper-module-transforms@7.29.7':
+    resolution: {integrity: sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-optimise-call-expression@7.29.7':
+    resolution: {integrity: sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/helper-plugin-utils@7.28.6':
     resolution: {integrity: sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/helper-plugin-utils@7.29.7':
+    resolution: {integrity: sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-replace-supers@7.29.7':
+    resolution: {integrity: sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
+    resolution: {integrity: sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/helper-string-parser@7.27.1':
     resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
     engines: {node: '>=6.9.0'}
@@ -1032,6 +1281,10 @@ packages:
     resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/helper-validator-option@7.29.7':
+    resolution: {integrity: sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/helpers@7.29.2':
     resolution: {integrity: sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==}
     engines: {node: '>=6.9.0'}
@@ -1056,6 +1309,24 @@ packages:
     engines: {node: ^22.18.0 || >=24.11.0}
     hasBin: true
 
+  '@babel/plugin-syntax-jsx@7.29.7':
+    resolution: {integrity: sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-syntax-typescript@7.29.7':
+    resolution: {integrity: sha512-ngr+82Sh0xMz25TPCZi+nC2iTzjfCdWS2ONXTp/PtSCHCgaCNBpdMqgvJ2ccdLlClVZ7sisIgB914j/JFe+RZA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-modules-commonjs@7.29.7':
+    resolution: {integrity: sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
   '@babel/plugin-transform-react-jsx-self@7.27.1':
     resolution: {integrity: sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==}
     engines: {node: '>=6.9.0'}
@@ -1068,6 +1339,22 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
+  '@babel/plugin-transform-typescript@7.29.7':
+    resolution: {integrity: sha512-jK52h8LaLc7JarhQV2ofeFMts4H7vnOXnqZNA6fYglBTZewRBE51KWt3BUltW1P+KoPsYkHoJeXePuz4zo2LMw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/preset-typescript@7.29.7':
+    resolution: {integrity: sha512-/Foi8vKY2EVbed/1eZx0gJEEwHAIxogrySI7rULcRIvhZzbvoE/b5qG5Ghc0WKAFKOHA9SD1x7RsFlOYdutIiQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/runtime-corejs3@7.29.7':
+    resolution: {integrity: sha512-ppj9ouYku+RX0ljtgZd+KMO5mkM2bCqg8H2PYAFWnLsHEIKIdRojqbJ2i3eVHrisuxy7nOFCmngTDdWtUCdXUQ==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/runtime@7.29.2':
     resolution: {integrity: sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==}
     engines: {node: '>=6.9.0'}
@@ -1076,10 +1363,18 @@ packages:
     resolution: {integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/template@7.29.7':
+    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/traverse@7.29.0':
     resolution: {integrity: sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/traverse@7.29.7':
+    resolution: {integrity: sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/types@7.29.0':
     resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
     engines: {node: '>=6.9.0'}
@@ -1092,6 +1387,36 @@ packages:
     resolution: {integrity: sha512-JeSVu/m8x/zpp4CLjYHVNXuhEyOkhPXuxM8YOXjh6L4LlvQNKuUNOTo5KdBuKAcTDHw8DquToTaEkhsBqPXOaA==}
     engines: {node: ^22.18.0 || >=24.11.0}
 
+  '@base-ui/react@1.6.0':
+    resolution: {integrity: sha512-/jzjTWJYXhRFO45Bev9lc3cHbmjzCMpUqbMZ2AgKy/z25mY9B6shGSNcXcjQar9n5doM0KYW1W8fcFv2jZBuMw==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@date-fns/tz': ^1.2.0
+      '@types/react': ^17 || ^18 || ^19
+      date-fns: ^4.0.0
+      react: ^17 || ^18 || ^19
+      react-dom: ^17 || ^18 || ^19
+    peerDependenciesMeta:
+      '@date-fns/tz':
+        optional: true
+      '@types/react':
+        optional: true
+      date-fns:
+        optional: true
+
+  '@base-ui/utils@0.3.1':
+    resolution: {integrity: sha512-gFFiltORVmW/N6IILTGxizP3PBpVpysqML1ALY5Vk0mH+7faVkCknOU31goYHN5Aoek2dkjxva1XOD2Ce9WuIg==}
+    peerDependencies:
+      '@types/react': ^17 || ^18 || ^19
+      react: ^17 || ^18 || ^19
+      react-dom: ^17 || ^18 || ^19
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@bcoe/v8-coverage@0.2.3':
+    resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==}
+
   '@bcoe/v8-coverage@1.0.2':
     resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
     engines: {node: '>=18'}
@@ -1244,6 +1569,13 @@ packages:
       search-insights:
         optional: true
 
+  '@dotenvx/dotenvx@1.75.1':
+    resolution: {integrity: sha512-/BITOC9dmS/edY2zQwZNicQ059O6RKabtQfyEafV0nGtfYRNHYy1DIPiYVcov40+tob9hfmBnbR963dS+EQ1DQ==}
+    hasBin: true
+
+  '@dotenvx/primitives@0.8.0':
+    resolution: {integrity: sha512-VYJy0uhFm9zTJ1TxBaW/pA8bjbOM/OttaNMwZ1RHG4JKyRG7DhSdiqD1ipQoAyoD22olUtxbP78W9xY3Wd11bg==}
+
   '@electron/asar@3.4.1':
     resolution: {integrity: sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==}
     engines: {node: '>=10.12.0'}
@@ -1286,6 +1618,41 @@ packages:
   '@emnapi/wasi-threads@1.2.1':
     resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==}
 
+  '@emotion/babel-plugin@11.13.5':
+    resolution: {integrity: sha512-pxHCpT2ex+0q+HH91/zsdHkw/lXd468DIN2zvfvLtPKLLMo6gQj7oLObq8PhkrxOZb/gGCq03S3Z7PDhS8pduQ==}
+
+  '@emotion/cache@11.14.0':
+    resolution: {integrity: sha512-L/B1lc/TViYk4DcpGxtAVbx0ZyiKM5ktoIyafGkH6zg/tj+mA+NE//aPYKG0k8kCHSHVJrpLpcAlOBEXQ3SavA==}
+
+  '@emotion/css@11.1.3':
+    resolution: {integrity: sha512-RSQP59qtCNTf5NWD6xM08xsQdCZmVYnX/panPYvB6LQAPKQB6GL49Njf0EMbS3CyDtrlWsBcmqBtysFvfWT3rA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    peerDependenciesMeta:
+      '@babel/core':
+        optional: true
+
+  '@emotion/hash@0.9.2':
+    resolution: {integrity: sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g==}
+
+  '@emotion/memoize@0.9.0':
+    resolution: {integrity: sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==}
+
+  '@emotion/serialize@1.3.3':
+    resolution: {integrity: sha512-EISGqt7sSNWHGI76hC7x1CksiXPahbxEOrC5RjmFRJTqLyEK9/9hZvBbiYn70dw4wuwMKiEMCUlR6ZXTSWQqxA==}
+
+  '@emotion/sheet@1.4.0':
+    resolution: {integrity: sha512-fTBW9/8r2w3dXWYM4HCB1Rdp8NLibOw2+XELH5m5+AkWiL/KqYX6dc0kKYlaYyKjrQ6ds33MCdMPEwgs2z1rqg==}
+
+  '@emotion/unitless@0.10.0':
+    resolution: {integrity: sha512-dFoMUuQA20zvtVTuxZww6OHoJYgrzfKM1t52mVySDJnMSEa08ruEvdYQbhvyu6soU+NeLVd3yKfTfT0NeV6qGg==}
+
+  '@emotion/utils@1.4.2':
+    resolution: {integrity: sha512-3vLclRofFziIa3J2wDh9jjbkUz9qk5Vi3IZ/FSTKViB0k+ef0fPV7dYrUIugbgupYDx7v9ud/SjrtEP8Y4xLoA==}
+
+  '@emotion/weak-memoize@0.4.0':
+    resolution: {integrity: sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg==}
+
   '@esbuild/aix-ppc64@0.21.5':
     resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
     engines: {node: '>=12'}
@@ -1769,12 +2136,27 @@ packages:
   '@floating-ui/core@1.7.5':
     resolution: {integrity: sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==}
 
+  '@floating-ui/core@1.8.0':
+    resolution: {integrity: sha512-0CIZ5itps/8x7BG8dEIhs53BvCUH2PCoogtakwRTut+Arm58sJooJ0AuZhLw2HJYIR5cMLNPBSS728sPho2khQ==}
+
   '@floating-ui/dom@1.7.6':
     resolution: {integrity: sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==}
 
+  '@floating-ui/dom@1.8.0':
+    resolution: {integrity: sha512-yXSrzeHZBTZadLOlfyhCkJHNeLJnHRnRInwdZ40L7ZiaAtrBwoYlsDrX3v5zB1Utk7CLfzcOVnVVWoXEky7Ceg==}
+
+  '@floating-ui/react-dom@2.1.9':
+    resolution: {integrity: sha512-JDjEFGCpImxDCA7JJKviA0M9+RtmJdj0m/NVU5IMgBK+AmZouAQQ7/+2GLH0GXXY0YMw9oXPB8hKdbPYg5QLYg==}
+    peerDependencies:
+      react: '>=16.8.0'
+      react-dom: '>=16.8.0'
+
   '@floating-ui/utils@0.2.11':
     resolution: {integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==}
 
+  '@floating-ui/utils@0.2.12':
+    resolution: {integrity: sha512-HpCo8tmWzLVad5s2d19EhAz5zqrrQ6s69qd6moPMQvkOuSwDT1YgRfWSVuc4ennqrgv3OHppiOGMQ7oC13yIww==}
+
   '@fontsource-variable/inter@5.2.8':
     resolution: {integrity: sha512-kOfP2D+ykbcX/P3IFnokOhVRNoTozo5/JxhAIVYLpea/UBmCQ/YWPBfWIDuBImXX/15KH+eKh4xpEUyS2sQQGQ==}
 
@@ -1814,6 +2196,28 @@ packages:
   '@iconify/utils@3.1.3':
     resolution: {integrity: sha512-LPKOXPn/zV+zis1oOfGWogaXVpqUybF3ZS6SCZIsz8vg0ivVp9+fVqyYB7xq0aiST/VhUQYGO1qo6uoYSiEJqw==}
 
+  '@inquirer/ansi@2.0.7':
+    resolution: {integrity: sha512-3eTuUO1vH2cZm2ZKHeQxnOqlTi9EfZDGgIe3BL3I4u+rJHocr9Fz86M4fjYABPvFnQG/gGK551HqDiIcETwU6Q==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^20.17.0'}
+
+  '@inquirer/confirm@6.1.1':
+    resolution: {integrity: sha512-eb8DBZcz/2qHWQda4rk2JiQk5h9QV/cVHi1yjt0f69WFZMRFn0sJTye3EAP8icut8UDMjQPsaH5KbcOogefrFQ==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^20.17.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/core@11.2.1':
+    resolution: {integrity: sha512-Qd6GJT1yVyrZZCfN8W2qKF5ApmqryXRhRKCuip8h01x2w/esJQ2XIYc6f9abMIHgKQdBfFTSOdbHRLAhuM09UA==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^20.17.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
   '@inquirer/external-editor@1.0.3':
     resolution: {integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==}
     engines: {node: '>=18'}
@@ -1823,6 +2227,19 @@ packages:
       '@types/node':
         optional: true
 
+  '@inquirer/figures@2.0.7':
+    resolution: {integrity: sha512-aJ8TBPOGB6f/2qziPfElISTCEd5XOYTFckA2SGjhNmiKzfK/u4ot3v0DUzGVdUnKjN10EqnnEPck36BkyfLnJw==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^20.17.0'}
+
+  '@inquirer/type@4.0.7':
+    resolution: {integrity: sha512-t28inv14nMQ1PhKpsJPY+kEs/c00qzeCOS2gTNRyTjG5d6qsVA2fItxW4hkvGZ5lvanGLdtCzVIx5dwdRpN1+g==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^20.17.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
   '@intlify/core-base@11.4.5':
     resolution: {integrity: sha512-lja3F/iKVIvTa48mIwmrIeDcQUFZ0F0drvFvT8AwINOvbwnAzl/S/p8p2DxILZpWEUHRi1qewfWNIkMvhD3kKA==}
     engines: {node: '>= 22'}
@@ -1847,6 +2264,10 @@ packages:
     resolution: {integrity: sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==}
     engines: {node: '>=18.0.0'}
 
+  '@istanbuljs/schema@0.1.6':
+    resolution: {integrity: sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw==}
+    engines: {node: '>=8'}
+
   '@jimp/core@1.6.1':
     resolution: {integrity: sha512-+BoKC5G6hkrSy501zcJ2EpfnllP+avPevcBfRcZe/CW+EwEfY6X1EZ8QWyT7NpDIvEEJb1fdJnMMfUnFkxmw9A==}
     engines: {node: '>=18'}
@@ -2096,12 +2517,110 @@ packages:
     resolution: {integrity: sha512-juG5VWh4qAivzTAeMzvY9xs9HY5rAcr2E4I7tiSSCokRFi7XIZCAu92ZkSTsIj1OPceCifL3cpfteP3pDT9/QQ==}
     engines: {node: '>=14.0.0'}
 
+  '@mswjs/interceptors@0.41.9':
+    resolution: {integrity: sha512-VVPPgHyQ6ShqnrmDWuxjmUIsO9gWyOZFmuOfLd9LfBGQJwZfy0gvv9pbHSJuoFNIYC7ZDX9aoFwowjcdSC4E8w==}
+    engines: {node: '>=18'}
+
+  '@napi-rs/wasm-runtime@0.2.12':
+    resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==}
+
   '@napi-rs/wasm-runtime@1.1.4':
     resolution: {integrity: sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==}
     peerDependencies:
       '@emnapi/core': ^1.7.1
       '@emnapi/runtime': ^1.7.1
 
+  '@node-rs/crc32-android-arm-eabi@1.10.6':
+    resolution: {integrity: sha512-vZAMuJXm3TpWPOkkhxdrofWDv+Q+I2oO7ucLRbXyAPmXFNDhHtBxbO1rk9Qzz+M3eep8ieS4/+jCL1Q0zacNMQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm]
+    os: [android]
+
+  '@node-rs/crc32-android-arm64@1.10.6':
+    resolution: {integrity: sha512-Vl/JbjCinCw/H9gEpZveWCMjxjcEChDcDBM8S4hKay5yyoRCUHJPuKr4sjVDBeOm+1nwU3oOm6Ca8dyblwp4/w==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [android]
+
+  '@node-rs/crc32-darwin-arm64@1.10.6':
+    resolution: {integrity: sha512-kARYANp5GnmsQiViA5Qu74weYQ3phOHSYQf0G+U5wB3NB5JmBHnZcOc46Ig21tTypWtdv7u63TaltJQE41noyg==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@node-rs/crc32-darwin-x64@1.10.6':
+    resolution: {integrity: sha512-Q99bevJVMfLTISpkpKBlXgtPUItrvTWKFyiqoKH5IvscZmLV++NH4V13Pa17GTBmv9n18OwzgQY4/SRq6PQNVA==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@node-rs/crc32-freebsd-x64@1.10.6':
+    resolution: {integrity: sha512-66hpawbNjrgnS9EDMErta/lpaqOMrL6a6ee+nlI2viduVOmRZWm9Rg9XdGTK/+c4bQLdtC6jOd+Kp4EyGRYkAg==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@node-rs/crc32-linux-arm-gnueabihf@1.10.6':
+    resolution: {integrity: sha512-E8Z0WChH7X6ankbVm8J/Yym19Cq3otx6l4NFPS6JW/cWdjv7iw+Sps2huSug+TBprjbcEA+s4TvEwfDI1KScjg==}
+    engines: {node: '>= 10'}
+    cpu: [arm]
+    os: [linux]
+
+  '@node-rs/crc32-linux-arm64-gnu@1.10.6':
+    resolution: {integrity: sha512-LmWcfDbqAvypX0bQjQVPmQGazh4dLiVklkgHxpV4P0TcQ1DT86H/SWpMBMs/ncF8DGuCQ05cNyMv1iddUDugoQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@node-rs/crc32-linux-arm64-musl@1.10.6':
+    resolution: {integrity: sha512-k8ra/bmg0hwRrIEE8JL1p32WfaN9gDlUUpQRWsbxd1WhjqvXea7kKO6K4DwVxyxlPhBS9Gkb5Urq7Y4mXANzaw==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@node-rs/crc32-linux-x64-gnu@1.10.6':
+    resolution: {integrity: sha512-IfjtqcuFK7JrSZ9mlAFhb83xgium30PguvRjIMI45C3FJwu18bnLk1oR619IYb/zetQT82MObgmqfKOtgemEKw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@node-rs/crc32-linux-x64-musl@1.10.6':
+    resolution: {integrity: sha512-LbFYsA5M9pNunOweSt6uhxenYQF94v3bHDAQRPTQ3rnjn+mK6IC7YTAYoBjvoJP8lVzcvk9hRj8wp4Jyh6Y80g==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@node-rs/crc32-wasm32-wasi@1.10.6':
+    resolution: {integrity: sha512-KaejdLgHMPsRaxnM+OG9L9XdWL2TabNx80HLdsCOoX9BVhEkfh39OeahBo8lBmidylKbLGMQoGfIKDjq0YMStw==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+
+  '@node-rs/crc32-win32-arm64-msvc@1.10.6':
+    resolution: {integrity: sha512-x50AXiSxn5Ccn+dCjLf1T7ZpdBiV1Sp5aC+H2ijhJO4alwznvXgWbopPRVhbp2nj0i+Gb6kkDUEyU+508KAdGQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@node-rs/crc32-win32-ia32-msvc@1.10.6':
+    resolution: {integrity: sha512-DpDxQLaErJF9l36aghe1Mx+cOnYLKYo6qVPqPL9ukJ5rAGLtCdU0C+Zoi3gs9ySm8zmbFgazq/LvmsZYU42aBw==}
+    engines: {node: '>= 10'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@node-rs/crc32-win32-x64-msvc@1.10.6':
+    resolution: {integrity: sha512-5B1vXosIIBw1m2Rcnw62IIfH7W9s9f7H7Ma0rRuhT8HR4Xh8QCgw6NJSI2S2MCngsGktYnAhyUvs81b7efTyQw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
+  '@node-rs/crc32@1.10.6':
+    resolution: {integrity: sha512-+llXfqt+UzgoDzT9of5vPQPGqTAVCohU74I9zIBkNo5TH6s2P31DFJOGsJQKN207f0GHnYv5pV3wh3BCY/un/A==}
+    engines: {node: '>= 10'}
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -2123,6 +2642,18 @@ packages:
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
     deprecated: This functionality has been moved to @npmcli/fs
 
+  '@open-draft/deferred-promise@2.2.0':
+    resolution: {integrity: sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA==}
+
+  '@open-draft/deferred-promise@3.0.0':
+    resolution: {integrity: sha512-XW375UK8/9SqUVNVa6M0yEy8+iTi4QN5VZ7aZuRFQmy76LRwI9wy5F4YIBU6T+eTe2/DNDo8tqu8RHlwLHM6RA==}
+
+  '@open-draft/logger@0.3.0':
+    resolution: {integrity: sha512-X2g45fzhxH238HKO4xbSr7+wBS8Fvw6ixhTDuvLd5mqh6bJJCFAPwU9mPDxbcrRtfxv4u5IHCEH77BmxvXmmxQ==}
+
+  '@open-draft/until@2.1.0':
+    resolution: {integrity: sha512-U69T3ItWHvLwGg5eJ0n3I62nWuE6ilHlmz7zM0npLBRvPRd7e6NYmg54vvRtP5mZG7kZqZCFVdsTWo7BPtBujg==}
+
   '@oxc-project/types@0.122.0':
     resolution: {integrity: sha512-oLAl5kBpV4w69UtFZ9xqcmTi+GENWOcPF7FCrczTiBbmC0ibXxCwyvZGbO39rCVEuLGAZM84DH0pUIyyv/YJzA==}
 
@@ -2328,6 +2859,696 @@ packages:
   '@quansync/fs@1.0.0':
     resolution: {integrity: sha512-4TJ3DFtlf1L5LDMaM6CanJ/0lckGNtJcMjQ1NAV6zDmA0tEHKZtxNKin8EgPaVX1YzljbxckyT2tJrpQKAtngQ==}
 
+  '@radix-ui/number@1.1.2':
+    resolution: {integrity: sha512-ceTwaxc4I5IOi97DgCotl3pqiyRGvffcc0oOsE2dQYaJOFIDsDt4VWG6xEbg1QePv9QWausCEIppud/tJ1wNig==}
+
+  '@radix-ui/primitive@1.1.5':
+    resolution: {integrity: sha512-d86WIWFYNtGA0H/d8exstrTRTp7eWJYlYJbtNofxr/3ljupZYn6EFDG/Qgu/0Kc8v7yMUxySagqJsL1+PdYjWg==}
+
+  '@radix-ui/react-accessible-icon@1.1.11':
+    resolution: {integrity: sha512-HQDOFTKwSnmUij6l54wYJJtxTAnxI71+YJLOrjm2ladFB8HAV5Jt7hwaZPhWTGBkYoW4+ZAOfNZrLDh/qvxSYA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-accordion@1.2.16':
+    resolution: {integrity: sha512-BpZJNmetujnGgUI6OX0jEhEmlA46WPqgub8Rv09Kyquwd0cc1ndMKpiPYCjmBU6KSSRPAMtgLpEoZSG/tdNIWQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-alert-dialog@1.1.19':
+    resolution: {integrity: sha512-FA7n1f6D/DwGE0+AWxiY5LacNbbExQuEgMubeG06idEaH+mSLuf9dp/qBNqOnvbTQ+4gZ2ue1RATF1Ub91Mg5g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-arrow@1.1.11':
+    resolution: {integrity: sha512-Kdil9BB1rIFC/khmf4hC35bn8701AJcizTU7G7cUbEbk5XqqbjDuHW60uUfKqO5WojjZcbAW51Q7P0hRmMLw8A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-aspect-ratio@1.1.11':
+    resolution: {integrity: sha512-IUAhIVpBUvP5NNICjlaB1OFmtRLGqQqTF3ZOSGPoq3XeLXRFtHiWTRxSVEULgOd9GQR2c7tsYqDnhUennapZnw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-avatar@1.2.2':
+    resolution: {integrity: sha512-sST0qh8GzOB7besQ3tMLWLyngnRuSk0gc/Hm+667KYKQFCt6Y6ZXv25WlqM7dIDK54ULCh5+CHmk4LIolzfz+A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-checkbox@1.3.7':
+    resolution: {integrity: sha512-JroKHfQBfh+fDuzpPsBC+pESkhuq8ql4hljTguz8MWnS35cISr3d/Jhl9kYrB44FlDtxCArYdDvTx+BSsJ64rQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-collapsible@1.1.16':
+    resolution: {integrity: sha512-opfXRe6nnzyGmCDPx+l1Aqo/RbqWtQal2FnsBqF9hhePp6j0LsRoBaRxcMOlTv+uYTJVtWYZKg9t9wTe+BA/ZA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-collection@1.1.12':
+    resolution: {integrity: sha512-nb67INpE0IahJKN7EYPp9m9YGwYeKlnzxT3MwXVkgCskaSJia97kG4T0ywpjNUSSnoJk/uvk12V8vbrEHEj+/Q==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-compose-refs@1.1.3':
+    resolution: {integrity: sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-context-menu@2.3.3':
+    resolution: {integrity: sha512-PS+gKE0z2prJ74Y0sM+brAGK4mYOHIR7TlcV5EJgUQ6E0xMvyswkK2X4yRqyganrzsRL+WCSKAPu0NQITICRWg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-context@1.2.0':
+    resolution: {integrity: sha512-fOE+JtN9rygNZkCnHRBEP0TAvLldlhyOxMsbwFvTP4nAs+nBmfnna+o/Zski2wkmY1YMrFC0aSzsHoLY47iLrg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-dialog@1.1.19':
+    resolution: {integrity: sha512-+HhbN2+YtkRgVirjZ2afMeutQRuGOrdkWR5+EFC58SJojGmtyNQwYzgi6tHBpOxvFHefMtPeHdgtjz0BOGxFQg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-direction@1.1.2':
+    resolution: {integrity: sha512-C3vFhbyi4SW3PmbAi6Awpu4OzJtd0MxGurvSsYtr7p7nM8RNB3VAF3CUmnp2j50knpkrRcB7+ycVXzgLgF6yNA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-dismissable-layer@1.1.15':
+    resolution: {integrity: sha512-b0XaRlzn2QKuo10XyNgi2DAJDf5XC9d1nD3FJcuvCjbR7+4Ad28zmZsLsqx+hvDEzMnRuZaZxZm9gYObV6RmRA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-dropdown-menu@2.1.20':
+    resolution: {integrity: sha512-slfm+rRaZRuQBvHq60lXvSVUPhid0IPtjSZzIuUlWZMUs01iYZNlGS3mJgRD3ChLQVBAYlKiL/tFyWGX+dz8Xw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-focus-guards@1.1.4':
+    resolution: {integrity: sha512-cot/aB/mOm0IYVYTTmQcEEK1M48lZWi8FlYe5nDPQQ8NYZUlXEFgncJ9p2Kzer3RKSrY7cTTpEMLZKNo9QoP5Q==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-focus-scope@1.1.12':
+    resolution: {integrity: sha512-jjk/lqTeNL0azUx5ZYzVrl4NgaDIrdzTNE4mABV9yBFI7FQqN7pIgzV1bTleUezP2QiTGA1BFTqY8MegDgWX9A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-form@0.1.12':
+    resolution: {integrity: sha512-JTX94E4LDL91rzLg7X0mHPdxr0A8JEdVwZEmeOwZJSMDHCGW5DFtSlTSJozUyUs807IQmnvbfzKZFVCK5DmkqQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-hover-card@1.1.19':
+    resolution: {integrity: sha512-2KTgMLQtKvicznQgbindEI2RZ3QbDIwU5gabjUPwFJsormjGDz+rUvO4NANmYwzEEpTcTONUt33vBHIfTIVSfw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-id@1.1.2':
+    resolution: {integrity: sha512-orBC88futVpqCmhX1p4cvquNHsELQ+w+vBJnuj3ftETI5bJb0bZn3Tqu3SWN2IOcPycTnMGnhwoermvISt72sA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-label@2.1.11':
+    resolution: {integrity: sha512-3PKvDDxOn62k0oV1n4QtNtD2vpu+zYjXR7ojLBPaO6SPvhy53yg0vAmgNeBQeJW5rV3dffoRG+HYfLBZuzw0CQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-menu@2.1.20':
+    resolution: {integrity: sha512-VsUrXxFe9d2ScbZF0fR/oPR1+qjyeLs5p0jzG8h90puMoA9bq4SirYlXbE+USRg9Q2qTeJSFNqjw2nts8jJe4w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-menubar@1.1.20':
+    resolution: {integrity: sha512-gzFZvybgmwYsFBWDqanycIoEYnhyk8MMnuLamdFVHUZYGp4COM+sqXiwbnn0VMWqGLeeU7GV7jm+dXRa+Wufag==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-navigation-menu@1.2.18':
+    resolution: {integrity: sha512-K9HiuxZ6xCwSaHcIuUpxyhy4w5gpwzWjh9dHTSbMN3Ix4qAyVObS9RlU3zMycb0PO3v9Tpk0BXMwWvXOUbVXew==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-one-time-password-field@0.1.12':
+    resolution: {integrity: sha512-nQLu5OAcORDQp1EHAv6k3mJGV1hjMTw2NTGVAsGE1g/mWeNqAd1R5jyaAs3U+A8ZD/W8XNPY2yKT0ZdQnqo3NA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-password-toggle-field@0.1.7':
+    resolution: {integrity: sha512-gB1Mr8vzdv1XzDjrtJTXmL0JORRs1B4g7ngUs0F+H2VvMOwXTZMTmLCl0wZZ3m7ylX8TssI7NCvgiSHmLuTm/A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-popover@1.1.19':
+    resolution: {integrity: sha512-jkrTdQVxnIB8fpn0NyyxW9CTB5aCXZZelVz5z+Xmii6g5WxMqS3fInNslZ63puP39+Puu4jYohUK31y3dT87gQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-popper@1.3.3':
+    resolution: {integrity: sha512-mS7dGpyjv6b+gsDjLF7e0ia1W4Im1B1hSCy2yuXlHuvnZxHKagfDaobt/KAKt27EpZMit2pss8eJBVyVjEWM+g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-portal@1.1.13':
+    resolution: {integrity: sha512-z3oXfmaHLJTF1wktbjgD6cn9jiEbq3WSondB10LIuIt2m2Ym4iJlrW04/euMwENDdWDdE7z+OuY7Qyp1YpRSwA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-presence@1.1.7':
+    resolution: {integrity: sha512-zBZ4QM5XG3JRanDmqXYf3MD6th4AFXFmgU6KNMFzUaV6F3uw9I5/zjMUvFriSEn5ewo1nxuibvyxJdmLlDcslA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-primitive@2.1.7':
+    resolution: {integrity: sha512-bC3NiwsprbxKjuon9l7X6BUTw7FPVzEYaL92MPEY5SCd/9hUTPXVFtVwRix7778wtRsVao+zE062gL79FZleeQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-progress@1.1.12':
+    resolution: {integrity: sha512-ZPHyI0JyzoH/rP0tq2uRaIZTj/4s8+kAbqPz+e2N8+ejHvwPJ889dHhqn+vh7PNvNeq+boAoH9yzqeoShzwF2w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-radio-group@1.4.3':
+    resolution: {integrity: sha512-WwZFjWV4s3aC1QtR3k04R+oANHtX2q6fgKlc7MCEiDNlnTxCZ3H8k3mHtEgVlOejystwk1WQgarQhNOQZ2bK1g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-roving-focus@1.1.15':
+    resolution: {integrity: sha512-40svmmugfM3mUN7VUDGVE1tQGOhyi8enlGD0CNJEcMM36C1f71PKM21DFgNHUfem0XnA+d8H8oN3Z9ZpJjSslg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-scroll-area@1.2.14':
+    resolution: {integrity: sha512-bBODCWZK7JTbQLHs0uIP4f73wIWatakK4OS33UzkR1x897wu0PuO658a3f+6P2GEGyDzGYMuHRatMVoAk9WZTw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-select@2.3.3':
+    resolution: {integrity: sha512-L5RQTXz6Anxsf9CCv+pTgiAsUpyVj7rJxsGtmhFaEOJ++cVfXucv4qWfsIO0AIB4NAhi3yovWGVMKKS1Xf1Wrg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-separator@1.1.11':
+    resolution: {integrity: sha512-jRhe86+8PF7VZ1u14eOWVOuh2BuAhALg/FT1VcMC4OHedMTRUazDnDlKTt+yxo5cRNKHMfmvZ4sSQtWDeMV4CQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-slider@1.4.3':
+    resolution: {integrity: sha512-CWVVj+XaTom0SKCqw1EUgb0NuiLwS+N3OFG73mVEezKEjgNIvZiu0EevMelSSU+CbX3owbqJweG2gPU31WGC5A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-slot@1.3.0':
+    resolution: {integrity: sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-switch@1.3.3':
+    resolution: {integrity: sha512-1+mlB4/lxJfk5tgJ4g+R5mUCbRpPE1T9+UsEyeLYbGgMtwiMgmuTnfKz4Mw1nHALHjuwyxw4MLd4cSHn6pNSlQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-tabs@1.1.17':
+    resolution: {integrity: sha512-nRyXnrAVCwjeXcHbvEbLS6ndbTeKHG1RqCP4A8Gw5L4cemDzPXdD8rAmr6wet0v57R69wGvuIIsFjHSVkZiMzQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toast@1.2.19':
+    resolution: {integrity: sha512-SxfVZfVOibWKWdkf0Xx1awW2d09fQu4V4PXDY1j5hi4MVf7MWdJZqTBJMa1KWtOr1S6GGtCk02nniZ0Iia+dHw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toggle-group@1.1.15':
+    resolution: {integrity: sha512-gIC5Q+Xljg7lmUdzSuDoy0t97yZn1sZl00Ra37ZvKrYdWnQLU6sWLd09yG8cIB9jUAlQfHgJ2ACAG00MFwsqSQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toggle@1.1.14':
+    resolution: {integrity: sha512-QI/hB65XKWACA66P64A+aHxtLUgHJeJLkaQa+awUNXT6T3swndtY5DojeHA+vldrTspMTtFBd7HfZ9QGbM1Qrw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toolbar@1.1.15':
+    resolution: {integrity: sha512-t/iEuVjUnXXtrsGK40AA43uIx37sn3AqZ7oAVnPICK6lFJP6dzMzWR3U9b6eCfFjb6wtSEqkJ9Rn9xDjiOx20g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-tooltip@1.2.12':
+    resolution: {integrity: sha512-U3HoftgWnmla78vzQbLvKKb7bUYJxoiiqYFzp1wu/TBMyDqMZSuCl3aRICsD6EfVEwcJD2mumGDGUXLFVqQHKA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-use-callback-ref@1.1.2':
+    resolution: {integrity: sha512-xCso9j1/u8sEgP1RNHjFrXJLApL8LiqOkI1R4ywuN00rxWdYg4oQXuwKLS3i0j5NWLromUD27/4nlxj2UFVvIw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-controllable-state@1.2.3':
+    resolution: {integrity: sha512-PLzC90MS+ReootmjC597dvopoelpZ8Q61HJkDXZSExitIq7PL55vHNnesAHwguHK0aPfBnpdNzQtv1uliaqQrA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-effect-event@0.0.3':
+    resolution: {integrity: sha512-6c8ZqvPTWILEKnyVkP53EGRCcpnJiKTC21sS/6R1GF5xKyHJJWQEPfkqlcgUkdRQivd6tb23abUwe4ngWmY0JA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-escape-keydown@1.1.3':
+    resolution: {integrity: sha512-3wEkMiPHXha/2VadZ68rYBcmYnPINVGl4Y3gtcM7fKRjANk0OscK+cdqBgUWdozb7YJxsh0vefM7vgAMHXOjqg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-is-hydrated@0.1.1':
+    resolution: {integrity: sha512-qwOiz4Tjo8CNnrOLAYUMXeZwDzXgXpvK4TKQPmWLECM9XoWvA6+0Z2/7Ag3A4ivjS4ovbLJPbskkxioFyBhr8A==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-layout-effect@1.1.2':
+    resolution: {integrity: sha512-jrBWOxZITuGcnjRCM2t2U5ZPkCLxD+Ym6DjfssS5haTj2iiak/DOb64JeN6OdLfLgptb6/e2kKR+ZuTrGoZTPA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-previous@1.1.2':
+    resolution: {integrity: sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-rect@1.1.2':
+    resolution: {integrity: sha512-d8a+bBY/FxikNPlgJJoaBHZX+zKVbWHYJGTLnLvveQgFSTntkGdEKv3JDtHrMS0DNYpllz2nRsTLGLKYttbpmw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-size@1.1.2':
+    resolution: {integrity: sha512-giWQp+4mxjBPt4KZ0MmyuykFNWfbDxKt4x+fPkRYmgRFJSbCZFzUglvMb/Kjn38tm10YP4ufiQZDx3zna4LU6w==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-visually-hidden@1.2.7':
+    resolution: {integrity: sha512-1wNZBggTDK3GRuuQ6nP4k2yi7a6l7I5qbMPbZcRsrGsGVead/f/d5FhEzUvqFs0bcrDLx7n1zKQ3JvLR6whaaw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/rect@1.1.2':
+    resolution: {integrity: sha512-xnXE7wG13PI+cxieVssYXlQJuYVRhH9NBoxt3KNwzghDIA69GMm7d4wXRouHIYjE+KvS6U/MsMO73NdS2MH9ZA==}
+
   '@rolldown/binding-android-arm64@1.0.0-rc.12':
     resolution: {integrity: sha512-pv1y2Fv0JybcykuiiD3qBOBdz6RteYojRFY1d+b95WVuzx211CRh+ytI/+9iVyWQ6koTh5dawe4S/yRfOFjgaA==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -2793,6 +4014,54 @@ packages:
   '@rushstack/ts-command-line@5.3.9':
     resolution: {integrity: sha512-GIHqU+sRGQ3LGWAZu1O+9Yh++qwtyNIIGuNbcWHJjBTm2qRez0cwINUHZ+pQLR8UuzZDcMajrDaNbUYoaL/XtQ==}
 
+  '@sec-ant/readable-stream@0.4.1':
+    resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==}
+
+  '@secretlint/config-creator@10.2.2':
+    resolution: {integrity: sha512-BynOBe7Hn3LJjb3CqCHZjeNB09s/vgf0baBaHVw67w7gHF0d25c3ZsZ5+vv8TgwSchRdUCRrbbcq5i2B1fJ2QQ==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/config-loader@10.2.2':
+    resolution: {integrity: sha512-ndjjQNgLg4DIcMJp4iaRD6xb9ijWQZVbd9694Ol2IszBIbGPPkwZHzJYKICbTBmh6AH/pLr0CiCaWdGJU7RbpQ==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/core@10.2.2':
+    resolution: {integrity: sha512-6rdwBwLP9+TO3rRjMVW1tX+lQeo5gBbxl1I5F8nh8bgGtKwdlCMhMKsBWzWg1ostxx/tIG7OjZI0/BxsP8bUgw==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/formatter@10.2.2':
+    resolution: {integrity: sha512-10f/eKV+8YdGKNQmoDUD1QnYL7TzhI2kzyx95vsJKbEa8akzLAR5ZrWIZ3LbcMmBLzxlSQMMccRmi05yDQ5YDA==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/node@10.2.2':
+    resolution: {integrity: sha512-eZGJQgcg/3WRBwX1bRnss7RmHHK/YlP/l7zOQsrjexYt6l+JJa5YhUmHbuGXS94yW0++3YkEJp0kQGYhiw1DMQ==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/profiler@10.2.2':
+    resolution: {integrity: sha512-qm9rWfkh/o8OvzMIfY8a5bCmgIniSpltbVlUVl983zDG1bUuQNd1/5lUEeWx5o/WJ99bXxS7yNI4/KIXfHexig==}
+
+  '@secretlint/resolver@10.2.2':
+    resolution: {integrity: sha512-3md0cp12e+Ae5V+crPQYGd6aaO7ahw95s28OlULGyclyyUtf861UoRGS2prnUrKh7MZb23kdDOyGCYb9br5e4w==}
+
+  '@secretlint/secretlint-formatter-sarif@10.2.2':
+    resolution: {integrity: sha512-ojiF9TGRKJJw308DnYBucHxkpNovDNu1XvPh7IfUp0A12gzTtxuWDqdpuVezL7/IP8Ua7mp5/VkDMN9OLp1doQ==}
+
+  '@secretlint/secretlint-rule-no-dotenv@10.2.2':
+    resolution: {integrity: sha512-KJRbIShA9DVc5Va3yArtJ6QDzGjg3PRa1uYp9As4RsyKtKSSZjI64jVca57FZ8gbuk4em0/0Jq+uy6485wxIdg==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/secretlint-rule-preset-recommend@10.2.2':
+    resolution: {integrity: sha512-K3jPqjva8bQndDKJqctnGfwuAxU2n9XNCPtbXVI5JvC7FnQiNg/yWlQPbMUlBXtBoBGFYp08A94m6fvtc9v+zA==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/source-creator@10.2.2':
+    resolution: {integrity: sha512-h6I87xJfwfUTgQ7irWq7UTdq/Bm1RuQ/fYhA3dtTIAop5BwSFmZyrchph4WcoEvbN460BWKmk4RYSvPElIIvxw==}
+    engines: {node: '>=20.0.0'}
+
+  '@secretlint/types@10.2.2':
+    resolution: {integrity: sha512-Nqc90v4lWCXyakD6xNyNACBJNJ0tNCwj2WNk/7ivyacYHxiITVgmLUFXTBOeCdy79iz6HtN9Y31uw/jbLrdOAg==}
+    engines: {node: '>=20.0.0'}
+
   '@shikijs/core@2.5.0':
     resolution: {integrity: sha512-uu/8RExTKtavlpH7XqnVYBrfBkUc20ngXiX9NSrBhOVZYv/7XQRKUyhtkeflY5QsxC0GbJThCerruZfsUaSldg==}
 
@@ -2855,6 +4124,14 @@ packages:
     resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==}
     engines: {node: '>=10'}
 
+  '@sindresorhus/merge-streams@2.3.0':
+    resolution: {integrity: sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg==}
+    engines: {node: '>=18'}
+
+  '@sindresorhus/merge-streams@4.0.0':
+    resolution: {integrity: sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==}
+    engines: {node: '>=18'}
+
   '@sinonjs/commons@3.0.1':
     resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==}
 
@@ -2874,39 +4151,87 @@ packages:
     resolution: {integrity: sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==}
     engines: {node: '>=10'}
 
+  '@tabler/icons-react@3.44.0':
+    resolution: {integrity: sha512-8+rvzBbVm/1Z3sG3x7GUNAaxIKxwgz8xaMhRs23nrCnMTKRFAhEC+82zAIFeAA0seXdrAGX5HFCkaLpGK2rVHg==}
+    peerDependencies:
+      react: '>= 16'
+
+  '@tabler/icons@3.44.0':
+    resolution: {integrity: sha512-Wn0AOZG9sg0L+bjfMqq4eNhC6pQjIrk94LvvWYNYkY8KH8wC3YILRzQlrnVJc4FUeMxH/AK97QsYCX35H3LndA==}
+
+  '@tailwindcss/node@4.1.18':
+    resolution: {integrity: sha512-DoR7U1P7iYhw16qJ49fgXUlry1t4CpXeErJHnQ44JgTSKMaZUdf17cfn5mHchfJ4KRBZRFA/Coo+MUF5+gOaCQ==}
+
   '@tailwindcss/node@4.2.2':
     resolution: {integrity: sha512-pXS+wJ2gZpVXqFaUEjojq7jzMpTGf8rU6ipJz5ovJV6PUGmlJ+jvIwGrzdHdQ80Sg+wmQxUFuoW1UAAwHNEdFA==}
 
+  '@tailwindcss/oxide-android-arm64@4.1.18':
+    resolution: {integrity: sha512-dJHz7+Ugr9U/diKJA0W6N/6/cjI+ZTAoxPf9Iz9BFRF2GzEX8IvXxFIi/dZBloVJX/MZGvRuFA9rqwdiIEZQ0Q==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [android]
+
   '@tailwindcss/oxide-android-arm64@4.2.2':
     resolution: {integrity: sha512-dXGR1n+P3B6748jZO/SvHZq7qBOqqzQ+yFrXpoOWWALWndF9MoSKAT3Q0fYgAzYzGhxNYOoysRvYlpixRBBoDg==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [android]
 
+  '@tailwindcss/oxide-darwin-arm64@4.1.18':
+    resolution: {integrity: sha512-Gc2q4Qhs660bhjyBSKgq6BYvwDz4G+BuyJ5H1xfhmDR3D8HnHCmT/BSkvSL0vQLy/nkMLY20PQ2OoYMO15Jd0A==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
   '@tailwindcss/oxide-darwin-arm64@4.2.2':
     resolution: {integrity: sha512-iq9Qjr6knfMpZHj55/37ouZeykwbDqF21gPFtfnhCCKGDcPI/21FKC9XdMO/XyBM7qKORx6UIhGgg6jLl7BZlg==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [darwin]
 
+  '@tailwindcss/oxide-darwin-x64@4.1.18':
+    resolution: {integrity: sha512-FL5oxr2xQsFrc3X9o1fjHKBYBMD1QZNyc1Xzw/h5Qu4XnEBi3dZn96HcHm41c/euGV+GRiXFfh2hUCyKi/e+yw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
   '@tailwindcss/oxide-darwin-x64@4.2.2':
     resolution: {integrity: sha512-BlR+2c3nzc8f2G639LpL89YY4bdcIdUmiOOkv2GQv4/4M0vJlpXEa0JXNHhCHU7VWOKWT/CjqHdTP8aUuDJkuw==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [darwin]
 
+  '@tailwindcss/oxide-freebsd-x64@4.1.18':
+    resolution: {integrity: sha512-Fj+RHgu5bDodmV1dM9yAxlfJwkkWvLiRjbhuO2LEtwtlYlBgiAT4x/j5wQr1tC3SANAgD+0YcmWVrj8R9trVMA==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [freebsd]
+
   '@tailwindcss/oxide-freebsd-x64@4.2.2':
     resolution: {integrity: sha512-YUqUgrGMSu2CDO82hzlQ5qSb5xmx3RUrke/QgnoEx7KvmRJHQuZHZmZTLSuuHwFf0DJPybFMXMYf+WJdxHy/nQ==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [freebsd]
 
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18':
+    resolution: {integrity: sha512-Fp+Wzk/Ws4dZn+LV2Nqx3IilnhH51YZoRaYHQsVq3RQvEl+71VGKFpkfHrLM/Li+kt5c0DJe/bHXK1eHgDmdiA==}
+    engines: {node: '>= 10'}
+    cpu: [arm]
+    os: [linux]
+
   '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.2':
     resolution: {integrity: sha512-FPdhvsW6g06T9BWT0qTwiVZYE2WIFo2dY5aCSpjG/S/u1tby+wXoslXS0kl3/KXnULlLr1E3NPRRw0g7t2kgaQ==}
     engines: {node: '>= 20'}
     cpu: [arm]
     os: [linux]
 
+  '@tailwindcss/oxide-linux-arm64-gnu@4.1.18':
+    resolution: {integrity: sha512-S0n3jboLysNbh55Vrt7pk9wgpyTTPD0fdQeh7wQfMqLPM/Hrxi+dVsLsPrycQjGKEQk85Kgbx+6+QnYNiHalnw==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
   '@tailwindcss/oxide-linux-arm64-gnu@4.2.2':
     resolution: {integrity: sha512-4og1V+ftEPXGttOO7eCmW7VICmzzJWgMx+QXAJRAhjrSjumCwWqMfkDrNu1LXEQzNAwz28NCUpucgQPrR4S2yw==}
     engines: {node: '>= 20'}
@@ -2914,6 +4239,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@tailwindcss/oxide-linux-arm64-musl@4.1.18':
+    resolution: {integrity: sha512-1px92582HkPQlaaCkdRcio71p8bc8i/ap5807tPRDK/uw953cauQBT8c5tVGkOwrHMfc2Yh6UuxaH4vtTjGvHg==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
   '@tailwindcss/oxide-linux-arm64-musl@4.2.2':
     resolution: {integrity: sha512-oCfG/mS+/+XRlwNjnsNLVwnMWYH7tn/kYPsNPh+JSOMlnt93mYNCKHYzylRhI51X+TbR+ufNhhKKzm6QkqX8ag==}
     engines: {node: '>= 20'}
@@ -2921,6 +4253,13 @@ packages:
     os: [linux]
     libc: [musl]
 
+  '@tailwindcss/oxide-linux-x64-gnu@4.1.18':
+    resolution: {integrity: sha512-v3gyT0ivkfBLoZGF9LyHmts0Isc8jHZyVcbzio6Wpzifg/+5ZJpDiRiUhDLkcr7f/r38SWNe7ucxmGW3j3Kb/g==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
   '@tailwindcss/oxide-linux-x64-gnu@4.2.2':
     resolution: {integrity: sha512-rTAGAkDgqbXHNp/xW0iugLVmX62wOp2PoE39BTCGKjv3Iocf6AFbRP/wZT/kuCxC9QBh9Pu8XPkv/zCZB2mcMg==}
     engines: {node: '>= 20'}
@@ -2928,6 +4267,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@tailwindcss/oxide-linux-x64-musl@4.1.18':
+    resolution: {integrity: sha512-bhJ2y2OQNlcRwwgOAGMY0xTFStt4/wyU6pvI6LSuZpRgKQwxTec0/3Scu91O8ir7qCR3AuepQKLU/kX99FouqQ==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
   '@tailwindcss/oxide-linux-x64-musl@4.2.2':
     resolution: {integrity: sha512-XW3t3qwbIwiSyRCggeO2zxe3KWaEbM0/kW9e8+0XpBgyKU4ATYzcVSMKteZJ1iukJ3HgHBjbg9P5YPRCVUxlnQ==}
     engines: {node: '>= 20'}
@@ -2935,6 +4281,18 @@ packages:
     os: [linux]
     libc: [musl]
 
+  '@tailwindcss/oxide-wasm32-wasi@4.1.18':
+    resolution: {integrity: sha512-LffYTvPjODiP6PT16oNeUQJzNVyJl1cjIebq/rWWBF+3eDst5JGEFSc5cWxyRCJ0Mxl+KyIkqRxk1XPEs9x8TA==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+    bundledDependencies:
+      - '@napi-rs/wasm-runtime'
+      - '@emnapi/core'
+      - '@emnapi/runtime'
+      - '@tybys/wasm-util'
+      - '@emnapi/wasi-threads'
+      - tslib
+
   '@tailwindcss/oxide-wasm32-wasi@4.2.2':
     resolution: {integrity: sha512-eKSztKsmEsn1O5lJ4ZAfyn41NfG7vzCg496YiGtMDV86jz1q/irhms5O0VrY6ZwTUkFy/EKG3RfWgxSI3VbZ8Q==}
     engines: {node: '>=14.0.0'}
@@ -2947,22 +4305,43 @@ packages:
       - '@emnapi/wasi-threads'
       - tslib
 
+  '@tailwindcss/oxide-win32-arm64-msvc@4.1.18':
+    resolution: {integrity: sha512-HjSA7mr9HmC8fu6bdsZvZ+dhjyGCLdotjVOgLA2vEqxEBZaQo9YTX4kwgEvPCpRh8o4uWc4J/wEoFzhEmjvPbA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
   '@tailwindcss/oxide-win32-arm64-msvc@4.2.2':
     resolution: {integrity: sha512-qPmaQM4iKu5mxpsrWZMOZRgZv1tOZpUm+zdhhQP0VhJfyGGO3aUKdbh3gDZc/dPLQwW4eSqWGrrcWNBZWUWaXQ==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [win32]
 
+  '@tailwindcss/oxide-win32-x64-msvc@4.1.18':
+    resolution: {integrity: sha512-bJWbyYpUlqamC8dpR7pfjA0I7vdF6t5VpUGMWRkXVE3AXgIZjYUYAK7II1GNaxR8J1SSrSrppRar8G++JekE3Q==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
   '@tailwindcss/oxide-win32-x64-msvc@4.2.2':
     resolution: {integrity: sha512-1T/37VvI7WyH66b+vqHj/cLwnCxt7Qt3WFu5Q8hk65aOvlwAhs7rAp1VkulBJw/N4tMirXjVnylTR72uI0HGcA==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [win32]
 
+  '@tailwindcss/oxide@4.1.18':
+    resolution: {integrity: sha512-EgCR5tTS5bUSKQgzeMClT6iCY3ToqE1y+ZB0AKldj809QXk1Y+3jB0upOYZrn9aGIzPtUsP7sX4QQ4XtjBB95A==}
+    engines: {node: '>= 10'}
+
   '@tailwindcss/oxide@4.2.2':
     resolution: {integrity: sha512-qEUA07+E5kehxYp9BVMpq9E8vnJuBHfJEC0vPC5e7iL/hw7HR61aDKoVoKzrG+QKp56vhNZe4qwkRmMC0zDLvg==}
     engines: {node: '>= 20'}
 
+  '@tailwindcss/vite@4.1.18':
+    resolution: {integrity: sha512-jVA+/UpKL1vRLg6Hkao5jldawNmRo7mQYrZtNHMIVpLfLhDml5nMRUo/8MwoX2vNXvnaXNNMedrMfMugAVX1nA==}
+    peerDependencies:
+      vite: ^5.2.0 || ^6 || ^7
+
   '@tailwindcss/vite@4.2.2':
     resolution: {integrity: sha512-mEiF5HO1QqCLXoNEfXVA1Tzo+cYsrqV7w9Juj2wdUFyW07JRenqMG225MvPwr3ZD9N1bFQj46X7r33iHxLUW0w==}
     peerDependencies:
@@ -2985,6 +4364,21 @@ packages:
   '@tanstack/virtual-core@3.14.0':
     resolution: {integrity: sha512-JLANqGy/D6k4Ujmh8Tr25lGimuOXNiaVyXaCAZS0W+1390sADdGnyUdSWNIfd49gebtIxGMij4IktRVzrdr12Q==}
 
+  '@textlint/ast-node-types@15.7.1':
+    resolution: {integrity: sha512-Wii5UgUKFEh9Uv6wbq1zr4/Kf+dtjiUuzPrrXzKp8H+ifkvKNzi23V4Nz+6wVyHQn5T28AFuc8VH8OtzvGYecA==}
+
+  '@textlint/linter-formatter@15.7.1':
+    resolution: {integrity: sha512-TdwZ/debWYFD05K3CcoHtwvnCrza29wZxD+BjDTk/V5N7iRqkK1dTTHSD4A8AIgROLiDkHJmIKQbasbmsg8AvA==}
+
+  '@textlint/module-interop@15.7.1':
+    resolution: {integrity: sha512-Jg+sQW2L/cRJypk59wtcMUVVpt8vmit5ZMT3gUnFwevP3A6Qp1HfOtUy9ObT4hBX3lOSGT/ekcCDxR1pL7uH1g==}
+
+  '@textlint/resolver@15.7.1':
+    resolution: {integrity: sha512-8XnO0pgF6mXnm41VvWmBbEIdGPhiCUt31uLZkOis1ECeg/1SoUcIT6Mx/F0e1rukq8l0UlOSeY9a31CsvRMK0g==}
+
+  '@textlint/types@15.7.1':
+    resolution: {integrity: sha512-Vye/GmFNBTgVzZFtIFJTmLB+s2A7oIADxNG6r9UhfPuY+Czv0z5G3xeyFZZudPlfxURsKUyPIU5XsjOFqVp33A==}
+
   '@tokenizer/inflate@0.4.1':
     resolution: {integrity: sha512-2mAv+8pkG6GIZiF1kNg1jAjh27IDxEPKwdGul3snfztFerfPGI1LjDezZp3i7BElXompqEtPmoPx6c2wgtWsOA==}
     engines: {node: '>=18'}
@@ -2996,6 +4390,9 @@ packages:
     resolution: {integrity: sha512-HqmEUIGRJ5fSXchkVgR5F7qn48bDBzv0kWj/Kfu5e6uci4UlEeng4331LnBkWffb++Ei3FOVLxo8JJWMFBDMeQ==}
     engines: {node: '>= 10'}
 
+  '@ts-morph/common@0.27.0':
+    resolution: {integrity: sha512-Wf29UqxWDpc+i61k3oIOzcUfQt79PIT9y/MWfAGlrkjg6lBC1hwDECLXPVJAhWjiGbfBCxZd65F/LIZF3+jeJQ==}
+
   '@ts-morph/common@0.29.0':
     resolution: {integrity: sha512-35oUmphHbJvQ/+UTwFNme/t2p3FoKiGJ5auTjjpNTop2dyREspirjMy82PLSC1pnDJ8ah1GU98hwpVt64YXQsg==}
 
@@ -3125,6 +4522,13 @@ packages:
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
+  '@types/diff@8.0.0':
+    resolution: {integrity: sha512-o7jqJM04gfaYrdCecCVMbZhNdG6T1MHg/oQoRFdERLV+4d+V7FijhiEAbFu0Usww84Yijk9yH58U4Jk4HbtzZw==}
+    deprecated: This is a stub types definition. diff provides its own type definitions, so you do not need this installed.
+
+  '@types/estree-jsx@1.0.5':
+    resolution: {integrity: sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==}
+
   '@types/estree@1.0.8':
     resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
@@ -3140,12 +4544,21 @@ packages:
   '@types/http-cache-semantics@4.2.0':
     resolution: {integrity: sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==}
 
+  '@types/istanbul-lib-coverage@2.0.6':
+    resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==}
+
+  '@types/js-cookie@3.0.6':
+    resolution: {integrity: sha512-wkw9yd1kEXOPnvEeEV1Go1MmxtBJL0RR79aOTAApecWFVu7w0NNXNqhcWgvw2YgZDYadliXkl14pa3WXw5jlCQ==}
+
   '@types/js-yaml@4.0.9':
     resolution: {integrity: sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==}
 
   '@types/jsesc@2.5.1':
     resolution: {integrity: sha512-9VN+6yxLOPLOav+7PwjZbxiID2bVaeq0ED4qSQmdQTdjnXJSaCVKTR58t15oqH1H5t8Ng2ZX1SabJVoN9Q34bw==}
 
+  '@types/katex@0.16.8':
+    resolution: {integrity: sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg==}
+
   '@types/keyv@3.1.4':
     resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==}
 
@@ -3161,6 +4574,9 @@ packages:
   '@types/mdurl@2.0.0':
     resolution: {integrity: sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==}
 
+  '@types/mocha@10.0.10':
+    resolution: {integrity: sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==}
+
   '@types/ms@2.1.0':
     resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==}
 
@@ -3179,15 +4595,24 @@ packages:
   '@types/node@22.19.17':
     resolution: {integrity: sha512-wGdMcf+vPYM6jikpS/qhg6WiqSV/OhG+jeeHT/KlVqxYfD40iYJf9/AE1uQxVWFvU7MipKRkRv8NSHiCGgPr8Q==}
 
+  '@types/normalize-package-data@2.4.4':
+    resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==}
+
   '@types/nunjucks@3.2.6':
     resolution: {integrity: sha512-pHiGtf83na1nCzliuAdq8GowYiXvH5l931xZ0YEHaLMNFgynpEqx+IPStlu7UaDkehfvl01e4x/9Tpwhy7Ue3w==}
 
+  '@types/parse-json@4.0.2':
+    resolution: {integrity: sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==}
+
   '@types/picomatch@4.0.3':
     resolution: {integrity: sha512-iG0T6+nYJ9FAPmx9SsUlnwcq1ZVRuCXcVEvWnntoPlrOpwtSTKNDC9uVAxTsC3PUvJ+99n4RpAcNgBbHX3JSnQ==}
 
   '@types/plist@3.0.5':
     resolution: {integrity: sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==}
 
+  '@types/prismjs@1.26.6':
+    resolution: {integrity: sha512-vqlvI7qlMvcCBbVe0AKAb4f97//Hy0EBTaiW8AalRnG/xAN5zOiWWyrNqNXeq8+KAuvRewjCVY1+IPxk4RdNYw==}
+
   '@types/proper-lockfile@4.1.4':
     resolution: {integrity: sha512-uo2ABllncSqg9F1D4nugVl9v93RmjxF6LJzQLMLDdPaXCUIDPeOJ21Gbqi43xNKzBi/WQ0Q0dICqufzQbMjipQ==}
 
@@ -3196,6 +4621,12 @@ packages:
     peerDependencies:
       '@types/react': ^19.2.0
 
+  '@types/react-scroll-to-bottom@4.2.5':
+    resolution: {integrity: sha512-gYMMxxhphzTNfKc4NIkEgu4XRiQjfj/6R7QK10Igz8jOUPNXBLSnK3RS7ofsNWnJDEgpLkNOwSLuASASiGsfHQ==}
+
+  '@types/react-syntax-highlighter@15.5.13':
+    resolution: {integrity: sha512-uLGJ87j6Sz8UaBAooU0T6lWJ0dBmjZgN1PZTrj05TNql2/XpC6+4HhMT5syIdFUUt+FASfCeLLv4kBygNU+8qA==}
+
   '@types/react@19.2.14':
     resolution: {integrity: sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==}
 
@@ -3208,9 +4639,15 @@ packages:
   '@types/retry@0.12.0':
     resolution: {integrity: sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==}
 
+  '@types/sarif@2.1.7':
+    resolution: {integrity: sha512-kRz0VEkJqWLf1LLVN4pT1cg1Z9wAuvI6L97V3m2f5B76Tg8d413ddvLBPTEHAZJlnn4XSvu0FkZtViCQGVyrXQ==}
+
   '@types/semver@7.7.1':
     resolution: {integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==}
 
+  '@types/set-cookie-parser@2.4.10':
+    resolution: {integrity: sha512-GGmQVGpQWUe5qglJozEjZV/5dyxbOOZ0LHe/lqyWssB88Y4svNfst0uqBVscdDeIKl5Jy5+aPSvy7mI9tYRguw==}
+
   '@types/sinon@21.0.1':
     resolution: {integrity: sha512-5yoJSqLbjH8T9V2bksgRayuhpZy+723/z6wBOR+Soe4ZlXC0eW8Na71TeaZPUWDQvM7LYKa9UGFc6LRqxiR5fQ==}
 
@@ -3220,6 +4657,9 @@ packages:
   '@types/ssh2@1.15.5':
     resolution: {integrity: sha512-N1ASjp/nXH3ovBHddRJpli4ozpk6UdDYIX4RJWFa9L1YKnzdhTlVmiGHm4DZnj/jLbqZpes4aeR30EFGQtvhQQ==}
 
+  '@types/statuses@2.0.6':
+    resolution: {integrity: sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==}
+
   '@types/tar@7.0.87':
     resolution: {integrity: sha512-3IxNBV8LeY5oi2ZFpvAhOtW1+mHswkzM7BuisVrwJgPv67GBO2rkLPQlEKtzfHuLdhDDczhkCZeT+RuizMay4A==}
     deprecated: This is a stub types definition. tar provides its own type definitions, so you do not need this installed.
@@ -3227,12 +4667,21 @@ packages:
   '@types/trusted-types@2.0.7':
     resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==}
 
+  '@types/unist@2.0.11':
+    resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==}
+
   '@types/unist@3.0.3':
     resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
 
+  '@types/validate-npm-package-name@4.0.2':
+    resolution: {integrity: sha512-lrpDziQipxCEeK5kWxvljWYhUvOiB2A9izZd9B2AFarYAkqZshb4lPbRs7zKEic6eGtH8V/2qJW+dPp9OtF6bw==}
+
   '@types/verror@1.10.11':
     resolution: {integrity: sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg==}
 
+  '@types/vscode@1.100.0':
+    resolution: {integrity: sha512-4uNyvzHoraXEeCamR3+fzcBlh7Afs4Ifjs4epINyUX/jvdk0uzLnwiDY35UKDKnkCHP5Nu3dljl2H8lR6s+rQw==}
+
   '@types/web-bluetooth@0.0.21':
     resolution: {integrity: sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA==}
 
@@ -3245,6 +4694,10 @@ packages:
   '@types/yazl@2.4.6':
     resolution: {integrity: sha512-/ifFjQtcKaoZOjl5NNCQRR0fAKafB3Foxd7J/WvFPTMea46zekapcR30uzkwIkKAAuq5T6d0dkwz754RFH27hg==}
 
+  '@typespec/ts-http-runtime@0.3.7':
+    resolution: {integrity: sha512-JVUD8X2tfDMWjcjLs4yVxxVrS8yR5vnh386GAXT9Qj79nBxxXSaHFQZg5FweLmT8HlPQ3kii6noUB+Z9RN7DvQ==}
+    engines: {node: '>=22.0.0'}
+
   '@ungap/structured-clone@1.3.1':
     resolution: {integrity: sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==}
 
@@ -3311,6 +4764,68 @@ packages:
   '@volar/typescript@2.4.28':
     resolution: {integrity: sha512-Ja6yvWrbis2QtN4ClAKreeUZPVYMARDYZl9LMEv1iQ1QdepB6wn0jTRxA9MftYmYa4DQ4k/DaSZpFPUfxl8giw==}
 
+  '@vscode/test-cli@0.0.11':
+    resolution: {integrity: sha512-qO332yvzFqGhBMJrp6TdwbIydiHgCtxXc2Nl6M58mbH/Z+0CyLR76Jzv4YWPEthhrARprzCRJUqzFvTHFhTj7Q==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@vscode/test-electron@2.5.2':
+    resolution: {integrity: sha512-8ukpxv4wYe0iWMRQU18jhzJOHkeGKbnw7xWRX3Zw1WJA4cEKbHcmmLPdPrPtL6rhDcrlCZN+xKRpv09n4gRHYg==}
+    engines: {node: '>=16'}
+
+  '@vscode/vsce-sign-alpine-arm64@2.0.6':
+    resolution: {integrity: sha512-wKkJBsvKF+f0GfsUuGT0tSW0kZL87QggEiqNqK6/8hvqsXvpx8OsTEc3mnE1kejkh5r+qUyQ7PtF8jZYN0mo8Q==}
+    cpu: [arm64]
+    os: [alpine]
+
+  '@vscode/vsce-sign-alpine-x64@2.0.6':
+    resolution: {integrity: sha512-YoAGlmdK39vKi9jA18i4ufBbd95OqGJxRvF3n6ZbCyziwy3O+JgOpIUPxv5tjeO6gQfx29qBivQ8ZZTUF2Ba0w==}
+    cpu: [x64]
+    os: [alpine]
+
+  '@vscode/vsce-sign-darwin-arm64@2.0.6':
+    resolution: {integrity: sha512-5HMHaJRIQuozm/XQIiJiA0W9uhdblwwl2ZNDSSAeXGO9YhB9MH5C4KIHOmvyjUnKy4UCuiP43VKpIxW1VWP4tQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@vscode/vsce-sign-darwin-x64@2.0.6':
+    resolution: {integrity: sha512-25GsUbTAiNfHSuRItoQafXOIpxlYj+IXb4/qarrXu7kmbH94jlm5sdWSCKrrREs8+GsXF1b+l3OB7VJy5jsykw==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@vscode/vsce-sign-linux-arm64@2.0.6':
+    resolution: {integrity: sha512-cfb1qK7lygtMa4NUl2582nP7aliLYuDEVpAbXJMkDq1qE+olIw/es+C8j1LJwvcRq1I2yWGtSn3EkDp9Dq5FdA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@vscode/vsce-sign-linux-arm@2.0.6':
+    resolution: {integrity: sha512-UndEc2Xlq4HsuMPnwu7420uqceXjs4yb5W8E2/UkaHBB9OWCwMd3/bRe/1eLe3D8kPpxzcaeTyXiK3RdzS/1CA==}
+    cpu: [arm]
+    os: [linux]
+
+  '@vscode/vsce-sign-linux-x64@2.0.6':
+    resolution: {integrity: sha512-/olerl1A4sOqdP+hjvJ1sbQjKN07Y3DVnxO4gnbn/ahtQvFrdhUi0G1VsZXDNjfqmXw57DmPi5ASnj/8PGZhAA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@vscode/vsce-sign-win32-arm64@2.0.6':
+    resolution: {integrity: sha512-ivM/MiGIY0PJNZBoGtlRBM/xDpwbdlCWomUWuLmIxbi1Cxe/1nooYrEQoaHD8ojVRgzdQEUzMsRbyF5cJJgYOg==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@vscode/vsce-sign-win32-x64@2.0.6':
+    resolution: {integrity: sha512-mgth9Kvze+u8CruYMmhHw6Zgy3GRX2S+Ed5oSokDEK5vPEwGGKnmuXua9tmFhomeAnhgJnL4DCna3TiNuGrBTQ==}
+    cpu: [x64]
+    os: [win32]
+
+  '@vscode/vsce-sign@2.0.9':
+    resolution: {integrity: sha512-8IvaRvtFyzUnGGl3f5+1Cnor3LqaUWvhaUjAYO8Y39OUYlOf3cRd+dowuQYLpZcP3uwSG+mURwjEBOSq4SOJ0g==}
+
+  '@vscode/vsce@3.9.2':
+    resolution: {integrity: sha512-XSxMosEEDO6vLxELAHVkwmhC0qe0ijZni2jB9Rcs8kQsW4lhTDQ/wMzmwFs/buotAWSnpmUp/dRWD2ufG3UYKA==}
+    engines: {node: '>= 20'}
+    hasBin: true
+
   '@vue/compiler-core@3.5.35':
     resolution: {integrity: sha512-BUmHaR1J+O+CKZ9uJucdVTEr1LHsdyvv7vG3eNRhK3CczEHeMd/LtsHAuD7PbrxvI2envCY2v7HI1vC1aBRzKw==}
 
@@ -3468,6 +4983,12 @@ packages:
     resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==}
     engines: {node: '>=8'}
 
+  ahooks@3.9.7:
+    resolution: {integrity: sha512-S0lvzhbdlhK36RFBkGv+RbOM/dbbweym+BIHM/bwwuWVSVN5TuVErHPMWo4w0t1NDYg5KPp2iEf7Y7E5LASYiw==}
+    peerDependencies:
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
   ajv-draft-04@1.0.0:
     resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==}
     peerDependencies:
@@ -3476,6 +4997,14 @@ packages:
       ajv:
         optional: true
 
+  ajv-formats@2.1.1:
+    resolution: {integrity: sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
   ajv-formats@3.0.1:
     resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
     peerDependencies:
@@ -3536,6 +5065,10 @@ packages:
   any-promise@1.3.0:
     resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
 
+  anymatch@3.1.3:
+    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
+    engines: {node: '>= 8'}
+
   app-builder-bin@5.0.0-alpha.10:
     resolution: {integrity: sha512-Ev4jj3D7Bo+O0GPD2NMvJl+PGiBAfS7pUGawntBNpCbxtpncfUixqFj9z9Jme7V7s3LBGqsWZZP54fxBX3JKJw==}
 
@@ -3572,6 +5105,10 @@ packages:
   argparse@2.0.1:
     resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
 
+  aria-hidden@1.2.6:
+    resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
+    engines: {node: '>=10'}
+
   array-buffer-byte-length@1.0.2:
     resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==}
     engines: {node: '>= 0.4'}
@@ -3602,6 +5139,10 @@ packages:
     resolution: {integrity: sha512-trmleAnZ2PxN/loHWVhhx1qeOHSRXq4TDsBBxq3GqeJitfk3+jTQ+v/C1km/KYq9M7wKqCewMh+/NAvVH7m+bw==}
     engines: {node: '>=20.19.0'}
 
+  ast-types@0.16.1:
+    resolution: {integrity: sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg==}
+    engines: {node: '>=4'}
+
   ast-v8-to-istanbul@1.0.0:
     resolution: {integrity: sha512-1fSfIwuDICFA4LKkCzRPO7F0hzFf0B7+Xqrl27ynQaa+Rh0e1Es0v6kWHPott3lU10AyAr7oKHa65OppjLn3Rg==}
 
@@ -3631,6 +5172,10 @@ packages:
     resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==}
     engines: {node: '>=8.0.0'}
 
+  atomically@1.7.0:
+    resolution: {integrity: sha512-Xcz9l0z7y9yQ9rdDaxlmaI4uJHf/T8g9hOEzJcsEqX2SjCj4J20uK7+ldkDHMbpJDK76wF7xEIgxc/vSlsfw5w==}
+    engines: {node: '>=10.12.0'}
+
   available-typed-arrays@1.0.7:
     resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
     engines: {node: '>= 0.4'}
@@ -3642,6 +5187,13 @@ packages:
     resolution: {integrity: sha512-zJAaP9zxTcvTHRlejau3ZOY4V7SRpiByf3/dxx2uyKxxor19tpmpV2QRsTKikckwhaPmr2dVpxxMr7jOCYVp5g==}
     engines: {node: '>=6.0.0'}
 
+  azure-devops-node-api@12.5.0:
+    resolution: {integrity: sha512-R5eFskGvOm3U/GzeAuxRkUsAl0hrAwGgWn6zAd2KrZmrEhWZVqLew4OOupbQlXUuojUzpGtq62SmdhJ06N88og==}
+
+  babel-plugin-macros@3.1.0:
+    resolution: {integrity: sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==}
+    engines: {node: '>=10', npm: '>=6'}
+
   bail@2.0.2:
     resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==}
 
@@ -3673,6 +5225,14 @@ packages:
   bignumber.js@9.3.1:
     resolution: {integrity: sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==}
 
+  binary-extensions@2.3.0:
+    resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
+    engines: {node: '>=8'}
+
+  binaryextensions@6.11.0:
+    resolution: {integrity: sha512-sXnYK/Ij80TO3lcqZVV2YgfKN5QjUWIRk/XSm2J/4bd/lPko3lvk0O4ZppH6m+6hB2/GTu+ptNwVFe1xh+QLQw==}
+    engines: {node: '>=4'}
+
   birpc@2.9.0:
     resolution: {integrity: sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==}
 
@@ -3702,6 +5262,9 @@ packages:
     resolution: {integrity: sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==}
     deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
 
+  boundary@2.0.0:
+    resolution: {integrity: sha512-rJKn5ooC9u8q13IMCrW0RSp31pxBCHE3y9V/tp3TdWSLf8Em3p6Di4NBpfzbJge9YjjFEsD0RtFEjtvHL5VyEA==}
+
   brace-expansion@1.1.15:
     resolution: {integrity: sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==}
 
@@ -3716,6 +5279,9 @@ packages:
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
 
+  browser-stdout@1.3.1:
+    resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==}
+
   browserslist@4.28.2:
     resolution: {integrity: sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==}
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
@@ -3752,6 +5318,11 @@ packages:
     resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
     engines: {node: '>= 0.8'}
 
+  c8@9.1.0:
+    resolution: {integrity: sha512-mBWcT5iqNir1zIkzSPyI3NCR9EZCVI3WUD+AVO17MVWTSFNyUueXE82qTeampNtTr+ilN/5Ua3j24LgbCKjDVg==}
+    engines: {node: '>=14.14.0'}
+    hasBin: true
+
   cac@7.0.0:
     resolution: {integrity: sha512-tixWYgm5ZoOD+3g6UTea91eow5z6AAHaho3g0V9CNSNb45gM8SmflpAc+GRd1InC4AqN/07Unrgp56Y94N9hJQ==}
     engines: {node: '>=20.19.0'}
@@ -3780,6 +5351,14 @@ packages:
     resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
     engines: {node: '>= 0.4'}
 
+  callsites@3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+
+  camelcase@6.3.0:
+    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
+    engines: {node: '>=10'}
+
   caniuse-lite@1.0.30001788:
     resolution: {integrity: sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ==}
 
@@ -3811,13 +5390,30 @@ packages:
   character-entities@2.0.2:
     resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==}
 
+  character-reference-invalid@2.0.1:
+    resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==}
+
   chardet@2.1.1:
     resolution: {integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==}
 
+  cheerio-select@2.1.0:
+    resolution: {integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==}
+
+  cheerio@1.2.0:
+    resolution: {integrity: sha512-WDrybc/gKFpTYQutKIK6UvfcuxijIZfMfXaYm8NMsPQxSYvf+13fXUJ4rztGGbJcBQ/GF55gvrZ0Bc0bj/mqvg==}
+    engines: {node: '>=20.18.1'}
+
+  chokidar@3.6.0:
+    resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
+    engines: {node: '>= 8.10.0'}
+
   chokidar@4.0.3:
     resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
     engines: {node: '>= 14.16.0'}
 
+  chownr@1.1.4:
+    resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+
   chownr@2.0.0:
     resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
     engines: {node: '>=10'}
@@ -3829,6 +5425,9 @@ packages:
   chromium-pickle-js@0.2.0:
     resolution: {integrity: sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw==}
 
+  ci-info@2.0.0:
+    resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==}
+
   ci-info@3.9.0:
     resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
     engines: {node: '>=8'}
@@ -3836,9 +5435,15 @@ packages:
   cjs-module-lexer@1.4.3:
     resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==}
 
+  class-variance-authority@0.7.1:
+    resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==}
+
   classcat@5.0.5:
     resolution: {integrity: sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w==}
 
+  classnames@2.3.1:
+    resolution: {integrity: sha512-OlQdbZ7gLfGarSqxesMesDa5uz7KFbID8Kpq/SxIoNGDqY8lSYs0D+hhtBXhcdB3rcbXArFr7vlHheLk1voeNA==}
+
   clean-stack@2.2.0:
     resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==}
     engines: {node: '>=6'}
@@ -3872,6 +5477,10 @@ packages:
     resolution: {integrity: sha512-xRwvIOMGrfOAnM1JYtqQImuaNtDEv9v6oIYAs4LIHwTiKee8uwvIi363igssOC0O5U04i4AlENs79LQLu9tEMw==}
     engines: {node: '>=20'}
 
+  cli-width@4.1.0:
+    resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
+    engines: {node: '>= 12'}
+
   cliui@7.0.4:
     resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
 
@@ -3886,6 +5495,20 @@ packages:
     resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
     engines: {node: '>=0.8'}
 
+  clsx@2.1.1:
+    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
+    engines: {node: '>=6'}
+
+  cmdk@1.1.1:
+    resolution: {integrity: sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg==}
+    peerDependencies:
+      react: ^18 || ^19 || ^19.0.0-rc
+      react-dom: ^18 || ^19 || ^19.0.0-rc
+
+  cockatiel@3.2.1:
+    resolution: {integrity: sha512-gfrHV6ZPkquExvMh9IOkKsBzNDk6sDuZ6DdBGUBkvFnTCqCxzpuq48RySgP0AnaqQkw2zynOFj9yly6T1Q2G5Q==}
+    engines: {node: '>=16'}
+
   code-block-writer@13.0.3:
     resolution: {integrity: sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==}
 
@@ -3914,6 +5537,14 @@ packages:
     resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
     engines: {node: '>=14'}
 
+  commander@11.1.0:
+    resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==}
+    engines: {node: '>=16'}
+
+  commander@12.1.0:
+    resolution: {integrity: sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==}
+    engines: {node: '>=18'}
+
   commander@13.1.0:
     resolution: {integrity: sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==}
     engines: {node: '>=18'}
@@ -3926,6 +5557,10 @@ packages:
     resolution: {integrity: sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==}
     engines: {node: '>= 6'}
 
+  commander@6.2.1:
+    resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==}
+    engines: {node: '>= 6'}
+
   commander@7.2.0:
     resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==}
     engines: {node: '>= 10'}
@@ -3954,6 +5589,10 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
+  conf@10.2.0:
+    resolution: {integrity: sha512-8fLl9F04EJqjSqH+QjITQfJF8BrOVaYr1jewVgSRAEWePfxT0sku4w2hrGQ60BC/TNLGQ2pgxNlTbWQmMPFvXg==}
+    engines: {node: '>=12'}
+
   confbox@0.1.8:
     resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}
 
@@ -3974,6 +5613,9 @@ packages:
     resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
     engines: {node: '>= 0.6'}
 
+  convert-source-map@1.9.0:
+    resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==}
+
   convert-source-map@2.0.0:
     resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
 
@@ -3993,6 +5635,13 @@ packages:
     resolution: {integrity: sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==}
     engines: {node: '>=18'}
 
+  core-js-pure@3.49.0:
+    resolution: {integrity: sha512-XM4RFka59xATyJv/cS3O3Kml72hQXUeGRuuTmMYFxwzc9/7C8OYTaIR/Ji+Yt8DXzsFLNhat15cE/JP15HrCgw==}
+
+  core-js@3.18.3:
+    resolution: {integrity: sha512-tReEhtMReZaPFVw7dajMx0vlsz3oOb8ajgPoHVYGxr8ErnZ6PcYEvvmjGmXlfpnxpkYSdOQttjB+MvVbCGfvLw==}
+    deprecated: core-js@<3.23.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Some versions have web compatibility issues. Please, upgrade your dependencies to the actual version of core-js.
+
   core-util-is@1.0.2:
     resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==}
 
@@ -4009,6 +5658,19 @@ packages:
   cose-base@2.2.0:
     resolution: {integrity: sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g==}
 
+  cosmiconfig@7.1.0:
+    resolution: {integrity: sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==}
+    engines: {node: '>=10'}
+
+  cosmiconfig@9.0.2:
+    resolution: {integrity: sha512-gtTZxTDau1wL7Y7zifc2dd8jHSK/k6BTx/2Xp/BpdlAdnlYWFVt7qhJqgwi7637yRwRQ3qL4ZidbB4I8tA5VOg==}
+    engines: {node: '>=14'}
+    peerDependencies:
+      typescript: '>=4.9.5'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
   crc-32@1.2.2:
     resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==}
     engines: {node: '>=0.8'}
@@ -4032,6 +5694,11 @@ packages:
     resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==}
     engines: {node: '>= 6'}
 
+  cssesc@3.0.0:
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
   cssom@0.5.0:
     resolution: {integrity: sha512-iKuQcq+NdHqlAcwUY0o/HL69XQrUaQdMjmStJ8JFmUaiiQErlhrmuigkg/CU4E2J0IyUKUrMAgl36TvN67MqTw==}
 
@@ -4224,6 +5891,10 @@ packages:
   dayjs@1.11.21:
     resolution: {integrity: sha512-98IT+HOahAisibz/yjKbzuOBwYcjJ7BCLPzARyHiyEBmRz4fatF+KPJszEHXsGYjUG234aH/cOjW1wwTbKUZlA==}
 
+  debounce-fn@4.0.0:
+    resolution: {integrity: sha512-8pYCQiL9Xdcg0UPSD3d+0KMlOjp+KGU5EPwYddgzQ7DATsg4fuUDjQtsYLmWjnk2obnNHgV3vE2Y4jejSOJVBQ==}
+    engines: {node: '>=10'}
+
   debug@4.4.3:
     resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
     engines: {node: '>=6.0'}
@@ -4233,6 +5904,10 @@ packages:
       supports-color:
         optional: true
 
+  decamelize@4.0.0:
+    resolution: {integrity: sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==}
+    engines: {node: '>=10'}
+
   decimal.js@10.6.0:
     resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}
 
@@ -4243,6 +5918,22 @@ packages:
     resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
     engines: {node: '>=10'}
 
+  dedent@1.7.2:
+    resolution: {integrity: sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA==}
+    peerDependencies:
+      babel-plugin-macros: ^3.1.0
+    peerDependenciesMeta:
+      babel-plugin-macros:
+        optional: true
+
+  deep-extend@0.6.0:
+    resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
+    engines: {node: '>=4.0.0'}
+
+  deepmerge@4.3.1:
+    resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
+    engines: {node: '>=0.10.0'}
+
   default-browser-id@5.0.1:
     resolution: {integrity: sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==}
     engines: {node: '>=18'}
@@ -4262,6 +5953,10 @@ packages:
     resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
     engines: {node: '>= 0.4'}
 
+  define-lazy-prop@2.0.0:
+    resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
+    engines: {node: '>=8'}
+
   define-lazy-prop@3.0.0:
     resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==}
     engines: {node: '>=12'}
@@ -4299,12 +5994,19 @@ packages:
     resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
     engines: {node: '>=8'}
 
+  detect-node-es@1.1.0:
+    resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==}
+
   detect-node@2.1.0:
     resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==}
 
   devlop@1.1.0:
     resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
 
+  diff@7.0.0:
+    resolution: {integrity: sha512-PJWHUb1RFevKCwaFA9RlG5tCd+FO5iRh9A8HEtkmBH2Li03iJriB6m6JIN4rGz3K3JLawI7/veA1xzRKP6ISBw==}
+    engines: {node: '>=0.3.1'}
+
   diff@8.0.4:
     resolution: {integrity: sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==}
     engines: {node: '>=0.3.1'}
@@ -4345,6 +6047,10 @@ packages:
   domutils@3.2.2:
     resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==}
 
+  dot-prop@6.0.1:
+    resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==}
+    engines: {node: '>=10'}
+
   dotenv-expand@11.0.7:
     resolution: {integrity: sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==}
     engines: {node: '>=12'}
@@ -4353,6 +6059,10 @@ packages:
     resolution: {integrity: sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==}
     engines: {node: '>=12'}
 
+  dotenv@17.4.2:
+    resolution: {integrity: sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==}
+    engines: {node: '>=12'}
+
   dotenv@8.6.0:
     resolution: {integrity: sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==}
     engines: {node: '>=10'}
@@ -4376,6 +6086,10 @@ packages:
   ecdsa-sig-formatter@1.0.11:
     resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
 
+  editions@6.22.0:
+    resolution: {integrity: sha512-UgGlf8IW75je7HZjNDpJdCv4cGJWIi6yumFdZ0R7A8/CIhQiWUjyGLCxdHpd8bmyD1gnkfUNK0oeOXqUS2cpfQ==}
+    engines: {ecmascript: '>= es5', node: '>=4'}
+
   ee-first@1.1.1:
     resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
 
@@ -4426,6 +6140,9 @@ packages:
     resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
     engines: {node: '>= 0.8'}
 
+  encoding-sniffer@0.2.1:
+    resolution: {integrity: sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw==}
+
   encoding@0.1.13:
     resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==}
 
@@ -4463,6 +6180,9 @@ packages:
   err-code@2.0.3:
     resolution: {integrity: sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==}
 
+  error-ex@1.3.4:
+    resolution: {integrity: sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==}
+
   es-abstract@1.24.2:
     resolution: {integrity: sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==}
     engines: {node: '>= 0.4'}
@@ -4531,6 +6251,9 @@ packages:
     engines: {node: '>=4'}
     hasBin: true
 
+  estree-util-is-identifier-name@3.0.0:
+    resolution: {integrity: sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==}
+
   estree-walker@2.0.2:
     resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
 
@@ -4552,9 +6275,21 @@ packages:
     resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==}
     engines: {node: '>=18.0.0'}
 
+  execa@5.1.1:
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
+
+  execa@9.6.1:
+    resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==}
+    engines: {node: ^18.19.0 || >=20.5.0}
+
   exif-parser@0.1.12:
     resolution: {integrity: sha512-c2bQfLNbMzLPmzQuOr8fy0csy84WmwnER81W88DzTp9CYNPJ6yzOj2EZAh9pywYpqHnshVLHQJ8WzldAyfY+Iw==}
 
+  expand-template@2.0.3:
+    resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
+    engines: {node: '>=6'}
+
   expect-type@1.3.0:
     resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
     engines: {node: '>=12.0.0'}
@@ -4616,9 +6351,18 @@ packages:
   fast-sha256@1.3.0:
     resolution: {integrity: sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==}
 
+  fast-string-truncated-width@3.0.3:
+    resolution: {integrity: sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g==}
+
+  fast-string-width@3.0.2:
+    resolution: {integrity: sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==}
+
   fast-uri@3.1.0:
     resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==}
 
+  fast-wrap-ansi@0.2.2:
+    resolution: {integrity: sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q==}
+
   fastify-plugin@5.1.0:
     resolution: {integrity: sha512-FAIDA8eovSt5qcDgcBvDuX/v0Cjz0ohGhENZ/wpc3y+oZCY2afZ9Baqql3g/lC+OHRnciQol4ww7tuthOb9idw==}
 
@@ -4628,6 +6372,9 @@ packages:
   fastq@1.20.1:
     resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
 
+  fault@1.0.4:
+    resolution: {integrity: sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==}
+
   fault@2.0.1:
     resolution: {integrity: sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==}
 
@@ -4650,6 +6397,10 @@ packages:
   fflate@0.8.2:
     resolution: {integrity: sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==}
 
+  figures@6.1.0:
+    resolution: {integrity: sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==}
+    engines: {node: '>=18'}
+
   file-type@21.3.4:
     resolution: {integrity: sha512-Ievi/yy8DS3ygGvT47PjSfdFoX+2isQueoYP1cntFW1JLYAuS4GD7NUPGg4zv2iZfV52uDyk5w5Z0TdpRS6Q1g==}
     engines: {node: '>=20'}
@@ -4669,13 +6420,37 @@ packages:
     resolution: {integrity: sha512-Zf4Xve4RymLl7NgaavNebZ01joJ8MfVerOG43wy7SHLO+r+K0C6d/SE0BiR7AV5V1VOCFlOP7ecdo+I4qmiHrQ==}
     engines: {node: '>=20'}
 
+  find-root@1.1.0:
+    resolution: {integrity: sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==}
+
+  find-up@3.0.0:
+    resolution: {integrity: sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==}
+    engines: {node: '>=6'}
+
   find-up@4.1.0:
     resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
     engines: {node: '>=8'}
 
+  find-up@5.0.0:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+
+  flat@5.0.2:
+    resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==}
+    hasBin: true
+
   focus-trap@7.8.0:
     resolution: {integrity: sha512-/yNdlIkpWbM0ptxno3ONTuf+2g318kh2ez3KSeZN5dZ8YC6AAmgeWz+GasYYiBJPFaYcSAPeu4GfhUaChzIJXA==}
 
+  follow-redirects@1.16.0:
+    resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
   for-each@0.3.5:
     resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
     engines: {node: '>= 0.4'}
@@ -4749,6 +6524,16 @@ packages:
   functions-have-names@1.2.3:
     resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
 
+  fuse.js@7.5.0:
+    resolution: {integrity: sha512-sQtrEfA+ez/3G0cCZecF70oqpCRttCexYUG4mUrtWL49ULUzUyxokt5kyqwtKzj1270RaKih+hcP3qLcumccow==}
+    engines: {node: '>=10'}
+
+  fuzzysort@3.1.0:
+    resolution: {integrity: sha512-sR9BNCjBg6LNgwvxlBd0sBABvQitkLzoVY9MYYROQVX/FvfJ4Mai9LsGhDgd8qYdds0bY77VzYd5iuB+v5rwQQ==}
+
+  fzf@0.5.2:
+    resolution: {integrity: sha512-Tt4kuxLXFKHy8KT40zwsUPUkg1CrsgY25FxA2U/j/0WgEDCk3ddc/zLTCCcbSHX9FcKtLuVaDGtGE/STWC+j3Q==}
+
   gauge@4.0.4:
     resolution: {integrity: sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==}
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
@@ -4782,6 +6567,14 @@ packages:
     resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
     engines: {node: '>= 0.4'}
 
+  get-nonce@1.0.1:
+    resolution: {integrity: sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==}
+    engines: {node: '>=6'}
+
+  get-own-enumerable-keys@1.0.0:
+    resolution: {integrity: sha512-PKsK2FSrQCyxcGHsGrLDcK0lx+0Ke+6e8KFFozA9/fIQLhQzPaRvJFdcz7+Axg3jUH/Mq+NI4xa5u/UT2tQskA==}
+    engines: {node: '>=14.16'}
+
   get-proto@1.0.1:
     resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
     engines: {node: '>= 0.4'}
@@ -4790,6 +6583,14 @@ packages:
     resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==}
     engines: {node: '>=8'}
 
+  get-stream@6.0.1:
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
+
+  get-stream@9.0.1:
+    resolution: {integrity: sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==}
+    engines: {node: '>=18'}
+
   get-symbol-description@1.1.0:
     resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==}
     engines: {node: '>= 0.4'}
@@ -4804,6 +6605,9 @@ packages:
   gifwrap@0.10.1:
     resolution: {integrity: sha512-2760b1vpJHNmLzZ/ubTtNnEx5WApN/PYWJvXvgS+tL1egTTthayFYIQQNi136FLEDcN/IyEY2EcGpIITD6eYUw==}
 
+  github-from-package@0.0.0:
+    resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}
+
   glob-parent@5.1.2:
     resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
     engines: {node: '>= 6'}
@@ -4813,6 +6617,10 @@ packages:
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
+  glob@13.0.6:
+    resolution: {integrity: sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==}
+    engines: {node: 18 || 20 || >=22}
+
   glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
@@ -4834,6 +6642,10 @@ packages:
     resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
     engines: {node: '>=10'}
 
+  globby@14.1.0:
+    resolution: {integrity: sha512-0Ia46fDOaT7k4og1PDW4YbodWWr3scS2vAr2lTbsplOt2WkKp0vQbkI9wKis/T5LV/dqPjO3bpS/z6GTJB82LA==}
+    engines: {node: '>=18'}
+
   google-auth-library@10.6.2:
     resolution: {integrity: sha512-e27Z6EThmVNNvtYASwQxose/G57rkRuaRbQyxM2bvYLLX/GqWZ5chWq2EBoUchJbCc57eC9ArzO5wMsEmWftCw==}
     engines: {node: '>=18'}
@@ -4853,6 +6665,10 @@ packages:
   graceful-fs@4.2.11:
     resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
 
+  graphql@16.14.2:
+    resolution: {integrity: sha512-Chq1s4CY7jmh8gO2qvLIJyfCDIN+EHLFW/9iShnp1z8FjBQMoodWP1kDC36VAMXXIvAjj4ARa7ntfAV2BrjsbA==}
+    engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0}
+
   gray-matter@4.0.3:
     resolution: {integrity: sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==}
     engines: {node: '>=6.0'}
@@ -4894,15 +6710,55 @@ packages:
     resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
     engines: {node: '>= 0.4'}
 
+  hast-util-from-dom@5.0.1:
+    resolution: {integrity: sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==}
+
+  hast-util-from-html-isomorphic@2.0.0:
+    resolution: {integrity: sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==}
+
+  hast-util-from-html@2.0.3:
+    resolution: {integrity: sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==}
+
+  hast-util-from-parse5@8.0.3:
+    resolution: {integrity: sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==}
+
+  hast-util-is-element@3.0.0:
+    resolution: {integrity: sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==}
+
+  hast-util-parse-selector@4.0.0:
+    resolution: {integrity: sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==}
+
   hast-util-to-html@9.0.5:
     resolution: {integrity: sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==}
 
+  hast-util-to-jsx-runtime@2.3.6:
+    resolution: {integrity: sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==}
+
+  hast-util-to-text@4.0.2:
+    resolution: {integrity: sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==}
+
   hast-util-whitespace@3.0.0:
     resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==}
 
+  hastscript@9.0.1:
+    resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==}
+
+  he@1.2.0:
+    resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
+    hasBin: true
+
+  headers-polyfill@5.0.1:
+    resolution: {integrity: sha512-1TJ6Fih/b8h5TIcv+1+Hw0PDQWJTKDKzFZzcKOiW1wJza3XoAQlkCuXLbymPYB8+ZQyw8mHvdw560e8zVFIWyA==}
+
+  heic-to@1.5.2:
+    resolution: {integrity: sha512-8Fns+lZHAWmz5U5IUxDeXKwIf3foBoKNPLxxFY4B0MkLjNuomEIHCoDbDE+x/llFK3NCEO1cu4+n3iUKY+Svmw==}
+
   highlight.js@10.7.3:
     resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==}
 
+  highlightjs-vue@1.0.0:
+    resolution: {integrity: sha512-PDEfEF102G23vHmPhLyPboFCD+BkMGu+GuJe2d9/eH4FsCwvgBpnc9n0pGE+ffKdph38s6foEZiEjdgHdzp+IA==}
+
   hono@4.12.14:
     resolution: {integrity: sha512-am5zfg3yu6sqn5yjKBNqhnTX7Cv+m00ox+7jbaKkrLMRJ4rAdldd1xPd/JzbBWspqaQv6RSTrgFN95EsfhC+7w==}
     engines: {node: '>=16.9.0'}
@@ -4917,6 +6773,10 @@ packages:
     resolution: {integrity: sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==}
     engines: {node: '>=10'}
 
+  hosted-git-info@7.0.2:
+    resolution: {integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==}
+    engines: {node: ^16.14.0 || >=18.0.0}
+
   html-encoding-sniffer@4.0.0:
     resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
     engines: {node: '>=18'}
@@ -4927,6 +6787,9 @@ packages:
   html-escaper@3.0.3:
     resolution: {integrity: sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==}
 
+  html-url-attributes@3.0.1:
+    resolution: {integrity: sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==}
+
   html-void-elements@3.0.0:
     resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==}
 
@@ -4964,6 +6827,14 @@ packages:
     resolution: {integrity: sha512-tsYlhAYpjCKa//8rXZ9DqKEawhPoSytweBC2eNvcaDK+57RZLHGqNs3PZTQO6yekLFSuvA6AlnAfrw1uBvtb+Q==}
     hasBin: true
 
+  human-signals@2.1.0:
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
+
+  human-signals@8.0.1:
+    resolution: {integrity: sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==}
+    engines: {node: '>=18.18.0'}
+
   humanize-ms@1.2.1:
     resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==}
 
@@ -4987,9 +6858,23 @@ packages:
     resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
     engines: {node: '>= 4'}
 
+  ignore@7.0.6:
+    resolution: {integrity: sha512-BAg6QkE8W+TuQLrrw0Ugr7HegXduRuuj8/ti2kSOc+jz1dmx8/WNcjr6XGnq5YpDWxFwwaavqD0+jIUOKelTsw==}
+    engines: {node: '>= 4'}
+
   image-q@4.0.0:
     resolution: {integrity: sha512-PfJGVgIfKQJuq3s0tTDOKtztksibuUEbJQIYT3by6wctQo+Rdlh7ef4evJ5NCdxY4CfMbvFkocEwbl4BF8RlJw==}
 
+  immediate@3.0.6:
+    resolution: {integrity: sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==}
+
+  immer@11.1.11:
+    resolution: {integrity: sha512-qzXuyXAkPySAGYkfsAwodDPWT8Zm7/Uo5BNt4BjhMhG5WlWyZZ4wQqnWwdS8kjlQ1Cwu6gjw3A6+0gTQwlyYtw==}
+
+  import-fresh@3.3.1:
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
+
   import-lazy@4.0.0:
     resolution: {integrity: sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==}
     engines: {node: '>=8'}
@@ -5009,6 +6894,10 @@ packages:
     resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==}
     engines: {node: '>=8'}
 
+  index-to-position@1.2.0:
+    resolution: {integrity: sha512-Yg7+ztRkqslMAS2iFaU+Oa4KTSidr63OsFGlOrJoW981kIYO3CGCS3wA95P1mUi/IVSJkn0D479KTJpVpvFNuw==}
+    engines: {node: '>=18'}
+
   infer-owner@1.0.4:
     resolution: {integrity: sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==}
 
@@ -5019,6 +6908,12 @@ packages:
   inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
+  ini@1.3.8:
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
+
+  inline-style-parser@0.2.7:
+    resolution: {integrity: sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==}
+
   internal-slot@1.1.0:
     resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==}
     engines: {node: '>= 0.4'}
@@ -5030,6 +6925,10 @@ packages:
     resolution: {integrity: sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==}
     engines: {node: '>=12'}
 
+  intersection-observer@0.12.2:
+    resolution: {integrity: sha512-7m1vEcPCxXYI8HqnL8CKI6siDyD+eIWSwgB3DZA+ZTogxk9I4CDnj4wilt9x/+/QbHI4YG5YZNmC6458/e9Ktg==}
+    deprecated: The Intersection Observer polyfill is no longer needed and can safely be removed. Intersection Observer has been Baseline since 2019.
+
   ip-address@10.1.0:
     resolution: {integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==}
     engines: {node: '>= 12'}
@@ -5046,10 +6945,19 @@ packages:
     resolution: {integrity: sha512-9VGk3HGanVE6JoZXHiCpnGy5X0jYDnN4EA4lntFPj+1vIWlFhIylq2CrrCOJH9EAhc5CYhq18F2Av2tgoAPsYQ==}
     engines: {node: '>= 10'}
 
+  is-alphabetical@2.0.1:
+    resolution: {integrity: sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==}
+
+  is-alphanumerical@2.0.1:
+    resolution: {integrity: sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==}
+
   is-array-buffer@3.0.5:
     resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==}
     engines: {node: '>= 0.4'}
 
+  is-arrayish@0.2.1:
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+
   is-async-function@2.1.1:
     resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==}
     engines: {node: '>= 0.4'}
@@ -5058,6 +6966,10 @@ packages:
     resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==}
     engines: {node: '>= 0.4'}
 
+  is-binary-path@2.1.0:
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
+
   is-boolean-object@1.2.2:
     resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==}
     engines: {node: '>= 0.4'}
@@ -5066,6 +6978,10 @@ packages:
     resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
     engines: {node: '>= 0.4'}
 
+  is-ci@2.0.0:
+    resolution: {integrity: sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==}
+    hasBin: true
+
   is-ci@3.0.1:
     resolution: {integrity: sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==}
     hasBin: true
@@ -5082,6 +6998,14 @@ packages:
     resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==}
     engines: {node: '>= 0.4'}
 
+  is-decimal@2.0.1:
+    resolution: {integrity: sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==}
+
+  is-docker@2.2.1:
+    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
+    engines: {node: '>=8'}
+    hasBin: true
+
   is-docker@3.0.0:
     resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -5115,6 +7039,13 @@ packages:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
     engines: {node: '>=0.10.0'}
 
+  is-hexadecimal@2.0.1:
+    resolution: {integrity: sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==}
+
+  is-in-ssh@1.0.0:
+    resolution: {integrity: sha512-jYa6Q9rH90kR1vKB6NM7qqd1mge3Fx4Dhw5TVlK1MUBqhEOuCagrEHMevNuCcbECmXZ0ThXkRm+Ymr51HwEPAw==}
+    engines: {node: '>=20'}
+
   is-inside-container@1.0.0:
     resolution: {integrity: sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==}
     engines: {node: '>=14.16'}
@@ -5124,6 +7055,14 @@ packages:
     resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==}
     engines: {node: '>=8'}
 
+  is-interactive@2.0.0:
+    resolution: {integrity: sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==}
+    engines: {node: '>=12'}
+
+  is-it-type@5.1.3:
+    resolution: {integrity: sha512-AX2uU0HW+TxagTgQXOJY7+2fbFHemC7YFBwN1XqD8qQMKdtfbOC8OC3fUb4s5NU59a3662Dzwto8tWDdZYRXxg==}
+    engines: {node: '>=12'}
+
   is-lambda@1.0.1:
     resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==}
 
@@ -5135,6 +7074,9 @@ packages:
     resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==}
     engines: {node: '>= 0.4'}
 
+  is-node-process@1.2.0:
+    resolution: {integrity: sha512-Vg4o6/fqPxIjtxgUH5QLJhwZ7gW5diGCVlXpuUfELC62CuxM1iHcRe51f2W1FDy04Ai4KJkagKjx3XaqyfRKXw==}
+
   is-number-object@1.1.1:
     resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==}
     engines: {node: '>= 0.4'}
@@ -5143,6 +7085,22 @@ packages:
     resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
     engines: {node: '>=0.12.0'}
 
+  is-obj@2.0.0:
+    resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==}
+    engines: {node: '>=8'}
+
+  is-obj@3.0.0:
+    resolution: {integrity: sha512-IlsXEHOjtKhpN8r/tRFj2nDyTmHvcfNeu/nrRIcXE17ROeatXchkojffa1SpdqW4cr/Fj6QkEf/Gn4zf6KKvEQ==}
+    engines: {node: '>=12'}
+
+  is-path-inside@3.0.3:
+    resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==}
+    engines: {node: '>=8'}
+
+  is-plain-obj@2.1.0:
+    resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==}
+    engines: {node: '>=8'}
+
   is-plain-obj@4.1.0:
     resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
     engines: {node: '>=12'}
@@ -5157,6 +7115,10 @@ packages:
     resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==}
     engines: {node: '>= 0.4'}
 
+  is-regexp@3.1.0:
+    resolution: {integrity: sha512-rbku49cWloU5bSMI+zaRaXdQHXnthP6DZ/vLnfdSKyL4zUzuWnomtOEiZZOd+ioQ+avFo/qau3KPTc7Fjy1uPA==}
+    engines: {node: '>=12'}
+
   is-set@2.0.3:
     resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==}
     engines: {node: '>= 0.4'}
@@ -5165,6 +7127,14 @@ packages:
     resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==}
     engines: {node: '>= 0.4'}
 
+  is-stream@2.0.1:
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
+
+  is-stream@4.0.1:
+    resolution: {integrity: sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==}
+    engines: {node: '>=18'}
+
   is-string@1.1.1:
     resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==}
     engines: {node: '>= 0.4'}
@@ -5185,6 +7155,14 @@ packages:
     resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==}
     engines: {node: '>=10'}
 
+  is-unicode-supported@1.3.0:
+    resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==}
+    engines: {node: '>=12'}
+
+  is-unicode-supported@2.1.0:
+    resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==}
+    engines: {node: '>=18'}
+
   is-weakmap@2.0.2:
     resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==}
     engines: {node: '>= 0.4'}
@@ -5205,6 +7183,10 @@ packages:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
     engines: {node: '>=0.10.0'}
 
+  is-wsl@2.2.0:
+    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
+    engines: {node: '>=8'}
+
   is-wsl@3.1.1:
     resolution: {integrity: sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==}
     engines: {node: '>=16'}
@@ -5226,6 +7208,10 @@ packages:
   isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
+  isexe@3.1.5:
+    resolution: {integrity: sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==}
+    engines: {node: '>=18'}
+
   istanbul-lib-coverage@3.2.2:
     resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
     engines: {node: '>=8'}
@@ -5238,6 +7224,10 @@ packages:
     resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
     engines: {node: '>=8'}
 
+  istextorbinary@9.5.0:
+    resolution: {integrity: sha512-5mbUj3SiZXCuRf9fT3ibzbSSEWiy63gFfksmGfdOzujPjW3k+z8WvIBxcJHBoQNlaZaiyB25deviif2+osLmLw==}
+    engines: {node: '>=4'}
+
   jackspeak@3.4.3:
     resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
 
@@ -5263,6 +7253,9 @@ packages:
   jpeg-js@0.4.4:
     resolution: {integrity: sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg==}
 
+  js-cookie@3.0.8:
+    resolution: {integrity: sha512-yeJd4aNAdYZQjaon2bpD/Gb0B/omw7HQOsynXXcOiWVCacbBcPlgn8S/d1X6blFSaHao7ozqtW7NZW19xpCtIw==}
+
   js-tokens@10.0.0:
     resolution: {integrity: sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==}
 
@@ -5297,6 +7290,9 @@ packages:
   json-buffer@3.0.1:
     resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
 
+  json-parse-even-better-errors@2.3.1:
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+
   json-schema-ref-resolver@3.0.0:
     resolution: {integrity: sha512-hOrZIVL5jyYFjzk7+y7n5JDzGlU8rfWDuYyHwGa2WA8/pcmMHezp2xsVwxrebD/Q9t8Nc5DboieySDpCp4WG4A==}
 
@@ -5314,6 +7310,9 @@ packages:
   json-schema-traverse@1.0.0:
     resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
 
+  json-schema-typed@7.0.3:
+    resolution: {integrity: sha512-7DE8mpG+/fVw+dTpjbxnx47TaMnDfOI1jwft9g1VybltZCduyRQPJPvc+zzKY9WPHxhPWczyFuYa6I8Mw4iU5A==}
+
   json-schema-typed@8.0.2:
     resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
 
@@ -5325,12 +7324,22 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
+  jsonc-parser@3.3.1:
+    resolution: {integrity: sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==}
+
   jsonfile@4.0.0:
     resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
 
   jsonfile@6.2.1:
     resolution: {integrity: sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==}
 
+  jsonwebtoken@9.0.3:
+    resolution: {integrity: sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==}
+    engines: {node: '>=12', npm: '>=6'}
+
+  jszip@3.10.1:
+    resolution: {integrity: sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==}
+
   jwa@2.0.1:
     resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==}
 
@@ -5345,6 +7354,9 @@ packages:
     resolution: {integrity: sha512-Vdw0ATsQ9V+LuegM/BTwQqV/6cTl5lbGcIrU+BCgLxyf6bo38ybOr372tuSIxir3CN720flu1meYR6XzNMwQnw==}
     hasBin: true
 
+  keytar@7.9.0:
+    resolution: {integrity: sha512-VPD8mtVtm5JNtA2AErl6Chp06JBfy7diFQ7TQQhdpWOl6MrCRB+eRbvAZUsbGQS9kiMq0coJsy0W0vHpDCkWsQ==}
+
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
@@ -5355,6 +7367,14 @@ packages:
     resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
     engines: {node: '>=0.10.0'}
 
+  kleur@3.0.3:
+    resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==}
+    engines: {node: '>=6'}
+
+  kleur@4.1.5:
+    resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
+    engines: {node: '>=6'}
+
   layout-base@1.0.2:
     resolution: {integrity: sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg==}
 
@@ -5368,39 +7388,83 @@ packages:
     resolution: {integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==}
     engines: {node: '>= 0.6.3'}
 
+  leven@3.1.0:
+    resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==}
+    engines: {node: '>=6'}
+
+  lie@3.3.0:
+    resolution: {integrity: sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==}
+
   light-my-request@6.6.0:
     resolution: {integrity: sha512-CHYbu8RtboSIoVsHZ6Ye4cj4Aw/yg2oAFimlF7mNvfDV192LR7nDiKtSIfCuLT7KokPSTn/9kfVLm5OGN0A28A==}
 
+  lightningcss-android-arm64@1.30.2:
+    resolution: {integrity: sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [android]
+
   lightningcss-android-arm64@1.32.0:
     resolution: {integrity: sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [android]
 
+  lightningcss-darwin-arm64@1.30.2:
+    resolution: {integrity: sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
   lightningcss-darwin-arm64@1.32.0:
     resolution: {integrity: sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [darwin]
 
+  lightningcss-darwin-x64@1.30.2:
+    resolution: {integrity: sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
   lightningcss-darwin-x64@1.32.0:
     resolution: {integrity: sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [darwin]
 
+  lightningcss-freebsd-x64@1.30.2:
+    resolution: {integrity: sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
   lightningcss-freebsd-x64@1.32.0:
     resolution: {integrity: sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [freebsd]
 
+  lightningcss-linux-arm-gnueabihf@1.30.2:
+    resolution: {integrity: sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm]
+    os: [linux]
+
   lightningcss-linux-arm-gnueabihf@1.32.0:
     resolution: {integrity: sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm]
     os: [linux]
 
+  lightningcss-linux-arm64-gnu@1.30.2:
+    resolution: {integrity: sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
   lightningcss-linux-arm64-gnu@1.32.0:
     resolution: {integrity: sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==}
     engines: {node: '>= 12.0.0'}
@@ -5408,6 +7472,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  lightningcss-linux-arm64-musl@1.30.2:
+    resolution: {integrity: sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
   lightningcss-linux-arm64-musl@1.32.0:
     resolution: {integrity: sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==}
     engines: {node: '>= 12.0.0'}
@@ -5415,6 +7486,13 @@ packages:
     os: [linux]
     libc: [musl]
 
+  lightningcss-linux-x64-gnu@1.30.2:
+    resolution: {integrity: sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
   lightningcss-linux-x64-gnu@1.32.0:
     resolution: {integrity: sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==}
     engines: {node: '>= 12.0.0'}
@@ -5422,6 +7500,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  lightningcss-linux-x64-musl@1.30.2:
+    resolution: {integrity: sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
   lightningcss-linux-x64-musl@1.32.0:
     resolution: {integrity: sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==}
     engines: {node: '>= 12.0.0'}
@@ -5429,22 +7514,41 @@ packages:
     os: [linux]
     libc: [musl]
 
+  lightningcss-win32-arm64-msvc@1.30.2:
+    resolution: {integrity: sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
   lightningcss-win32-arm64-msvc@1.32.0:
     resolution: {integrity: sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [win32]
 
+  lightningcss-win32-x64-msvc@1.30.2:
+    resolution: {integrity: sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [win32]
+
   lightningcss-win32-x64-msvc@1.32.0:
     resolution: {integrity: sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [win32]
 
+  lightningcss@1.30.2:
+    resolution: {integrity: sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ==}
+    engines: {node: '>= 12.0.0'}
+
   lightningcss@1.32.0:
     resolution: {integrity: sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==}
     engines: {node: '>= 12.0.0'}
 
+  lines-and-columns@1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+
   linkedom@0.18.12:
     resolution: {integrity: sha512-jalJsOwIKuQJSeTvsgzPe9iJzyfVaEJiEXl+25EkKevsULHvMJzpNqwvj1jOESWdmgKDiXObyjOYwlUqG7wo1Q==}
     engines: {node: '>=16'}
@@ -5470,10 +7574,18 @@ packages:
     resolution: {integrity: sha512-++gUqRDEvcnN6Zhqrr+y/CkVEHhlrR96vZn3nZZPYzMcBUyBtTKzB9NadClFIsIVSsu+3i9tfk/erqy9kAmt7Q==}
     engines: {node: '>=14'}
 
+  locate-path@3.0.0:
+    resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==}
+    engines: {node: '>=6'}
+
   locate-path@5.0.0:
     resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
     engines: {node: '>=8'}
 
+  locate-path@6.0.0:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+
   lodash-es@4.18.1:
     resolution: {integrity: sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==}
 
@@ -5486,12 +7598,33 @@ packages:
   lodash.flatten@4.4.0:
     resolution: {integrity: sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==}
 
+  lodash.includes@4.3.0:
+    resolution: {integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==}
+
+  lodash.isboolean@3.0.3:
+    resolution: {integrity: sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==}
+
+  lodash.isinteger@4.0.4:
+    resolution: {integrity: sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==}
+
+  lodash.isnumber@3.0.3:
+    resolution: {integrity: sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==}
+
   lodash.isplainobject@4.0.6:
     resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}
 
+  lodash.isstring@4.0.1:
+    resolution: {integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==}
+
+  lodash.once@4.1.1:
+    resolution: {integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==}
+
   lodash.startcase@4.4.0:
     resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==}
 
+  lodash.truncate@4.4.2:
+    resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==}
+
   lodash.union@4.6.0:
     resolution: {integrity: sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==}
 
@@ -5502,6 +7635,10 @@ packages:
     resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==}
     engines: {node: '>=10'}
 
+  log-symbols@6.0.0:
+    resolution: {integrity: sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==}
+    engines: {node: '>=18'}
+
   log-update@6.1.0:
     resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==}
     engines: {node: '>=18'}
@@ -5512,10 +7649,17 @@ packages:
   longest-streak@3.1.0:
     resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==}
 
+  loose-envify@1.4.0:
+    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
+    hasBin: true
+
   lowercase-keys@2.0.0:
     resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==}
     engines: {node: '>=8'}
 
+  lowlight@1.20.0:
+    resolution: {integrity: sha512-8Ktj+prEb1RoCPkEOrPMYUN/nCggB7qAWe3a7OpMjWQkh3l2RD5wKRQ+o8Q8YuI9RG/xs95waaI/E6ym/7NsTw==}
+
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
@@ -5580,6 +7724,9 @@ packages:
     resolution: {integrity: sha512-1TGiQiJVRQ3NPmZH6sx5Cfnmg6GQm9jvC1ch4TK511NjSJvjzKLzn5pPfZRNZkRPZP0HqCioSndqH8v2nRaWVQ==}
     hasBin: true
 
+  markdown-table@3.0.4:
+    resolution: {integrity: sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==}
+
   markdown-title@1.0.2:
     resolution: {integrity: sha512-MqIQVVkz+uGEHi3TsHx/czcxxCbRIL7sv5K5DnYw/tI+apY54IbPefV/cmgxp6LoJSEx/TqcHdLs/298afG5QQ==}
     engines: {node: '>=6'}
@@ -5643,12 +7790,48 @@ packages:
     resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
     engines: {node: '>= 0.4'}
 
+  math-random@2.0.1:
+    resolution: {integrity: sha512-oIEbWiVDxDpl5tIF4S6zYS9JExhh3bun3uLb3YAinHPTlRtW4g1S66LtJrJ4Npq8dgIa8CLK5iPVah5n4n0s2w==}
+
+  mdast-util-find-and-replace@3.0.2:
+    resolution: {integrity: sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==}
+
   mdast-util-from-markdown@2.0.3:
     resolution: {integrity: sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==}
 
   mdast-util-frontmatter@2.0.1:
     resolution: {integrity: sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==}
 
+  mdast-util-gfm-autolink-literal@2.0.1:
+    resolution: {integrity: sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==}
+
+  mdast-util-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==}
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    resolution: {integrity: sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==}
+
+  mdast-util-gfm-table@2.0.0:
+    resolution: {integrity: sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==}
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    resolution: {integrity: sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==}
+
+  mdast-util-gfm@3.1.0:
+    resolution: {integrity: sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==}
+
+  mdast-util-math@3.0.0:
+    resolution: {integrity: sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==}
+
+  mdast-util-mdx-expression@2.0.1:
+    resolution: {integrity: sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==}
+
+  mdast-util-mdx-jsx@3.2.0:
+    resolution: {integrity: sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==}
+
+  mdast-util-mdxjs-esm@2.0.1:
+    resolution: {integrity: sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==}
+
   mdast-util-phrasing@4.1.0:
     resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==}
 
@@ -5672,6 +7855,9 @@ packages:
     resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
     engines: {node: '>=18'}
 
+  merge-stream@2.0.0:
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
+
   merge2@1.4.1:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
@@ -5685,6 +7871,30 @@ packages:
   micromark-extension-frontmatter@2.0.0:
     resolution: {integrity: sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==}
 
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    resolution: {integrity: sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==}
+
+  micromark-extension-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==}
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    resolution: {integrity: sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==}
+
+  micromark-extension-gfm-table@2.1.1:
+    resolution: {integrity: sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==}
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    resolution: {integrity: sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==}
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    resolution: {integrity: sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==}
+
+  micromark-extension-gfm@3.0.0:
+    resolution: {integrity: sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==}
+
+  micromark-extension-math@3.1.0:
+    resolution: {integrity: sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==}
+
   micromark-factory-destination@2.0.1:
     resolution: {integrity: sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==}
 
@@ -5769,6 +7979,11 @@ packages:
     resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==}
     engines: {node: '>=18'}
 
+  mime@1.6.0:
+    resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
   mime@2.6.0:
     resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==}
     engines: {node: '>=4.0.0'}
@@ -5783,6 +7998,10 @@ packages:
     resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
     engines: {node: '>=6'}
 
+  mimic-fn@3.1.0:
+    resolution: {integrity: sha512-Ysbi9uYW9hFyfrThdDEQuykN4Ey6BuwPD2kpI5ES/nFTDn/98yxYNLZJcgUAKPT/mcrLLKaGzJR9YVxJrIdASQ==}
+    engines: {node: '>=8'}
+
   mimic-function@5.0.1:
     resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==}
     engines: {node: '>=18'}
@@ -5863,6 +8082,9 @@ packages:
   mitt@3.0.1:
     resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
 
+  mkdirp-classic@0.5.3:
+    resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
+
   mkdirp@1.0.4:
     resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
     engines: {node: '>=10'}
@@ -5871,6 +8093,11 @@ packages:
   mlly@1.8.2:
     resolution: {integrity: sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA==}
 
+  mocha@11.7.6:
+    resolution: {integrity: sha512-nS9xOGbw2I3cjCpxwZAEJ9xK9lmJ08vEkQvLtz4du9ZrF9UrjRpeJGiIgl2Z+Qs++pmB4ecDe48Fwsh+j+j7xA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    hasBin: true
+
   mri@1.2.0:
     resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
     engines: {node: '>=4'}
@@ -5878,9 +8105,26 @@ packages:
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
+  msw@2.15.0:
+    resolution: {integrity: sha512-2wQAmKkQKxRuXvYJxVhPGG0wZNBQyD06oJvxqw90XqLvptdqxdlHrFUfEteKkpaNORX3Xzc+HtEl/q0nfmN2wQ==}
+    engines: {node: '>=18'}
+    hasBin: true
+    peerDependencies:
+      typescript: '>= 4.8.x'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
   muggle-string@0.4.1:
     resolution: {integrity: sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==}
 
+  mute-stream@0.0.8:
+    resolution: {integrity: sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==}
+
+  mute-stream@3.0.0:
+    resolution: {integrity: sha512-dkEJPVvun4FryqBmZ5KhDo0K9iDXAwn08tMLDinNdRBNPcYEDiWYysLcc6k3mjTMlbP9KyylvRpd4wFtwrT9rw==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
   mz@2.7.0:
     resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
 
@@ -5894,6 +8138,9 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
+  napi-build-utils@2.0.0:
+    resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
+
   negotiator@0.6.4:
     resolution: {integrity: sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==}
     engines: {node: '>= 0.6'}
@@ -5902,6 +8149,12 @@ packages:
     resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
     engines: {node: '>= 0.6'}
 
+  next-themes@0.4.6:
+    resolution: {integrity: sha512-pZvgD5L0IEvX5/9GWyHMf3m8BKiVQwsCMHfoFosXtXBMnaS0ZnIJ9ST4b4NqLVKDEm8QBxoNNGNaBv2JNF6XNA==}
+    peerDependencies:
+      react: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
+
   node-abi@3.92.0:
     resolution: {integrity: sha512-KdHvFWZjEKDf0cakgFjebl371GPsISX2oZHcuyKqM7DtogIsHrqKeLTo8wBHxaXRAQlY2PsPlZmfo+9ZCxEREQ==}
     engines: {node: '>=10'}
@@ -5909,6 +8162,9 @@ packages:
   node-addon-api@1.7.2:
     resolution: {integrity: sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==}
 
+  node-addon-api@4.3.0:
+    resolution: {integrity: sha512-73sE9+3UaLYYFmDsFZnqCInzPyh3MqIwZO9cw58yIqAZhONrrabrYyYe3TuIqtIiOuTXVhsGau8hcrhhwSsDIQ==}
+
   node-addon-api@7.1.1:
     resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
 
@@ -5948,6 +8204,10 @@ packages:
   node-releases@2.0.37:
     resolution: {integrity: sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==}
 
+  node-sarif-builder@3.4.0:
+    resolution: {integrity: sha512-tGnJW6OKRii9u/b2WiUViTJS+h7Apxx17qsMUjsUeNDiMMX5ZFf8F8Fcz7PAQ6omvOxHZtvDTmOYKJQwmfpjeg==}
+    engines: {node: '>=20'}
+
   non-layered-tidy-tree-layout@2.0.2:
     resolution: {integrity: sha512-gkXMxRzUH+PB0ax9dUN0yYF0S25BqeAYqhgMaLUFmpXLEk7Fcu8f4emJuOAY0V8kjDICxROIKsTAKsV/v355xw==}
 
@@ -5956,6 +8216,10 @@ packages:
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
     hasBin: true
 
+  normalize-package-data@6.0.2:
+    resolution: {integrity: sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==}
+    engines: {node: ^16.14.0 || >=18.0.0}
+
   normalize-path@3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
@@ -5964,6 +8228,14 @@ packages:
     resolution: {integrity: sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==}
     engines: {node: '>=10'}
 
+  npm-run-path@4.0.1:
+    resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==}
+    engines: {node: '>=8'}
+
+  npm-run-path@6.0.0:
+    resolution: {integrity: sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==}
+    engines: {node: '>=18'}
+
   npmlog@6.0.2:
     resolution: {integrity: sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==}
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
@@ -5997,6 +8269,10 @@ packages:
     resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
     engines: {node: '>= 0.4'}
 
+  object-treeify@1.1.33:
+    resolution: {integrity: sha512-EFVjAYfzWqWsBMRHPMAXLCDIJnpMhdWAqR7xG6M6a2cs6PMFpl/+Z20w9zDW4vkxOFfddegBKq9Rehd0bxWE7A==}
+    engines: {node: '>= 10'}
+
   object.assign@4.1.7:
     resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==}
     engines: {node: '>= 0.4'}
@@ -6039,6 +8315,14 @@ packages:
     resolution: {integrity: sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==}
     engines: {node: '>=18'}
 
+  open@11.0.0:
+    resolution: {integrity: sha512-smsWv2LzFjP03xmvFoJ331ss6h+jixfA4UUV/Bsiyuu4YJPfN+FIQGOIiv4w9/+MoHkfkJ22UIaQWRVFRfH6Vw==}
+    engines: {node: '>=20'}
+
+  open@8.4.2:
+    resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
+    engines: {node: '>=12'}
+
   openai@6.34.0:
     resolution: {integrity: sha512-yEr2jdGf4tVFYG6ohmr3pF6VJuveP0EA/sS8TBx+4Eq5NT10alu5zg2dmxMXMgqpihRDQlFGpRt2XwsGj+Fyxw==}
     hasBin: true
@@ -6058,9 +8342,21 @@ packages:
     resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==}
     engines: {node: '>=10'}
 
+  ora@8.2.0:
+    resolution: {integrity: sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==}
+    engines: {node: '>=18'}
+
   outdent@0.5.0:
     resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==}
 
+  outvariant@1.4.3:
+    resolution: {integrity: sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA==}
+
+  ovsx@1.0.2:
+    resolution: {integrity: sha512-N0gWlINGgoOA2Sn0AhrF9L3ap40a/QbsFUpMDKR+CKYyZGJeTFEoNGngplLHjAYtcjrrZv2jX2K7ktPzxWjPNg==}
+    engines: {node: '>= 20'}
+    hasBin: true
+
   own-keys@1.0.1:
     resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
     engines: {node: '>= 0.4'}
@@ -6095,10 +8391,18 @@ packages:
     resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
     engines: {node: '>=10'}
 
+  p-locate@3.0.0:
+    resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==}
+    engines: {node: '>=6'}
+
   p-locate@4.1.0:
     resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
     engines: {node: '>=8'}
 
+  p-locate@5.0.0:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+
   p-map@2.1.0:
     resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==}
     engines: {node: '>=6'}
@@ -6107,6 +8411,10 @@ packages:
     resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==}
     engines: {node: '>=10'}
 
+  p-map@7.0.5:
+    resolution: {integrity: sha512-e8vJF4XdVkzqqSHguEMz41mQO1wKwxKm5ENrUJQUu9kLDCtn83cxbyHZcszr4QC5zEA7WffRRC4gsTecC7J9oA==}
+    engines: {node: '>=18'}
+
   p-retry@4.6.2:
     resolution: {integrity: sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==}
     engines: {node: '>=8'}
@@ -6127,6 +8435,10 @@ packages:
   pako@1.0.11:
     resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==}
 
+  parent-module@1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+
   parse-bmfont-ascii@1.0.6:
     resolution: {integrity: sha512-U4RrVsUFCleIOBsIGYOMKjn9PavsGOXxbvYGtMOEfnId0SVNsgehXh1DxUdVPLoxd5mvcEtvmKs2Mmf0Mpa1ZA==}
 
@@ -6136,9 +8448,33 @@ packages:
   parse-bmfont-xml@1.1.6:
     resolution: {integrity: sha512-0cEliVMZEhrFDwMh4SxIyVJpqYoOWDJ9P895tFuS+XuNzI5UBmBk5U5O4KuJdTnZpSBI4LFA2+ZiJaiwfSwlMA==}
 
+  parse-entities@4.0.2:
+    resolution: {integrity: sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==}
+
+  parse-json@5.2.0:
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
+
+  parse-json@8.3.0:
+    resolution: {integrity: sha512-ybiGyvspI+fAoRQbIPRddCcSTV9/LsJbf0e/S85VLowVGzRmokfneg2kwVW/KU5rOXrPSbF1qAKPMgNTqqROQQ==}
+    engines: {node: '>=18'}
+
+  parse-ms@4.0.0:
+    resolution: {integrity: sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==}
+    engines: {node: '>=18'}
+
+  parse-semver@1.1.1:
+    resolution: {integrity: sha512-Eg1OuNntBMH0ojvEKSrvDSnwLmvVuUOSdylH/pSCPNMIspLlweJyIWXCE+k/5hm3cj/EBUYwmWkjhBALNP4LXQ==}
+
   parse5-htmlparser2-tree-adapter@6.0.1:
     resolution: {integrity: sha512-qPuWvbLgvDGilKc5BoicRovlT4MtYT6JfJyBOMDsKoiT+GiuP5qyrPCnR9HcPECIJJmZh5jRndyNThnhhb/vlA==}
 
+  parse5-htmlparser2-tree-adapter@7.1.0:
+    resolution: {integrity: sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==}
+
+  parse5-parser-stream@7.1.2:
+    resolution: {integrity: sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==}
+
   parse5@5.1.1:
     resolution: {integrity: sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug==}
 
@@ -6158,6 +8494,10 @@ packages:
   path-data-parser@0.1.0:
     resolution: {integrity: sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==}
 
+  path-exists@3.0.0:
+    resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==}
+    engines: {node: '>=4'}
+
   path-exists@4.0.0:
     resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
     engines: {node: '>=8'}
@@ -6170,6 +8510,10 @@ packages:
     resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
     engines: {node: '>=8'}
 
+  path-key@4.0.0:
+    resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==}
+    engines: {node: '>=12'}
+
   path-parse@1.0.7:
     resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
 
@@ -6177,6 +8521,10 @@ packages:
     resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
     engines: {node: '>=16 || 14 >=14.18'}
 
+  path-scurry@2.0.2:
+    resolution: {integrity: sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==}
+    engines: {node: 18 || 20 || >=22}
+
   path-to-regexp@6.3.0:
     resolution: {integrity: sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==}
 
@@ -6187,6 +8535,10 @@ packages:
     resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
     engines: {node: '>=8'}
 
+  path-type@6.0.0:
+    resolution: {integrity: sha512-Vj7sf++t5pBD637NSfkxpHSMfWaeig5+DKWLhcqIYx6mWQz5hdJTGDVMQiJcw1ZYkhs7AazKDGpRVji1LJCZUQ==}
+    engines: {node: '>=18'}
+
   pathe@2.0.3:
     resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
 
@@ -6243,10 +8595,21 @@ packages:
   pkg-types@2.3.1:
     resolution: {integrity: sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==}
 
+  pkg-up@3.1.0:
+    resolution: {integrity: sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==}
+    engines: {node: '>=8'}
+
   plist@3.1.1:
     resolution: {integrity: sha512-ZIfcLJC+7E7FBFnDxm9MPmt7D+DidyQ26lewieO75AdhA2ayMtsJSES0iWzqJQbcVRSrTufQoy0DR94xHue0oA==}
     engines: {node: '>=10.4.0'}
 
+  pluralize@2.0.0:
+    resolution: {integrity: sha512-TqNZzQCD4S42De9IfnnBvILN7HAW7riLqsCyp8lgjXeysyPlX5HhqKAcJHHHb9XskE4/a+7VGC9zzx8Ls0jOAw==}
+
+  pluralize@8.0.0:
+    resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
+    engines: {node: '>=4'}
+
   pngjs@6.0.0:
     resolution: {integrity: sha512-TRzzuFRRmEoSW/p1KVAmiOgPco2Irlah+bGFCeNfJXxxYGwSw7YwAOAcd7X28K/m5bjBWKsC29KyoMfHbypayg==}
     engines: {node: '>=12.13.0'}
@@ -6265,6 +8628,10 @@ packages:
     resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
     engines: {node: '>= 0.4'}
 
+  postcss-selector-parser@7.1.4:
+    resolution: {integrity: sha512-HeP7D2wyhkR+XaK6v4W8oRF62Dsz4flyuczALJp61GckGm42u1saSSJ/0auvcBqxs3jMRFEcPK34At/0JBKdOg==}
+    engines: {node: '>=4'}
+
   postcss@8.5.15:
     resolution: {integrity: sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==}
     engines: {node: ^10 || ^12 || >=14}
@@ -6278,9 +8645,19 @@ packages:
     engines: {node: '>=14.0.0'}
     hasBin: true
 
+  powershell-utils@0.1.0:
+    resolution: {integrity: sha512-dM0jVuXJPsDN6DvRpea484tCUaMiXWjuCn++HGTqUWzGDjv5tZkEZldAJ/UMlqRYGFrD/etByo4/xOuC/snX2A==}
+    engines: {node: '>=20'}
+
   preact@10.29.2:
     resolution: {integrity: sha512-7tNmwg/7mzzAoB/8kSg6Hl37JraAZw3Z3A0JSY7VXlZwo82Xn0G7wKbNNs2qoF4ZEEsQGTwDAroNdqKs1ofJxQ==}
 
+  prebuild-install@7.1.3:
+    resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}
+    engines: {node: '>=10'}
+    deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
+    hasBin: true
+
   prettier@2.8.8:
     resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
     engines: {node: '>=10.13.0'}
@@ -6290,6 +8667,14 @@ packages:
     resolution: {integrity: sha512-nODzvTiYVRGRqAOvE84Vk5JDPyyxsVk0/fbA/bq7RqlnhksGpset09XTxbpvLTIjoaF7K8Z8DG8yHtKGTPSYRw==}
     engines: {node: '>=20'}
 
+  pretty-ms@9.3.0:
+    resolution: {integrity: sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==}
+    engines: {node: '>=18'}
+
+  prismjs@1.30.0:
+    resolution: {integrity: sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==}
+    engines: {node: '>=6'}
+
   process-nextick-args@2.0.1:
     resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
 
@@ -6315,6 +8700,13 @@ packages:
     resolution: {integrity: sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==}
     engines: {node: '>=10'}
 
+  prompts@2.4.2:
+    resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
+    engines: {node: '>= 6'}
+
+  prop-types@15.7.2:
+    resolution: {integrity: sha512-8QQikdH7//R2vurIJSutZ1smHYTcLpRWEOlHnzcWHmBYrOGUysKwSsrC89BCiFj3CbrfJ/nXFdJepOVrY1GCHQ==}
+
   proper-lockfile@4.1.2:
     resolution: {integrity: sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==}
 
@@ -6365,6 +8757,22 @@ packages:
     resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==}
     engines: {node: '>=10'}
 
+  radix-ui@1.6.2:
+    resolution: {integrity: sha512-OwYUjzMwiInCUxgAWpPsavXC3Kh4iyi/49uU1/qZTG3RQDlvegyk1GOMiGvSkjua1RDb3JD3fo3eroL9FV4GQw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  randombytes@2.1.0:
+    resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
+
   range-parser@1.2.1:
     resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
     engines: {node: '>= 0.6'}
@@ -6373,15 +8781,54 @@ packages:
     resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}
     engines: {node: '>= 0.10'}
 
+  rc-config-loader@4.1.4:
+    resolution: {integrity: sha512-3GiwEzklkbXTDp52UR5nT8iXgYAx1V9ZG/kDZT7p60u2GCv2XTwQq4NzinMoMpNtXhmt3WkhYXcj6HH8HdwCEQ==}
+
+  rc@1.2.8:
+    resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
+    hasBin: true
+
   react-dom@19.2.5:
     resolution: {integrity: sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag==}
     peerDependencies:
       react: ^19.2.5
 
+  react-fast-compare@3.2.2:
+    resolution: {integrity: sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==}
+
+  react-is@16.13.1:
+    resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
+
+  react-markdown@10.1.0:
+    resolution: {integrity: sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==}
+    peerDependencies:
+      '@types/react': '>=18'
+      react: '>=18'
+
   react-refresh@0.17.0:
     resolution: {integrity: sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==}
     engines: {node: '>=0.10.0'}
 
+  react-remove-scroll-bar@2.3.8:
+    resolution: {integrity: sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-remove-scroll@2.7.2:
+    resolution: {integrity: sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   react-router-dom@7.14.1:
     resolution: {integrity: sha512-ZkrQuwwhGibjQLqH1eCdyiZyLWglPxzxdl5tgwgKEyCSGC76vmAjleGocRe3J/MLfzMUIKwaFJWpFVJhK3d2xA==}
     engines: {node: '>=20.0.0'}
@@ -6399,6 +8846,27 @@ packages:
       react-dom:
         optional: true
 
+  react-scroll-to-bottom@4.2.0:
+    resolution: {integrity: sha512-1WweuumQc5JLzeAR81ykRdK/cEv9NlCPEm4vSwOGN1qS2qlpGVTyMgdI8Y7ZmaqRmzYBGV5/xPuJQtekYzQFGg==}
+    peerDependencies:
+      react: '>= 16.8.6'
+
+  react-style-singleton@2.2.3:
+    resolution: {integrity: sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-syntax-highlighter@16.1.1:
+    resolution: {integrity: sha512-PjVawBGy80C6YbC5DDZJeUjBmC7skaoEUdvfFQediQHgCL7aKyVHe57SaJGfQsloGDac+gCpTfRdtxzWWKmCXA==}
+    engines: {node: '>= 16.20.2'}
+    peerDependencies:
+      react: '>= 0.14.0'
+
   react@19.2.5:
     resolution: {integrity: sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA==}
     engines: {node: '>=0.10.0'}
@@ -6407,10 +8875,18 @@ packages:
     resolution: {integrity: sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg==}
     hasBin: true
 
+  read-pkg@9.0.1:
+    resolution: {integrity: sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==}
+    engines: {node: '>=18'}
+
   read-yaml-file@1.1.0:
     resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==}
     engines: {node: '>=6'}
 
+  read@1.0.7:
+    resolution: {integrity: sha512-rSOKNYUmaxy0om1BNjMN4ezNT6VKK+2xF4GBhc81mkH7L60i6dp8qPYrkndNLT3QPphoII3maL9PVC9XmhHwVQ==}
+    engines: {node: '>=0.8'}
+
   readable-stream@2.3.8:
     resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
 
@@ -6421,6 +8897,10 @@ packages:
   readdir-glob@1.1.3:
     resolution: {integrity: sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==}
 
+  readdirp@3.6.0:
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
+
   readdirp@4.1.2:
     resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
     engines: {node: '>= 14.18.0'}
@@ -6429,10 +8909,17 @@ packages:
     resolution: {integrity: sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==}
     engines: {node: '>= 12.13.0'}
 
+  recast@0.23.12:
+    resolution: {integrity: sha512-dEWRjcINDu/F4l2dYx57ugBtD7HV9KXESyxhzw/MqWLeglJrsjJKqACPyUPg+6AF8mIgm+Zi0dZ3ACoIg+QtpA==}
+    engines: {node: '>= 4'}
+
   reflect.getprototypeof@1.0.10:
     resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==}
     engines: {node: '>= 0.4'}
 
+  refractor@5.0.0:
+    resolution: {integrity: sha512-QXOrHQF5jOpjjLfiNk5GFnWhRXvxjUVnlFxkeDmewR5sXkr3iM46Zo+CnRR8B+MDVqkULW4EcLVcRBNOPXHosw==}
+
   regex-recursion@6.0.2:
     resolution: {integrity: sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==}
 
@@ -6450,12 +8937,24 @@ packages:
     resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==}
     engines: {node: '>= 0.4'}
 
+  rehype-katex@7.0.1:
+    resolution: {integrity: sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA==}
+
   remark-frontmatter@5.0.0:
     resolution: {integrity: sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==}
 
+  remark-gfm@4.0.1:
+    resolution: {integrity: sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==}
+
+  remark-math@6.0.0:
+    resolution: {integrity: sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==}
+
   remark-parse@11.0.0:
     resolution: {integrity: sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==}
 
+  remark-rehype@11.1.2:
+    resolution: {integrity: sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==}
+
   remark-stringify@11.0.0:
     resolution: {integrity: sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==}
 
@@ -6474,9 +8973,19 @@ packages:
     resolution: {integrity: sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA==}
     engines: {node: '>=12', npm: '>=6'}
 
+  reselect@5.2.0:
+    resolution: {integrity: sha512-AgZ3UOZm3YndfrJ4OYjgrT7bmCm/1iqkjvEfH/oYjzh6PD2qw4QuT3jjnXIrpdt4MTpMXclMT3lXbmRY+XRakw==}
+
+  resize-observer-polyfill@1.5.1:
+    resolution: {integrity: sha512-LwZrotdHOo12nQuZlHEmtuXdqGoOD0OhaxopaNFxWzInpEgaLWoVuAMbTzixuosCx2nEG58ngzW3vxdWoxIgdg==}
+
   resolve-alpn@1.2.1:
     resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==}
 
+  resolve-from@4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+
   resolve-from@5.0.0:
     resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
     engines: {node: '>=8'}
@@ -6512,6 +9021,9 @@ packages:
     resolution: {integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==}
     engines: {node: '>= 4'}
 
+  rettime@0.11.11:
+    resolution: {integrity: sha512-ILJRqVWBCTlg9r42fFgwVZx1gnFAcQF8mRoMkbgQfIrjEDf9nbBFDFx00oloOa+Q869FUtaYDXZvEfnecQSCoQ==}
+
   reusify@1.1.0:
     resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
@@ -6643,9 +9155,18 @@ packages:
   scheduler@0.27.0:
     resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
 
+  screenfull@5.2.0:
+    resolution: {integrity: sha512-9BakfsO2aUQN2K9Fdbj87RJIEZ82Q9IGim7FqM5OsebfoFC6ZHXgDq/KvniuLTPdeM8wY2o6Dj3WQ7KeQCj3cA==}
+    engines: {node: '>=0.10.0'}
+
   search-insights@2.17.3:
     resolution: {integrity: sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==}
 
+  secretlint@10.2.2:
+    resolution: {integrity: sha512-xVpkeHV/aoWe4vP4TansF622nBEImzCY73y/0042DuJ29iKIaqgoJ8fGxre3rVSHHbxar4FdJobmTnLp9AU0eg==}
+    engines: {node: '>=20.0.0'}
+    hasBin: true
+
   section-matter@1.0.0:
     resolution: {integrity: sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==}
     engines: {node: '>=4'}
@@ -6656,6 +9177,10 @@ packages:
   semver-compare@1.0.0:
     resolution: {integrity: sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==}
 
+  semver@5.7.2:
+    resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
+    hasBin: true
+
   semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
@@ -6673,6 +9198,9 @@ packages:
     resolution: {integrity: sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==}
     engines: {node: '>=10'}
 
+  serialize-javascript@6.0.2:
+    resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==}
+
   serve-static@2.2.1:
     resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==}
     engines: {node: '>= 18'}
@@ -6683,6 +9211,9 @@ packages:
   set-cookie-parser@2.7.2:
     resolution: {integrity: sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==}
 
+  set-cookie-parser@3.1.2:
+    resolution: {integrity: sha512-5/r/lTwbJ3zQ+qwdUFZYeRNqda7P5HD8zQKqlSjdGt1/S0cjLAphHusj4Y58ahDtWn/g32xrIS58/ikOvwl0Lw==}
+
   set-function-length@1.2.2:
     resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
     engines: {node: '>= 0.4'}
@@ -6695,9 +9226,16 @@ packages:
     resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==}
     engines: {node: '>= 0.4'}
 
+  setimmediate@1.0.5:
+    resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==}
+
   setprototypeof@1.2.0:
     resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
 
+  shadcn@3.8.5:
+    resolution: {integrity: sha512-jPRx44e+eyeV7xwY3BLJXcfrks00+M0h5BGB9l6DdcBW4BpAj4x3lVmVy0TXPEs2iHEisxejr62sZAAw6B1EVA==}
+    hasBin: true
+
   shebang-command@2.0.0:
     resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
     engines: {node: '>=8'}
@@ -6801,10 +9339,23 @@ packages:
     resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
     engines: {node: '>=14'}
 
+  simple-concat@1.0.1:
+    resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==}
+
+  simple-get@4.0.1:
+    resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==}
+
   simple-git-hooks@2.13.1:
     resolution: {integrity: sha512-WszCLXwT4h2k1ufIXAgsbiTOazqqevFCIncOuUBZJ91DdvWcC5+OFkluWRQPrcuSYd8fjq+o2y1QfWqYMoAToQ==}
     hasBin: true
 
+  simple-invariant@2.0.1:
+    resolution: {integrity: sha512-1sbhsxqI+I2tqlmjbz99GXNmZtr6tKIyEgGGnJw/MKGblalqk/XoOYYFJlBzTKZCxx8kLaD3FD5s9BEEjx5Pyg==}
+    engines: {node: '>=10'}
+
+  simple-update-in@2.2.0:
+    resolution: {integrity: sha512-FrW41lLiOs82jKxwq39UrE1HDAHOvirKWk4Nv8tqnFFFknVbTxcHZzDS4vt02qqdU/5+KNsQHWzhKHznDBmrww==}
+
   simple-update-notifier@2.0.0:
     resolution: {integrity: sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==}
     engines: {node: '>=10'}
@@ -6816,6 +9367,9 @@ packages:
   sinon@22.0.0:
     resolution: {integrity: sha512-sq/6DpdXOrLyfbKlXLg/Usc7xu8YXPeLkOFZRvA3bNUSA2lhbrZ06yuXbH1fkzBPCbz9O10+7hznzUsjaYNm0Q==}
 
+  sisteransi@1.0.5:
+    resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
+
   skin-tone@2.0.0:
     resolution: {integrity: sha512-kUMbT1oBJCpgrnKoSr0o6wPtvRWT9W9UKvGLwfJYO2WuahZRHOpEyL1ckyMGgMWh0UdpmaoFqKKD29WTomNEGA==}
     engines: {node: '>=8'}
@@ -6824,10 +9378,18 @@ packages:
     resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
     engines: {node: '>=8'}
 
+  slash@5.1.0:
+    resolution: {integrity: sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==}
+    engines: {node: '>=14.16'}
+
   slice-ansi@3.0.0:
     resolution: {integrity: sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==}
     engines: {node: '>=8'}
 
+  slice-ansi@4.0.0:
+    resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==}
+    engines: {node: '>=10'}
+
   slice-ansi@7.1.2:
     resolution: {integrity: sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==}
     engines: {node: '>=18'}
@@ -6855,6 +9417,12 @@ packages:
   sonic-boom@4.2.1:
     resolution: {integrity: sha512-w6AxtubXa2wTXAUsZMMWERrsIRAdrK0Sc+FUytWvYAhBJLyuI4llrMIC1DtlNSdI99EI86KZum2MMq3EAZlF9Q==}
 
+  sonner@2.0.7:
+    resolution: {integrity: sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w==}
+    peerDependencies:
+      react: ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+      react-dom: ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+
   source-map-js@1.2.1:
     resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
     engines: {node: '>=0.10.0'}
@@ -6862,6 +9430,10 @@ packages:
   source-map-support@0.5.21:
     resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
 
+  source-map@0.5.7:
+    resolution: {integrity: sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==}
+    engines: {node: '>=0.10.0'}
+
   source-map@0.6.1:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
@@ -6872,6 +9444,18 @@ packages:
   spawndamnit@3.0.1:
     resolution: {integrity: sha512-MmnduQUuHCoFckZoWnXsTg7JaiLBJrKFj9UI2MbRPGaJeVpsLcVBu6P/IGZovziM/YBsellCmsprgNA+w0CzVg==}
 
+  spdx-correct@3.2.0:
+    resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==}
+
+  spdx-exceptions@2.5.0:
+    resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==}
+
+  spdx-expression-parse@3.0.1:
+    resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==}
+
+  spdx-license-ids@3.0.23:
+    resolution: {integrity: sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw==}
+
   speakingurl@14.0.1:
     resolution: {integrity: sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==}
     engines: {node: '>=0.10.0'}
@@ -6911,6 +9495,10 @@ packages:
   std-env@4.0.0:
     resolution: {integrity: sha512-zUMPtQ/HBY3/50VbpkupYHbRroTRZJPRLvreamgErJVys0ceuzMkD44J/QjqhHjOzK42GQ3QZIeFG1OYfOtKqQ==}
 
+  stdin-discarder@0.2.2:
+    resolution: {integrity: sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==}
+    engines: {node: '>=18'}
+
   stop-iteration-iterator@1.1.0:
     resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==}
     engines: {node: '>= 0.4'}
@@ -6923,6 +9511,9 @@ packages:
     peerDependencies:
       shiki: '>=3.23.0'
 
+  strict-event-emitter@0.5.1:
+    resolution: {integrity: sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ==}
+
   string-argv@0.3.2:
     resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==}
     engines: {node: '>=0.6.19'}
@@ -6964,6 +9555,10 @@ packages:
   stringify-entities@4.0.4:
     resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==}
 
+  stringify-object@5.0.0:
+    resolution: {integrity: sha512-zaJYxz2FtcMb4f+g60KsRNFOpVMUyuJgA51Zi5Z1DOTC3S59+OQiVOzE9GZt0x72uBGWKsQIuBKeF9iusmKFsg==}
+    engines: {node: '>=14.16'}
+
   strip-ansi@6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
@@ -6980,10 +9575,38 @@ packages:
     resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
     engines: {node: '>=4'}
 
+  strip-final-newline@2.0.0:
+    resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
+    engines: {node: '>=6'}
+
+  strip-final-newline@4.0.0:
+    resolution: {integrity: sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==}
+    engines: {node: '>=18'}
+
+  strip-json-comments@2.0.1:
+    resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
+    engines: {node: '>=0.10.0'}
+
+  strip-json-comments@3.1.1:
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
+
   strtok3@10.3.5:
     resolution: {integrity: sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==}
     engines: {node: '>=18'}
 
+  structured-source@4.0.0:
+    resolution: {integrity: sha512-qGzRFNJDjFieQkl/sVOI2dUjHKRyL9dAJi2gCPGJLbJHBIkyOHxjuocpIEfbLioX+qSJpvbYdT49/YCdMznKxA==}
+
+  style-to-js@1.1.21:
+    resolution: {integrity: sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==}
+
+  style-to-object@1.0.14:
+    resolution: {integrity: sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==}
+
+  stylis@4.2.0:
+    resolution: {integrity: sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==}
+
   stylis@4.4.0:
     resolution: {integrity: sha512-5Z9ZpRzfuH6l/UAvCPAPUo3665Nk2wLaZU3x+TLHKVzIz33+sbJqbtrYoC3KD4/uVOr2Zp+L0LySezP9OHV9yA==}
 
@@ -7003,6 +9626,10 @@ packages:
     resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
     engines: {node: '>=10'}
 
+  supports-color@9.4.0:
+    resolution: {integrity: sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==}
+    engines: {node: '>=12'}
+
   supports-hyperlinks@3.2.0:
     resolution: {integrity: sha512-zFObLMyZeEwzAoKCyu1B91U79K2t7ApXuQfo8OuxwXLDgcKxuwM+YvcbIhm6QWqz7mHUH1TVytR1PwVVjEuMig==}
     engines: {node: '>=14.18'}
@@ -7014,9 +9641,29 @@ packages:
   symbol-tree@3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
+  systeminformation@5.31.17:
+    resolution: {integrity: sha512-TvFA9iwDWlMjqZVlKIJ0Cy+Zgm9ttlMx0SMRwJDMNKyhlEKWBMb3+WRwDi/3dvHdWbexpos4Osp4U49p5WjB5g==}
+    engines: {node: '>=8.0.0'}
+    os: [darwin, linux, win32, freebsd, openbsd, netbsd, sunos, android]
+    hasBin: true
+
   tabbable@6.4.0:
     resolution: {integrity: sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==}
 
+  table@6.9.0:
+    resolution: {integrity: sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==}
+    engines: {node: '>=10.0.0'}
+
+  tagged-tag@1.0.0:
+    resolution: {integrity: sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==}
+    engines: {node: '>=20'}
+
+  tailwind-merge@3.6.0:
+    resolution: {integrity: sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w==}
+
+  tailwindcss@4.1.18:
+    resolution: {integrity: sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==}
+
   tailwindcss@4.2.2:
     resolution: {integrity: sha512-KWBIxs1Xb6NoLdMVqhbhgwZf2PGBpPEiwOqgI4pFIYbNTfBXiKYyWoTsXgBQ9WFg/OlhnvHaY+AEpW7wSmFo2Q==}
 
@@ -7024,6 +9671,9 @@ packages:
     resolution: {integrity: sha512-1MOpMXuhGzGL5TTCZFItxCc0AARf1EZFQkGqMm7ERKj8+Hgr5oLvJOVFcC+lRmR8hCe2S3jC4T5D7Vg/d7/fhA==}
     engines: {node: '>=6'}
 
+  tar-fs@2.1.5:
+    resolution: {integrity: sha512-OboTd8mmMhZDNPV+UjQcK9yKAatXu2aJ+r1w4im1Otd4M4fl2hwvdoXUxIYHFTHWK/3y3FarBP70v3vwmGlOxw==}
+
   tar-stream@2.2.0:
     resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
     engines: {node: '>=6'}
@@ -7044,6 +9694,21 @@ packages:
     resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
     engines: {node: '>=8'}
 
+  terminal-link@4.0.0:
+    resolution: {integrity: sha512-lk+vH+MccxNqgVqSnkMVKx4VLJfnLjDBGzH16JVZjKE2DoxP57s6/vt6JmXV5I3jBcfGrxNrYtC+mPtU7WJztA==}
+    engines: {node: '>=18'}
+
+  test-exclude@6.0.0:
+    resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==}
+    engines: {node: '>=8'}
+
+  text-table@0.2.0:
+    resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==}
+
+  textextensions@6.11.0:
+    resolution: {integrity: sha512-tXJwSr9355kFJI3lbCkPpUH5cP8/M0GGy2xLO34aZCjMXBaK3SoPnZwr/oWmo1FdCnELcs4npdCIOFtq9W3ruQ==}
+    engines: {node: '>=4'}
+
   thenify-all@1.6.0:
     resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==}
     engines: {node: '>=0.8'}
@@ -7054,6 +9719,9 @@ packages:
   thread-stream@3.2.0:
     resolution: {integrity: sha512-zLBvqpwr4Esa0kRjcrzGU6zL25lePWaCLMx0RQFrmteozIfeNdaMLpG5U7PeHzvlFkAWaRKA9/KVW4F60iB+qw==}
 
+  tiny-invariant@1.3.3:
+    resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
+
   tinybench@2.9.0:
     resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
 
@@ -7079,10 +9747,17 @@ packages:
   tldts-core@6.1.86:
     resolution: {integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==}
 
+  tldts-core@7.4.8:
+    resolution: {integrity: sha512-c1P7u0EhACHj7lPy4MJm8iTFEU8+nB0LCtddH0fhP7noaVoXAqafMtOOeX+ulpuPBqnrRgRhw494RICT3mbhnw==}
+
   tldts@6.1.86:
     resolution: {integrity: sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==}
     hasBin: true
 
+  tldts@7.4.8:
+    resolution: {integrity: sha512-htwgN/8KRB3z3vnC0BOETVh2m499g5GmyTK9Wq5JBLX3FNz6tSBveAd+fQhzy9hkjif8vy2jwDMR1sGhLtZl2A==}
+    hasBin: true
+
   tmp-promise@3.0.3:
     resolution: {integrity: sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==}
 
@@ -7113,6 +9788,10 @@ packages:
     resolution: {integrity: sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==}
     engines: {node: '>=16'}
 
+  tough-cookie@6.0.2:
+    resolution: {integrity: sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==}
+    engines: {node: '>=16'}
+
   tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
@@ -7140,9 +9819,16 @@ packages:
     resolution: {integrity: sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==}
     engines: {node: '>=6.10'}
 
+  ts-morph@26.0.0:
+    resolution: {integrity: sha512-ztMO++owQnz8c/gIENcM9XfCEzgoGphTv+nKpYNM1bgsdOVC/jRZuEBf6N+mLLDNg68Kl+GgUZfOySaRiG1/Ug==}
+
   ts-morph@28.0.0:
     resolution: {integrity: sha512-Wp3tnZ2bzwxyTZMtgWVzXDfm7lB1Drz+y9DmmYH/L702PQhPyVrp3pkou3yIz4qjS14GY9kcpmLiOOMvl8oG1g==}
 
+  tsconfig-paths@4.2.0:
+    resolution: {integrity: sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==}
+    engines: {node: '>=6'}
+
   tsdown@0.22.0:
     resolution: {integrity: sha512-FgW0hHb27nGQA/+F3d5+U9wKXkfilk9DVkc5+7x/ZqF03g+Hoz/eeApT32jqxATt9eRoR+1jxk7MUMON+O4CXw==}
     engines: {node: ^22.18.0 || >=24.0.0}
@@ -7185,6 +9871,16 @@ packages:
     engines: {node: '>=18.0.0'}
     hasBin: true
 
+  tunnel-agent@0.6.0:
+    resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
+
+  tunnel@0.0.6:
+    resolution: {integrity: sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==}
+    engines: {node: '>=0.6.11 <=0.7.0 || >=0.7.3'}
+
+  tw-animate-css@1.4.0:
+    resolution: {integrity: sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ==}
+
   tweetnacl@0.14.5:
     resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==}
 
@@ -7200,6 +9896,14 @@ packages:
     resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==}
     engines: {node: '>=10'}
 
+  type-fest@4.41.0:
+    resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
+    engines: {node: '>=16'}
+
+  type-fest@5.8.0:
+    resolution: {integrity: sha512-YGYEVz3Fm5iy/AybuA0oyNFq7H4CgQNfRp/qfe8nurE1kuCeNm3/vfm9X4Mtl+qLyaKJUh5xrFZwogr41SMjYA==}
+    engines: {node: '>=20'}
+
   type-is@2.0.1:
     resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
     engines: {node: '>= 0.6'}
@@ -7220,6 +9924,9 @@ packages:
     resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==}
     engines: {node: '>= 0.4'}
 
+  typed-rest-client@1.8.11:
+    resolution: {integrity: sha512-5UvfMpd1oelmUPRbbaVnq+rHP7ng2cE4qoQkQeAqxRL6PklkxsM0g32/HL0yfvruK6ojQ5x8EE+HF4YV6DtuCA==}
+
   typescript@5.6.1-rc:
     resolution: {integrity: sha512-E3b2+1zEFu84jB0YQi9BORDjz9+jGbwwy1Zi3G0LUNw7a7cePUrHMRNy8aPh53nXpkFGVHSxIZo5vKTfYaFiBQ==}
     engines: {node: '>=14.17'}
@@ -7259,6 +9966,9 @@ packages:
   unconfig-core@7.5.0:
     resolution: {integrity: sha512-Su3FauozOGP44ZmKdHy2oE6LPjk51M/TRRjHv2HNCWiDvfvCoxC2lno6jevMA91MYAdCdwP05QnWdWpSbncX/w==}
 
+  underscore@1.13.8:
+    resolution: {integrity: sha512-DXtD3ZtEQzc7M8m4cXotyHR+FAS18C64asBYY5vqZexfYryNNnDc02W4hKg3rdQuqOYas1jkseX0+nZXjTXnvQ==}
+
   undici-types@5.26.5:
     resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
 
@@ -7273,6 +9983,14 @@ packages:
     resolution: {integrity: sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g==}
     engines: {node: '>=4'}
 
+  unicorn-magic@0.1.0:
+    resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==}
+    engines: {node: '>=18'}
+
+  unicorn-magic@0.3.0:
+    resolution: {integrity: sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==}
+    engines: {node: '>=18'}
+
   unified@11.0.5:
     resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==}
 
@@ -7284,12 +10002,18 @@ packages:
     resolution: {integrity: sha512-8EyMynh679x/0gqE9fT9oilG+qEt+ibFyqjuVTsZn1+CMxH+XLlpvr2UZx4nVcCwTpx81nICr2JQFkM+HPLq4w==}
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
 
+  unist-util-find-after@5.0.0:
+    resolution: {integrity: sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==}
+
   unist-util-is@6.0.1:
     resolution: {integrity: sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==}
 
   unist-util-position@5.0.0:
     resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==}
 
+  unist-util-remove-position@5.0.0:
+    resolution: {integrity: sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==}
+
   unist-util-remove@4.0.0:
     resolution: {integrity: sha512-b4gokeGId57UVRX/eVKej5gXqGlc9+trkORhFJpu9raqZkZhU0zm8Doi05+HaiBsMEIJowL+2WtQ5ItjsngPXg==}
 
@@ -7345,6 +10069,9 @@ packages:
       synckit:
         optional: true
 
+  until-async@3.0.2:
+    resolution: {integrity: sha512-IiSk4HlzAMqTUseHHe3VhIGyuFmN90zMTpD3Z3y8jeQbzLIq500MVM7Jq2vUAnTKAFPJrqwkzr6PoTcPhGcOiw==}
+
   update-browserslist-db@1.2.3:
     resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
     hasBin: true
@@ -7354,6 +10081,29 @@ packages:
   uri-js@4.4.1:
     resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
 
+  url-join@4.0.1:
+    resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==}
+
+  use-callback-ref@1.3.3:
+    resolution: {integrity: sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  use-sidecar@1.1.3:
+    resolution: {integrity: sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   use-sync-external-store@1.6.0:
     resolution: {integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==}
     peerDependencies:
@@ -7372,10 +10122,21 @@ packages:
     resolution: {integrity: sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg==}
     hasBin: true
 
+  v8-to-istanbul@9.3.0:
+    resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==}
+    engines: {node: '>=10.12.0'}
+
+  validate-npm-package-license@3.0.4:
+    resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
+
   validate-npm-package-name@5.0.1:
     resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
+  validate-npm-package-name@7.0.2:
+    resolution: {integrity: sha512-hVDIBwsRruT73PbK7uP5ebUt+ezEtCmzZz3F59BSr2F6OVFnJ/6h8liuvdLrQ88Xmnk6/+xGGuq+pG9WwTuy3A==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
   vary@1.1.2:
     resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
     engines: {node: '>= 0.8'}
@@ -7384,12 +10145,24 @@ packages:
     resolution: {integrity: sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg==}
     engines: {node: '>=0.6.0'}
 
+  version-range@4.15.0:
+    resolution: {integrity: sha512-Ck0EJbAGxHwprkzFO966t4/5QkRuzh+/I1RxhLgUKKwEn+Cd8NwM60mE3AqBZg5gYODoXW0EFsQvbZjRlvdqbg==}
+    engines: {node: '>=4'}
+
+  vfile-location@5.0.3:
+    resolution: {integrity: sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==}
+
   vfile-message@4.0.3:
     resolution: {integrity: sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==}
 
   vfile@6.0.3:
     resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
 
+  vite-plugin-css-injected-by-js@3.5.2:
+    resolution: {integrity: sha512-2MpU/Y+SCZyWUB6ua3HbJCrgnF0KACAsmzOQt1UvRVJCGF6S8xdA3ZUhWcWdM9ivG4I5az8PnQmwwrkC2CAQrQ==}
+    peerDependencies:
+      vite: '>2.0.0-0'
+
   vite-plugin-singlefile@2.3.3:
     resolution: {integrity: sha512-XVnGH0QzbOa8fxRSsHdCarVN1BSBXNi7uLMQYlrGRN5apdHkk62XQWRJhVever0lnfuyBkwn+kvVChdm/OoOUg==}
     engines: {node: '>18.0.0'}
@@ -7610,6 +10383,9 @@ packages:
   wcwidth@1.0.1:
     resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==}
 
+  web-namespaces@2.0.1:
+    resolution: {integrity: sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==}
+
   web-streams-polyfill@3.3.3:
     resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==}
     engines: {node: '>= 8'}
@@ -7661,6 +10437,11 @@ packages:
     engines: {node: '>= 8'}
     hasBin: true
 
+  which@4.0.0:
+    resolution: {integrity: sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==}
+    engines: {node: ^16.13.0 || >=18.0.0}
+    hasBin: true
+
   why-is-node-running@2.3.0:
     resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
     engines: {node: '>=8'}
@@ -7669,6 +10450,9 @@ packages:
   wide-align@1.1.5:
     resolution: {integrity: sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==}
 
+  workerpool@9.3.4:
+    resolution: {integrity: sha512-TmPRQYYSAnnDiEB0P/Ytip7bFGvqnSU6I2BcuSw7Hx+JSg/DsUi5ebYfc8GYaSdpuvOcEs6dXxPurOYpe9QFwg==}
+
   wrap-ansi@7.0.0:
     resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
     engines: {node: '>=10'}
@@ -7700,6 +10484,10 @@ packages:
     resolution: {integrity: sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==}
     engines: {node: '>=18'}
 
+  wsl-utils@0.3.1:
+    resolution: {integrity: sha512-g/eziiSUNBSsdDJtCLB8bdYEUMj4jR7AGeUo96p/3dTafgjHhpF4RiCFPiRILwjQoDXx5MqkBr4fwWtR3Ky4Wg==}
+    engines: {node: '>=20'}
+
   xml-name-validator@5.0.0:
     resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
     engines: {node: '>=18'}
@@ -7736,6 +10524,10 @@ packages:
     resolution: {integrity: sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==}
     engines: {node: '>=18'}
 
+  yaml@1.10.3:
+    resolution: {integrity: sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==}
+    engines: {node: '>= 6'}
+
   yaml@2.8.3:
     resolution: {integrity: sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg==}
     engines: {node: '>= 14.6'}
@@ -7749,6 +10541,10 @@ packages:
     resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
     engines: {node: '>=12'}
 
+  yargs-unparser@2.0.0:
+    resolution: {integrity: sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==}
+    engines: {node: '>=10'}
+
   yargs@16.2.0:
     resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==}
     engines: {node: '>=10'}
@@ -7757,6 +10553,10 @@ packages:
     resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
     engines: {node: '>=12'}
 
+  yauzl-promise@4.0.0:
+    resolution: {integrity: sha512-/HCXpyHXJQQHvFq9noqrjfa/WpQC2XYs3vI7tBiAi4QiIU1knvYhZGaO1QPjwIVMdqflxbmwgMXtYeaRiAE0CA==}
+    engines: {node: '>=16'}
+
   yauzl@2.10.0:
     resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
 
@@ -7764,6 +10564,9 @@ packages:
     resolution: {integrity: sha512-PtGEvEP30p7sbIBJKUBjUnqgTVOyMURc4dLo9iNyAJnNIEz9pm88cCXF21w94Kg3k6RXkeZh5DHOGS0qEONvNQ==}
     engines: {node: '>=12'}
 
+  yazl@2.5.1:
+    resolution: {integrity: sha512-phENi2PLiHnHb6QBVot+dJnaAZ0xosj7p3fWl+znIjBDlnMI2PsZCJZ306BPTFOaHf5qdDEI8x5qFrSOBN5vrw==}
+
   yazl@3.3.1:
     resolution: {integrity: sha512-BbETDVWG+VcMUle37k5Fqp//7SDOK2/1+T7X8TD96M3D9G8jK5VLUdQVdVjGi8im7FGkazX7kk5hkU8X4L5Bng==}
 
@@ -7771,6 +10574,14 @@ packages:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
 
+  yocto-spinner@1.2.1:
+    resolution: {integrity: sha512-9cbFWLhbiZp+820O4pkHGNncI7+MrUGzBOjw8NMG+ewsY+aG0DdEXnr19Smxao32YOjLZRMdn1UtaxcrXOYOIg==}
+    engines: {node: '>=18.19'}
+
+  yoctocolors@2.1.2:
+    resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==}
+    engines: {node: '>=18'}
+
   zip-stream@4.1.1:
     resolution: {integrity: sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==}
     engines: {node: '>= 10'}
@@ -7801,6 +10612,24 @@ packages:
       react:
         optional: true
 
+  zustand@5.0.14:
+    resolution: {integrity: sha512-/8tAspM5LMPr28b3fwLYrtdj77ECpfZviaP75CMTnwO8ISyaE4GDIG/9rDDYq/cH9D2Xw2A2RXglLInmVBQB/g==}
+    engines: {node: '>=12.20.0'}
+    peerDependencies:
+      '@types/react': '>=18.0.0'
+      immer: '>=9.0.6'
+      react: '>=18.0.0'
+      use-sync-external-store: '>=1.2.0'
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      immer:
+        optional: true
+      react:
+        optional: true
+      use-sync-external-store:
+        optional: true
+
   zwitch@2.0.4:
     resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==}
 
@@ -7931,6 +10760,13 @@ snapshots:
       package-manager-detector: 1.6.0
       tinyexec: 1.1.2
 
+  '@antfu/ni@25.0.0':
+    dependencies:
+      ansis: 4.2.0
+      fzf: 0.5.2
+      package-manager-detector: 1.6.0
+      tinyexec: 1.1.2
+
   '@antfu/utils@9.3.0': {}
 
   '@anthropic-ai/sdk@0.95.2(zod@4.3.6)':
@@ -7970,12 +10806,106 @@ snapshots:
       lru-cache: 10.4.3
     optional: true
 
+  '@azu/format-text@1.0.2': {}
+
+  '@azu/style-format@1.0.1':
+    dependencies:
+      '@azu/format-text': 1.0.2
+
+  '@azure/abort-controller@2.2.0':
+    dependencies:
+      tslib: 2.8.1
+
+  '@azure/core-auth@1.11.0':
+    dependencies:
+      '@azure/abort-controller': 2.2.0
+      '@azure/core-util': 1.14.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/core-client@1.11.0':
+    dependencies:
+      '@azure/abort-controller': 2.2.0
+      '@azure/core-auth': 1.11.0
+      '@azure/core-rest-pipeline': 1.25.0
+      '@azure/core-tracing': 1.4.0
+      '@azure/core-util': 1.14.0
+      '@azure/logger': 1.4.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/core-rest-pipeline@1.25.0':
+    dependencies:
+      '@azure/abort-controller': 2.2.0
+      '@azure/core-auth': 1.11.0
+      '@azure/core-tracing': 1.4.0
+      '@azure/core-util': 1.14.0
+      '@azure/logger': 1.4.0
+      '@typespec/ts-http-runtime': 0.3.7
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/core-tracing@1.4.0':
+    dependencies:
+      tslib: 2.8.1
+
+  '@azure/core-util@1.14.0':
+    dependencies:
+      '@azure/abort-controller': 2.2.0
+      '@typespec/ts-http-runtime': 0.3.7
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/identity@4.13.1':
+    dependencies:
+      '@azure/abort-controller': 2.2.0
+      '@azure/core-auth': 1.11.0
+      '@azure/core-client': 1.11.0
+      '@azure/core-rest-pipeline': 1.25.0
+      '@azure/core-tracing': 1.4.0
+      '@azure/core-util': 1.14.0
+      '@azure/logger': 1.4.0
+      '@azure/msal-browser': 5.17.1
+      '@azure/msal-node': 5.4.1
+      open: 10.2.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/logger@1.4.0':
+    dependencies:
+      '@typespec/ts-http-runtime': 0.3.7
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/msal-browser@5.17.1':
+    dependencies:
+      '@azure/msal-common': 16.11.2
+
+  '@azure/msal-common@16.11.2': {}
+
+  '@azure/msal-node@5.4.1':
+    dependencies:
+      '@azure/msal-common': 16.11.2
+      jsonwebtoken: 9.0.3
+
   '@babel/code-frame@7.29.0':
     dependencies:
       '@babel/helper-validator-identifier': 7.28.5
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
+  '@babel/code-frame@7.29.7':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.29.7
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
   '@babel/compat-data@7.29.0': {}
 
   '@babel/core@7.29.0':
@@ -7991,7 +10921,7 @@ snapshots:
       '@babel/types': 7.29.0
       '@jridgewell/remapping': 2.3.5
       convert-source-map: 2.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
@@ -8006,6 +10936,14 @@ snapshots:
       '@jridgewell/trace-mapping': 0.3.31
       jsesc: 3.1.0
 
+  '@babel/generator@7.29.7':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      jsesc: 3.1.0
+
   '@babel/generator@8.0.0-rc.5':
     dependencies:
       '@babel/parser': 8.0.0-rc.5
@@ -8015,6 +10953,10 @@ snapshots:
       '@types/jsesc': 2.5.1
       jsesc: 3.1.0
 
+  '@babel/helper-annotate-as-pure@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
   '@babel/helper-compilation-targets@7.28.6':
     dependencies:
       '@babel/compat-data': 7.29.0
@@ -8023,8 +10965,30 @@ snapshots:
       lru-cache: 5.1.1
       semver: 6.3.1
 
+  '@babel/helper-create-class-features-plugin@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-member-expression-to-functions': 7.29.7
+      '@babel/helper-optimise-call-expression': 7.29.7
+      '@babel/helper-replace-supers': 7.29.7(@babel/core@7.29.0)
+      '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
+      '@babel/traverse': 7.29.7
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
   '@babel/helper-globals@7.28.0': {}
 
+  '@babel/helper-globals@7.29.7': {}
+
+  '@babel/helper-member-expression-to-functions@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
   '@babel/helper-module-imports@7.28.6':
     dependencies:
       '@babel/traverse': 7.29.0
@@ -8032,6 +10996,13 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@babel/helper-module-imports@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
   '@babel/helper-module-transforms@7.28.6(@babel/core@7.29.0)':
     dependencies:
       '@babel/core': 7.29.0
@@ -8041,8 +11012,39 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-optimise-call-expression@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
   '@babel/helper-plugin-utils@7.28.6': {}
 
+  '@babel/helper-plugin-utils@7.29.7': {}
+
+  '@babel/helper-replace-supers@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-member-expression-to-functions': 7.29.7
+      '@babel/helper-optimise-call-expression': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
   '@babel/helper-string-parser@7.27.1': {}
 
   '@babel/helper-string-parser@7.29.7': {}
@@ -8057,6 +11059,8 @@ snapshots:
 
   '@babel/helper-validator-option@7.27.1': {}
 
+  '@babel/helper-validator-option@7.29.7': {}
+
   '@babel/helpers@7.29.2':
     dependencies:
       '@babel/template': 7.28.6
@@ -8078,6 +11082,24 @@ snapshots:
     dependencies:
       '@babel/types': 8.0.0-rc.5
 
+  '@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/plugin-transform-modules-commonjs@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.0)
+      '@babel/helper-plugin-utils': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
   '@babel/plugin-transform-react-jsx-self@7.27.1(@babel/core@7.29.0)':
     dependencies:
       '@babel/core': 7.29.0
@@ -8088,6 +11110,32 @@ snapshots:
       '@babel/core': 7.29.0
       '@babel/helper-plugin-utils': 7.28.6
 
+  '@babel/plugin-transform-typescript@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-create-class-features-plugin': 7.29.7(@babel/core@7.29.0)
+      '@babel/helper-plugin-utils': 7.29.7
+      '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
+      '@babel/plugin-syntax-typescript': 7.29.7(@babel/core@7.29.0)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/preset-typescript@7.29.7(@babel/core@7.29.0)':
+    dependencies:
+      '@babel/core': 7.29.0
+      '@babel/helper-plugin-utils': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.0)
+      '@babel/plugin-transform-modules-commonjs': 7.29.7(@babel/core@7.29.0)
+      '@babel/plugin-transform-typescript': 7.29.7(@babel/core@7.29.0)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/runtime-corejs3@7.29.7':
+    dependencies:
+      core-js-pure: 3.49.0
+
   '@babel/runtime@7.29.2': {}
 
   '@babel/template@7.28.6':
@@ -8096,6 +11144,12 @@ snapshots:
       '@babel/parser': 7.29.2
       '@babel/types': 7.29.0
 
+  '@babel/template@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
   '@babel/traverse@7.29.0':
     dependencies:
       '@babel/code-frame': 7.29.0
@@ -8104,7 +11158,19 @@ snapshots:
       '@babel/parser': 7.29.2
       '@babel/template': 7.28.6
       '@babel/types': 7.29.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/traverse@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -8123,6 +11189,31 @@ snapshots:
       '@babel/helper-string-parser': 8.0.0-rc.5
       '@babel/helper-validator-identifier': 8.0.0-rc.5
 
+  '@base-ui/react@1.6.0(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@babel/runtime': 7.29.2
+      '@base-ui/utils': 0.3.1(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@floating-ui/react-dom': 2.1.9(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@floating-ui/utils': 0.2.11
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      use-sync-external-store: 1.6.0(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@base-ui/utils@0.3.1(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@babel/runtime': 7.29.2
+      '@floating-ui/utils': 0.2.11
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      reselect: 5.2.0
+      use-sync-external-store: 1.6.0(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@bcoe/v8-coverage@0.2.3': {}
+
   '@bcoe/v8-coverage@1.0.2': {}
 
   '@borewit/text-codec@0.2.2': {}
@@ -8361,6 +11452,27 @@ snapshots:
     transitivePeerDependencies:
       - '@algolia/client-search'
 
+  '@dotenvx/dotenvx@1.75.1':
+    dependencies:
+      '@dotenvx/primitives': 0.8.0
+      commander: 11.1.0
+      conf: 10.2.0
+      dotenv: 17.4.2
+      enquirer: 2.4.1
+      env-paths: 2.2.1
+      execa: 5.1.1
+      fdir: 6.5.0(picomatch@4.0.4)
+      ignore: 5.3.2
+      object-treeify: 1.1.33
+      open: 8.4.2
+      picomatch: 4.0.4
+      systeminformation: 5.31.17
+      undici: 7.27.1
+      which: 4.0.0
+      yocto-spinner: 1.2.1
+
+  '@dotenvx/primitives@0.8.0': {}
+
   '@electron/asar@3.4.1':
     dependencies:
       commander: 5.1.0
@@ -8369,7 +11481,7 @@ snapshots:
 
   '@electron/get@2.0.3':
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       env-paths: 2.2.1
       fs-extra: 8.1.0
       got: 11.8.6
@@ -8383,7 +11495,7 @@ snapshots:
 
   '@electron/notarize@2.5.0':
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       fs-extra: 9.1.0
       promise-retry: 2.0.1
     transitivePeerDependencies:
@@ -8392,7 +11504,7 @@ snapshots:
   '@electron/osx-sign@1.3.1':
     dependencies:
       compare-version: 0.1.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       fs-extra: 10.1.0
       isbinaryfile: 4.0.10
       minimist: 1.2.8
@@ -8404,7 +11516,7 @@ snapshots:
     dependencies:
       '@malept/cross-spawn-promise': 2.0.0
       chalk: 4.1.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       detect-libc: 2.1.2
       fs-extra: 10.1.0
       got: 11.8.6
@@ -8424,7 +11536,7 @@ snapshots:
     dependencies:
       '@electron/asar': 3.4.1
       '@malept/cross-spawn-promise': 2.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       dir-compare: 4.2.0
       fs-extra: 11.3.5
       minimatch: 9.0.9
@@ -8459,6 +11571,62 @@ snapshots:
       tslib: 2.8.1
     optional: true
 
+  '@emotion/babel-plugin@11.13.5':
+    dependencies:
+      '@babel/helper-module-imports': 7.28.6
+      '@babel/runtime': 7.29.2
+      '@emotion/hash': 0.9.2
+      '@emotion/memoize': 0.9.0
+      '@emotion/serialize': 1.3.3
+      babel-plugin-macros: 3.1.0
+      convert-source-map: 1.9.0
+      escape-string-regexp: 4.0.0
+      find-root: 1.1.0
+      source-map: 0.5.7
+      stylis: 4.2.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@emotion/cache@11.14.0':
+    dependencies:
+      '@emotion/memoize': 0.9.0
+      '@emotion/sheet': 1.4.0
+      '@emotion/utils': 1.4.2
+      '@emotion/weak-memoize': 0.4.0
+      stylis: 4.2.0
+
+  '@emotion/css@11.1.3(@babel/core@7.29.0)':
+    dependencies:
+      '@emotion/babel-plugin': 11.13.5
+      '@emotion/cache': 11.14.0
+      '@emotion/serialize': 1.3.3
+      '@emotion/sheet': 1.4.0
+      '@emotion/utils': 1.4.2
+    optionalDependencies:
+      '@babel/core': 7.29.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@emotion/hash@0.9.2': {}
+
+  '@emotion/memoize@0.9.0': {}
+
+  '@emotion/serialize@1.3.3':
+    dependencies:
+      '@emotion/hash': 0.9.2
+      '@emotion/memoize': 0.9.0
+      '@emotion/unitless': 0.10.0
+      '@emotion/utils': 1.4.2
+      csstype: 3.2.3
+
+  '@emotion/sheet@1.4.0': {}
+
+  '@emotion/unitless@0.10.0': {}
+
+  '@emotion/utils@1.4.2': {}
+
+  '@emotion/weak-memoize@0.4.0': {}
+
   '@esbuild/aix-ppc64@0.21.5':
     optional: true
 
@@ -8733,13 +11901,30 @@ snapshots:
     dependencies:
       '@floating-ui/utils': 0.2.11
 
+  '@floating-ui/core@1.8.0':
+    dependencies:
+      '@floating-ui/utils': 0.2.12
+
   '@floating-ui/dom@1.7.6':
     dependencies:
       '@floating-ui/core': 1.7.5
       '@floating-ui/utils': 0.2.11
 
+  '@floating-ui/dom@1.8.0':
+    dependencies:
+      '@floating-ui/core': 1.8.0
+      '@floating-ui/utils': 0.2.12
+
+  '@floating-ui/react-dom@2.1.9(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@floating-ui/dom': 1.8.0
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+
   '@floating-ui/utils@0.2.11': {}
 
+  '@floating-ui/utils@0.2.12': {}
+
   '@fontsource-variable/inter@5.2.8': {}
 
   '@fontsource-variable/jetbrains-mono@5.2.8': {}
@@ -8783,6 +11968,27 @@ snapshots:
       '@iconify/types': 2.0.0
       import-meta-resolve: 4.2.0
 
+  '@inquirer/ansi@2.0.7': {}
+
+  '@inquirer/confirm@6.1.1(@types/node@22.19.17)':
+    dependencies:
+      '@inquirer/core': 11.2.1(@types/node@22.19.17)
+      '@inquirer/type': 4.0.7(@types/node@22.19.17)
+    optionalDependencies:
+      '@types/node': 22.19.17
+
+  '@inquirer/core@11.2.1(@types/node@22.19.17)':
+    dependencies:
+      '@inquirer/ansi': 2.0.7
+      '@inquirer/figures': 2.0.7
+      '@inquirer/type': 4.0.7(@types/node@22.19.17)
+      cli-width: 4.1.0
+      fast-wrap-ansi: 0.2.2
+      mute-stream: 3.0.0
+      signal-exit: 4.1.0
+    optionalDependencies:
+      '@types/node': 22.19.17
+
   '@inquirer/external-editor@1.0.3(@types/node@22.19.17)':
     dependencies:
       chardet: 2.1.1
@@ -8790,6 +11996,12 @@ snapshots:
     optionalDependencies:
       '@types/node': 22.19.17
 
+  '@inquirer/figures@2.0.7': {}
+
+  '@inquirer/type@4.0.7(@types/node@22.19.17)':
+    optionalDependencies:
+      '@types/node': 22.19.17
+
   '@intlify/core-base@11.4.5':
     dependencies:
       '@intlify/devtools-types': 11.4.5
@@ -8821,6 +12033,8 @@ snapshots:
     dependencies:
       minipass: 7.1.3
 
+  '@istanbuljs/schema@0.1.6': {}
+
   '@jimp/core@1.6.1':
     dependencies:
       '@jimp/file-ops': 1.6.1
@@ -9077,7 +12291,7 @@ snapshots:
 
   '@malept/flatpak-bundler@0.4.0':
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       fs-extra: 9.1.0
       lodash: 4.18.1
       tmp-promise: 3.0.3
@@ -9194,6 +12408,28 @@ snapshots:
 
   '@microsoft/tsdoc@0.16.0': {}
 
+  '@modelcontextprotocol/sdk@1.29.0(zod@3.25.76)':
+    dependencies:
+      '@hono/node-server': 1.19.14(hono@4.12.14)
+      ajv: 8.18.0
+      ajv-formats: 3.0.1(ajv@8.18.0)
+      content-type: 1.0.5
+      cors: 2.8.6
+      cross-spawn: 7.0.6
+      eventsource: 3.0.7
+      eventsource-parser: 3.0.6
+      express: 5.2.1
+      express-rate-limit: 8.3.2(express@5.2.1)
+      hono: 4.12.14
+      jose: 6.2.2
+      json-schema-typed: 8.0.2
+      pkce-challenge: 5.0.1
+      raw-body: 3.0.2
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.2(zod@3.25.76)
+    transitivePeerDependencies:
+      - supports-color
+
   '@modelcontextprotocol/sdk@1.29.0(zod@4.3.6)':
     dependencies:
       '@hono/node-server': 1.19.14(hono@4.12.14)
@@ -9218,8 +12454,19 @@ snapshots:
 
   '@mozilla/readability@0.6.0': {}
 
-  '@napi-rs/wasm-runtime@1.1.4':
+  '@mswjs/interceptors@0.41.9':
     dependencies:
+      '@open-draft/deferred-promise': 2.2.0
+      '@open-draft/logger': 0.3.0
+      '@open-draft/until': 2.1.0
+      is-node-process: 1.2.0
+      outvariant: 1.4.3
+      strict-event-emitter: 0.5.1
+
+  '@napi-rs/wasm-runtime@0.2.12':
+    dependencies:
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
       '@tybys/wasm-util': 0.10.1
     optional: true
 
@@ -9237,6 +12484,67 @@ snapshots:
       '@tybys/wasm-util': 0.10.1
     optional: true
 
+  '@node-rs/crc32-android-arm-eabi@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-android-arm64@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-darwin-arm64@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-darwin-x64@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-freebsd-x64@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-linux-arm-gnueabihf@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-linux-arm64-gnu@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-linux-arm64-musl@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-linux-x64-gnu@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-linux-x64-musl@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-wasm32-wasi@1.10.6':
+    dependencies:
+      '@napi-rs/wasm-runtime': 0.2.12
+    optional: true
+
+  '@node-rs/crc32-win32-arm64-msvc@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-win32-ia32-msvc@1.10.6':
+    optional: true
+
+  '@node-rs/crc32-win32-x64-msvc@1.10.6':
+    optional: true
+
+  '@node-rs/crc32@1.10.6':
+    optionalDependencies:
+      '@node-rs/crc32-android-arm-eabi': 1.10.6
+      '@node-rs/crc32-android-arm64': 1.10.6
+      '@node-rs/crc32-darwin-arm64': 1.10.6
+      '@node-rs/crc32-darwin-x64': 1.10.6
+      '@node-rs/crc32-freebsd-x64': 1.10.6
+      '@node-rs/crc32-linux-arm-gnueabihf': 1.10.6
+      '@node-rs/crc32-linux-arm64-gnu': 1.10.6
+      '@node-rs/crc32-linux-arm64-musl': 1.10.6
+      '@node-rs/crc32-linux-x64-gnu': 1.10.6
+      '@node-rs/crc32-linux-x64-musl': 1.10.6
+      '@node-rs/crc32-wasm32-wasi': 1.10.6
+      '@node-rs/crc32-win32-arm64-msvc': 1.10.6
+      '@node-rs/crc32-win32-ia32-msvc': 1.10.6
+      '@node-rs/crc32-win32-x64-msvc': 1.10.6
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -9259,6 +12567,17 @@ snapshots:
       mkdirp: 1.0.4
       rimraf: 3.0.2
 
+  '@open-draft/deferred-promise@2.2.0': {}
+
+  '@open-draft/deferred-promise@3.0.0': {}
+
+  '@open-draft/logger@0.3.0':
+    dependencies:
+      is-node-process: 1.2.0
+      outvariant: 1.4.3
+
+  '@open-draft/until@2.1.0': {}
+
   '@oxc-project/types@0.122.0':
     optional: true
 
@@ -9375,6 +12694,752 @@ snapshots:
     dependencies:
       quansync: 1.0.0
 
+  '@radix-ui/number@1.1.2': {}
+
+  '@radix-ui/primitive@1.1.5': {}
+
+  '@radix-ui/react-accessible-icon@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-visually-hidden': 1.2.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-accordion@1.2.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collapsible': 1.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-alert-dialog@1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dialog': 1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-arrow@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-aspect-ratio@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-avatar@1.2.2(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-is-hydrated': 0.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-checkbox@1.3.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-previous': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-size': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-collapsible@1.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-collection@1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-compose-refs@1.1.3(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-context-menu@2.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-menu': 2.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-context@1.2.0(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-dialog@1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-focus-guards': 1.1.4(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-focus-scope': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      aria-hidden: 1.2.6
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-direction@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-dismissable-layer@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-effect-event': 0.0.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-dropdown-menu@2.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-menu': 2.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-focus-guards@1.1.4(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-focus-scope@1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-form@0.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-label': 2.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-hover-card@1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-popper': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-id@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-label@2.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-menu@2.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-focus-guards': 1.1.4(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-focus-scope': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-popper': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      aria-hidden: 1.2.6
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-menubar@1.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-menu': 2.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-navigation-menu@1.2.18(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-previous': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-visually-hidden': 1.2.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-one-time-password-field@0.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/number': 1.1.2
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-effect-event': 0.0.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-is-hydrated': 0.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-password-toggle-field@0.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-effect-event': 0.0.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-is-hydrated': 0.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-popover@1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-focus-guards': 1.1.4(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-focus-scope': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-popper': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      aria-hidden: 1.2.6
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-popper@1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@floating-ui/react-dom': 2.1.9(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-arrow': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-rect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-size': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/rect': 1.1.2
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-portal@1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-presence@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-primitive@2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-progress@1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-radio-group@1.4.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-previous': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-size': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-roving-focus@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-is-hydrated': 0.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-scroll-area@1.2.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/number': 1.1.2
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-select@2.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/number': 1.1.2
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-focus-guards': 1.1.4(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-focus-scope': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-popper': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-previous': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-visually-hidden': 1.2.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      aria-hidden: 1.2.6
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-separator@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-slider@1.4.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/number': 1.1.2
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-previous': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-size': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-slot@1.3.0(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-switch@1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-previous': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-size': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-tabs@1.1.17(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-toast@1.2.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-visually-hidden': 1.2.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-toggle-group@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-toggle': 1.1.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-toggle@1.1.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-toolbar@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-separator': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-toggle-group': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-tooltip@1.2.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-popper': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-visually-hidden': 1.2.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-use-callback-ref@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-controllable-state@1.2.3(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-effect-event': 0.0.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-effect-event@0.0.3(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-escape-keydown@1.1.3(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-is-hydrated@0.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-layout-effect@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-previous@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-rect@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/rect': 1.1.2
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-size@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-visually-hidden@1.2.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/rect@1.1.2': {}
+
   '@rolldown/binding-android-arm64@1.0.0-rc.12':
     optional: true
 
@@ -9485,7 +13550,7 @@ snapshots:
 
   '@rolldown/binding-wasm32-wasi@1.0.0-rc.12':
     dependencies:
-      '@napi-rs/wasm-runtime': 1.1.4
+      '@napi-rs/wasm-runtime': 1.1.4(@emnapi/core@1.9.2)(@emnapi/runtime@1.9.2)
     transitivePeerDependencies:
       - '@emnapi/core'
       - '@emnapi/runtime'
@@ -9654,6 +13719,82 @@ snapshots:
     transitivePeerDependencies:
       - '@types/node'
 
+  '@sec-ant/readable-stream@0.4.1': {}
+
+  '@secretlint/config-creator@10.2.2':
+    dependencies:
+      '@secretlint/types': 10.2.2
+
+  '@secretlint/config-loader@10.2.2':
+    dependencies:
+      '@secretlint/profiler': 10.2.2
+      '@secretlint/resolver': 10.2.2
+      '@secretlint/types': 10.2.2
+      ajv: 8.18.0
+      debug: 4.4.3(supports-color@8.1.1)
+      rc-config-loader: 4.1.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@secretlint/core@10.2.2':
+    dependencies:
+      '@secretlint/profiler': 10.2.2
+      '@secretlint/types': 10.2.2
+      debug: 4.4.3(supports-color@8.1.1)
+      structured-source: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@secretlint/formatter@10.2.2':
+    dependencies:
+      '@secretlint/resolver': 10.2.2
+      '@secretlint/types': 10.2.2
+      '@textlint/linter-formatter': 15.7.1
+      '@textlint/module-interop': 15.7.1
+      '@textlint/types': 15.7.1
+      chalk: 5.6.2
+      debug: 4.4.3(supports-color@8.1.1)
+      pluralize: 8.0.0
+      strip-ansi: 7.2.0
+      table: 6.9.0
+      terminal-link: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@secretlint/node@10.2.2':
+    dependencies:
+      '@secretlint/config-loader': 10.2.2
+      '@secretlint/core': 10.2.2
+      '@secretlint/formatter': 10.2.2
+      '@secretlint/profiler': 10.2.2
+      '@secretlint/source-creator': 10.2.2
+      '@secretlint/types': 10.2.2
+      debug: 4.4.3(supports-color@8.1.1)
+      p-map: 7.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@secretlint/profiler@10.2.2': {}
+
+  '@secretlint/resolver@10.2.2': {}
+
+  '@secretlint/secretlint-formatter-sarif@10.2.2':
+    dependencies:
+      node-sarif-builder: 3.4.0
+
+  '@secretlint/secretlint-rule-no-dotenv@10.2.2':
+    dependencies:
+      '@secretlint/types': 10.2.2
+
+  '@secretlint/secretlint-rule-preset-recommend@10.2.2': {}
+
+  '@secretlint/source-creator@10.2.2':
+    dependencies:
+      '@secretlint/types': 10.2.2
+      istextorbinary: 9.5.0
+
+  '@secretlint/types@10.2.2': {}
+
   '@shikijs/core@2.5.0':
     dependencies:
       '@shikijs/engine-javascript': 2.5.0
@@ -9746,6 +13887,10 @@ snapshots:
 
   '@sindresorhus/is@4.6.0': {}
 
+  '@sindresorhus/merge-streams@2.3.0': {}
+
+  '@sindresorhus/merge-streams@4.0.0': {}
+
   '@sinonjs/commons@3.0.1':
     dependencies:
       type-detect: 4.0.8
@@ -9767,6 +13912,23 @@ snapshots:
     dependencies:
       defer-to-connect: 2.0.1
 
+  '@tabler/icons-react@3.44.0(react@19.2.5)':
+    dependencies:
+      '@tabler/icons': 3.44.0
+      react: 19.2.5
+
+  '@tabler/icons@3.44.0': {}
+
+  '@tailwindcss/node@4.1.18':
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      enhanced-resolve: 5.20.1
+      jiti: 2.6.1
+      lightningcss: 1.30.2
+      magic-string: 0.30.21
+      source-map-js: 1.2.1
+      tailwindcss: 4.1.18
+
   '@tailwindcss/node@4.2.2':
     dependencies:
       '@jridgewell/remapping': 2.3.5
@@ -9777,42 +13939,93 @@ snapshots:
       source-map-js: 1.2.1
       tailwindcss: 4.2.2
 
+  '@tailwindcss/oxide-android-arm64@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-android-arm64@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-darwin-arm64@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-darwin-arm64@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-darwin-x64@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-darwin-x64@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-freebsd-x64@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-freebsd-x64@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-linux-arm64-gnu@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-linux-arm64-gnu@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-linux-arm64-musl@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-linux-arm64-musl@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-linux-x64-gnu@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-linux-x64-gnu@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-linux-x64-musl@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-linux-x64-musl@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-wasm32-wasi@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-wasm32-wasi@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-win32-arm64-msvc@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-win32-arm64-msvc@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide-win32-x64-msvc@4.1.18':
+    optional: true
+
   '@tailwindcss/oxide-win32-x64-msvc@4.2.2':
     optional: true
 
+  '@tailwindcss/oxide@4.1.18':
+    optionalDependencies:
+      '@tailwindcss/oxide-android-arm64': 4.1.18
+      '@tailwindcss/oxide-darwin-arm64': 4.1.18
+      '@tailwindcss/oxide-darwin-x64': 4.1.18
+      '@tailwindcss/oxide-freebsd-x64': 4.1.18
+      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.1.18
+      '@tailwindcss/oxide-linux-arm64-gnu': 4.1.18
+      '@tailwindcss/oxide-linux-arm64-musl': 4.1.18
+      '@tailwindcss/oxide-linux-x64-gnu': 4.1.18
+      '@tailwindcss/oxide-linux-x64-musl': 4.1.18
+      '@tailwindcss/oxide-wasm32-wasi': 4.1.18
+      '@tailwindcss/oxide-win32-arm64-msvc': 4.1.18
+      '@tailwindcss/oxide-win32-x64-msvc': 4.1.18
+
   '@tailwindcss/oxide@4.2.2':
     optionalDependencies:
       '@tailwindcss/oxide-android-arm64': 4.2.2
@@ -9828,6 +14041,13 @@ snapshots:
       '@tailwindcss/oxide-win32-arm64-msvc': 4.2.2
       '@tailwindcss/oxide-win32-x64-msvc': 4.2.2
 
+  '@tailwindcss/vite@4.1.18(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))':
+    dependencies:
+      '@tailwindcss/node': 4.1.18
+      '@tailwindcss/oxide': 4.1.18
+      tailwindcss: 4.1.18
+      vite: 6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)
+
   '@tailwindcss/vite@4.2.2(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))':
     dependencies:
       '@tailwindcss/node': 4.2.2
@@ -9850,9 +14070,38 @@ snapshots:
 
   '@tanstack/virtual-core@3.14.0': {}
 
+  '@textlint/ast-node-types@15.7.1': {}
+
+  '@textlint/linter-formatter@15.7.1':
+    dependencies:
+      '@azu/format-text': 1.0.2
+      '@azu/style-format': 1.0.1
+      '@textlint/module-interop': 15.7.1
+      '@textlint/resolver': 15.7.1
+      '@textlint/types': 15.7.1
+      chalk: 4.1.2
+      debug: 4.4.3(supports-color@8.1.1)
+      js-yaml: 4.1.1
+      lodash: 4.18.1
+      pluralize: 2.0.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      table: 6.9.0
+      text-table: 0.2.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@textlint/module-interop@15.7.1': {}
+
+  '@textlint/resolver@15.7.1': {}
+
+  '@textlint/types@15.7.1':
+    dependencies:
+      '@textlint/ast-node-types': 15.7.1
+
   '@tokenizer/inflate@0.4.1':
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       token-types: 6.1.2
     transitivePeerDependencies:
       - supports-color
@@ -9861,6 +14110,12 @@ snapshots:
 
   '@tootallnate/once@2.0.1': {}
 
+  '@ts-morph/common@0.27.0':
+    dependencies:
+      fast-glob: 3.3.3
+      minimatch: 10.2.5
+      path-browserify: 1.0.1
+
   '@ts-morph/common@0.29.0':
     dependencies:
       minimatch: 10.2.5
@@ -10032,6 +14287,14 @@ snapshots:
 
   '@types/deep-eql@4.0.2': {}
 
+  '@types/diff@8.0.0':
+    dependencies:
+      diff: 8.0.4
+
+  '@types/estree-jsx@1.0.5':
+    dependencies:
+      '@types/estree': 1.0.8
+
   '@types/estree@1.0.8': {}
 
   '@types/fs-extra@9.0.13':
@@ -10046,10 +14309,16 @@ snapshots:
 
   '@types/http-cache-semantics@4.2.0': {}
 
+  '@types/istanbul-lib-coverage@2.0.6': {}
+
+  '@types/js-cookie@3.0.6': {}
+
   '@types/js-yaml@4.0.9': {}
 
   '@types/jsesc@2.5.1': {}
 
+  '@types/katex@0.16.8': {}
+
   '@types/keyv@3.1.4':
     dependencies:
       '@types/node': 22.19.17
@@ -10067,6 +14336,8 @@ snapshots:
 
   '@types/mdurl@2.0.0': {}
 
+  '@types/mocha@10.0.10': {}
+
   '@types/ms@2.1.0': {}
 
   '@types/node@12.20.55': {}
@@ -10085,8 +14356,12 @@ snapshots:
     dependencies:
       undici-types: 6.21.0
 
+  '@types/normalize-package-data@2.4.4': {}
+
   '@types/nunjucks@3.2.6': {}
 
+  '@types/parse-json@4.0.2': {}
+
   '@types/picomatch@4.0.3': {}
 
   '@types/plist@3.0.5':
@@ -10095,6 +14370,8 @@ snapshots:
       xmlbuilder: 15.1.1
     optional: true
 
+  '@types/prismjs@1.26.6': {}
+
   '@types/proper-lockfile@4.1.4':
     dependencies:
       '@types/retry': 0.12.0
@@ -10103,6 +14380,14 @@ snapshots:
     dependencies:
       '@types/react': 19.2.14
 
+  '@types/react-scroll-to-bottom@4.2.5':
+    dependencies:
+      '@types/react': 19.2.14
+
+  '@types/react-syntax-highlighter@15.5.13':
+    dependencies:
+      '@types/react': 19.2.14
+
   '@types/react@19.2.14':
     dependencies:
       csstype: 3.2.3
@@ -10115,8 +14400,14 @@ snapshots:
 
   '@types/retry@0.12.0': {}
 
+  '@types/sarif@2.1.7': {}
+
   '@types/semver@7.7.1': {}
 
+  '@types/set-cookie-parser@2.4.10':
+    dependencies:
+      '@types/node': 22.19.17
+
   '@types/sinon@21.0.1':
     dependencies:
       '@types/sinonjs__fake-timers': 15.0.1
@@ -10127,6 +14418,8 @@ snapshots:
     dependencies:
       '@types/node': 18.19.130
 
+  '@types/statuses@2.0.6': {}
+
   '@types/tar@7.0.87':
     dependencies:
       tar: 7.5.13
@@ -10134,11 +14427,17 @@ snapshots:
   '@types/trusted-types@2.0.7':
     optional: true
 
+  '@types/unist@2.0.11': {}
+
   '@types/unist@3.0.3': {}
 
+  '@types/validate-npm-package-name@4.0.2': {}
+
   '@types/verror@1.10.11':
     optional: true
 
+  '@types/vscode@1.100.0': {}
+
   '@types/web-bluetooth@0.0.21': {}
 
   '@types/ws@8.18.1':
@@ -10153,6 +14452,14 @@ snapshots:
     dependencies:
       '@types/node': 22.19.17
 
+  '@typespec/ts-http-runtime@0.3.7':
+    dependencies:
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
   '@ungap/structured-clone@1.3.1': {}
 
   '@upsetjs/venn.js@2.0.0':
@@ -10194,7 +14501,7 @@ snapshots:
       obug: 2.1.1
       std-env: 4.0.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+      vitest: 4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
 
   '@vitest/expect@4.1.4':
     dependencies:
@@ -10205,20 +14512,22 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
-  '@vitest/mocker@4.1.4(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))':
+  '@vitest/mocker@4.1.4(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))':
     dependencies:
       '@vitest/spy': 4.1.4
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
+      msw: 2.15.0(@types/node@22.19.17)(typescript@6.0.2)
       vite: 6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)
 
-  '@vitest/mocker@4.1.4(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))':
+  '@vitest/mocker@4.1.4(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))':
     dependencies:
       '@vitest/spy': 4.1.4
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
+      msw: 2.15.0(@types/node@22.19.17)(typescript@6.0.2)
       vite: 8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
 
   '@vitest/pretty-format@4.1.4':
@@ -10257,6 +14566,103 @@ snapshots:
       path-browserify: 1.0.1
       vscode-uri: 3.1.0
 
+  '@vscode/test-cli@0.0.11':
+    dependencies:
+      '@types/mocha': 10.0.10
+      c8: 9.1.0
+      chokidar: 3.6.0
+      enhanced-resolve: 5.20.1
+      glob: 10.5.0
+      minimatch: 9.0.9
+      mocha: 11.7.6
+      supports-color: 9.4.0
+      yargs: 17.7.2
+
+  '@vscode/test-electron@2.5.2':
+    dependencies:
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      jszip: 3.10.1
+      ora: 8.2.0
+      semver: 7.7.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@vscode/vsce-sign-alpine-arm64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-alpine-x64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-darwin-arm64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-darwin-x64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-linux-arm64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-linux-arm@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-linux-x64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-win32-arm64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign-win32-x64@2.0.6':
+    optional: true
+
+  '@vscode/vsce-sign@2.0.9':
+    optionalDependencies:
+      '@vscode/vsce-sign-alpine-arm64': 2.0.6
+      '@vscode/vsce-sign-alpine-x64': 2.0.6
+      '@vscode/vsce-sign-darwin-arm64': 2.0.6
+      '@vscode/vsce-sign-darwin-x64': 2.0.6
+      '@vscode/vsce-sign-linux-arm': 2.0.6
+      '@vscode/vsce-sign-linux-arm64': 2.0.6
+      '@vscode/vsce-sign-linux-x64': 2.0.6
+      '@vscode/vsce-sign-win32-arm64': 2.0.6
+      '@vscode/vsce-sign-win32-x64': 2.0.6
+
+  '@vscode/vsce@3.9.2':
+    dependencies:
+      '@azure/identity': 4.13.1
+      '@secretlint/node': 10.2.2
+      '@secretlint/secretlint-formatter-sarif': 10.2.2
+      '@secretlint/secretlint-rule-no-dotenv': 10.2.2
+      '@secretlint/secretlint-rule-preset-recommend': 10.2.2
+      '@vscode/vsce-sign': 2.0.9
+      azure-devops-node-api: 12.5.0
+      chalk: 4.1.2
+      cheerio: 1.2.0
+      cockatiel: 3.2.1
+      commander: 12.1.0
+      form-data: 4.0.6
+      glob: 13.0.6
+      hosted-git-info: 4.1.0
+      jsonc-parser: 3.3.1
+      leven: 3.1.0
+      markdown-it: 14.2.0
+      mime: 1.6.0
+      minimatch: 10.2.5
+      parse-semver: 1.1.1
+      read: 1.0.7
+      secretlint: 10.2.2
+      semver: 7.7.4
+      tmp: 0.2.7
+      typed-rest-client: 1.8.11
+      url-join: 4.0.1
+      xml2js: 0.5.0
+      yauzl: 3.3.0
+      yazl: 2.5.1
+    optionalDependencies:
+      keytar: 7.9.0
+    transitivePeerDependencies:
+      - supports-color
+
   '@vue/compiler-core@3.5.35':
     dependencies:
       '@babel/parser': 7.29.7
@@ -10350,13 +14756,14 @@ snapshots:
     transitivePeerDependencies:
       - typescript
 
-  '@vueuse/integrations@12.8.2(focus-trap@7.8.0)(typescript@6.0.2)':
+  '@vueuse/integrations@12.8.2(focus-trap@7.8.0)(fuse.js@7.5.0)(typescript@6.0.2)':
     dependencies:
       '@vueuse/core': 12.8.2(typescript@6.0.2)
       '@vueuse/shared': 12.8.2(typescript@6.0.2)
       vue: 3.5.35(typescript@6.0.2)
     optionalDependencies:
       focus-trap: 7.8.0
+      fuse.js: 7.5.0
     transitivePeerDependencies:
       - typescript
 
@@ -10376,13 +14783,13 @@ snapshots:
 
   '@xterm/xterm@6.0.0': {}
 
-  '@xyflow/react@12.11.1(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+  '@xyflow/react@12.11.1(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(immer@11.1.11)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
     dependencies:
       '@xyflow/system': 0.0.78
       classcat: 5.0.5
       react: 19.2.5
       react-dom: 19.2.5(react@19.2.5)
-      zustand: 4.5.7(@types/react@19.2.14)(react@19.2.5)
+      zustand: 4.5.7(@types/react@19.2.14)(immer@11.1.11)(react@19.2.5)
     optionalDependencies:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
@@ -10416,7 +14823,7 @@ snapshots:
 
   agent-base@6.0.2:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -10431,10 +14838,29 @@ snapshots:
       clean-stack: 2.2.0
       indent-string: 4.0.0
 
+  ahooks@3.9.7(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      '@babel/runtime': 7.29.2
+      '@types/js-cookie': 3.0.6
+      dayjs: 1.11.21
+      intersection-observer: 0.12.2
+      js-cookie: 3.0.8
+      lodash: 4.18.1
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-fast-compare: 3.2.2
+      resize-observer-polyfill: 1.5.1
+      screenfull: 5.2.0
+      tslib: 2.8.1
+
   ajv-draft-04@1.0.0(ajv@8.18.0):
     optionalDependencies:
       ajv: 8.18.0
 
+  ajv-formats@2.1.1(ajv@8.18.0):
+    optionalDependencies:
+      ajv: 8.18.0
+
   ajv-formats@3.0.1(ajv@8.18.0):
     optionalDependencies:
       ajv: 8.18.0
@@ -10498,6 +14924,11 @@ snapshots:
 
   any-promise@1.3.0: {}
 
+  anymatch@3.1.3:
+    dependencies:
+      normalize-path: 3.0.0
+      picomatch: 2.3.2
+
   app-builder-bin@5.0.0-alpha.10: {}
 
   app-builder-lib@25.1.8(dmg-builder@25.1.8)(electron-builder-squirrel-windows@25.1.8):
@@ -10515,7 +14946,7 @@ snapshots:
       builder-util-runtime: 9.2.10
       chromium-pickle-js: 0.2.0
       config-file-ts: 0.2.8-rc1
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       dmg-builder: 25.1.8(electron-builder-squirrel-windows@25.1.8)
       dotenv: 16.6.1
       dotenv-expand: 11.0.7
@@ -10589,6 +15020,10 @@ snapshots:
 
   argparse@2.0.1: {}
 
+  aria-hidden@1.2.6:
+    dependencies:
+      tslib: 2.8.1
+
   array-buffer-byte-length@1.0.2:
     dependencies:
       call-bound: 1.0.4
@@ -10623,14 +15058,17 @@ snapshots:
       estree-walker: 3.0.3
       pathe: 2.0.3
 
+  ast-types@0.16.1:
+    dependencies:
+      tslib: 2.8.1
+
   ast-v8-to-istanbul@1.0.0:
     dependencies:
       '@jridgewell/trace-mapping': 0.3.31
       estree-walker: 3.0.3
       js-tokens: 10.0.0
 
-  astral-regex@2.0.0:
-    optional: true
+  astral-regex@2.0.0: {}
 
   async-exit-hook@2.0.1: {}
 
@@ -10644,6 +15082,8 @@ snapshots:
 
   atomic-sleep@1.0.0: {}
 
+  atomically@1.7.0: {}
+
   available-typed-arrays@1.0.7:
     dependencies:
       possible-typed-array-names: 1.1.0
@@ -10655,6 +15095,17 @@ snapshots:
 
   await-to-js@3.0.0: {}
 
+  azure-devops-node-api@12.5.0:
+    dependencies:
+      tunnel: 0.0.6
+      typed-rest-client: 1.8.11
+
+  babel-plugin-macros@3.1.0:
+    dependencies:
+      '@babel/runtime': 7.29.2
+      cosmiconfig: 7.1.0
+      resolve: 1.22.12
+
   bail@2.0.2: {}
 
   balanced-match@1.0.2: {}
@@ -10677,6 +15128,12 @@ snapshots:
 
   bignumber.js@9.3.1: {}
 
+  binary-extensions@2.3.0: {}
+
+  binaryextensions@6.11.0:
+    dependencies:
+      editions: 6.22.0
+
   birpc@2.9.0: {}
 
   birpc@4.0.0: {}
@@ -10699,7 +15156,7 @@ snapshots:
     dependencies:
       bytes: 3.1.2
       content-type: 1.0.5
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       http-errors: 2.0.1
       iconv-lite: 0.7.2
       on-finished: 2.4.1
@@ -10714,6 +15171,8 @@ snapshots:
   boolean@3.2.0:
     optional: true
 
+  boundary@2.0.0: {}
+
   brace-expansion@1.1.15:
     dependencies:
       balanced-match: 1.0.2
@@ -10731,6 +15190,8 @@ snapshots:
     dependencies:
       fill-range: 7.1.1
 
+  browser-stdout@1.3.1: {}
+
   browserslist@4.28.2:
     dependencies:
       baseline-browser-mapping: 2.10.20
@@ -10754,7 +15215,7 @@ snapshots:
 
   builder-util-runtime@9.2.10:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       sax: 1.6.0
     transitivePeerDependencies:
       - supports-color
@@ -10768,7 +15229,7 @@ snapshots:
       builder-util-runtime: 9.2.10
       chalk: 4.1.2
       cross-spawn: 7.0.6
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       fs-extra: 10.1.0
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
@@ -10786,6 +15247,20 @@ snapshots:
 
   bytes@3.1.2: {}
 
+  c8@9.1.0:
+    dependencies:
+      '@bcoe/v8-coverage': 0.2.3
+      '@istanbuljs/schema': 0.1.6
+      find-up: 5.0.0
+      foreground-child: 3.3.1
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-reports: 3.2.0
+      test-exclude: 6.0.0
+      v8-to-istanbul: 9.3.0
+      yargs: 17.7.2
+      yargs-parser: 21.1.1
+
   cac@7.0.0: {}
 
   cacache@16.1.3:
@@ -10840,6 +15315,10 @@ snapshots:
       call-bind-apply-helpers: 1.0.2
       get-intrinsic: 1.3.0
 
+  callsites@3.1.0: {}
+
+  camelcase@6.3.0: {}
+
   caniuse-lite@1.0.30001788: {}
 
   ccount@2.0.1: {}
@@ -10861,24 +15340,72 @@ snapshots:
 
   character-entities@2.0.2: {}
 
+  character-reference-invalid@2.0.1: {}
+
   chardet@2.1.1: {}
 
+  cheerio-select@2.1.0:
+    dependencies:
+      boolbase: 1.0.0
+      css-select: 5.2.2
+      css-what: 6.2.2
+      domelementtype: 2.3.0
+      domhandler: 5.0.3
+      domutils: 3.2.2
+
+  cheerio@1.2.0:
+    dependencies:
+      cheerio-select: 2.1.0
+      dom-serializer: 2.0.0
+      domhandler: 5.0.3
+      domutils: 3.2.2
+      encoding-sniffer: 0.2.1
+      htmlparser2: 10.1.0
+      parse5: 7.3.0
+      parse5-htmlparser2-tree-adapter: 7.1.0
+      parse5-parser-stream: 7.1.2
+      undici: 7.27.1
+      whatwg-mimetype: 4.0.0
+
+  chokidar@3.6.0:
+    dependencies:
+      anymatch: 3.1.3
+      braces: 3.0.3
+      glob-parent: 5.1.2
+      is-binary-path: 2.1.0
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      readdirp: 3.6.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
   chokidar@4.0.3:
     dependencies:
       readdirp: 4.1.2
 
+  chownr@1.1.4:
+    optional: true
+
   chownr@2.0.0: {}
 
   chownr@3.0.0: {}
 
   chromium-pickle-js@0.2.0: {}
 
+  ci-info@2.0.0: {}
+
   ci-info@3.9.0: {}
 
   cjs-module-lexer@1.4.3: {}
 
+  class-variance-authority@0.7.1:
+    dependencies:
+      clsx: 2.1.1
+
   classcat@5.0.5: {}
 
+  classnames@2.3.1: {}
+
   clean-stack@2.2.0: {}
 
   cli-cursor@3.1.0:
@@ -10917,6 +15444,8 @@ snapshots:
       slice-ansi: 8.0.0
       string-width: 8.2.0
 
+  cli-width@4.1.0: {}
+
   cliui@7.0.4:
     dependencies:
       string-width: 4.2.3
@@ -10935,6 +15464,22 @@ snapshots:
 
   clone@1.0.4: {}
 
+  clsx@2.1.1: {}
+
+  cmdk@1.1.1(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dialog': 1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    transitivePeerDependencies:
+      - '@types/react'
+      - '@types/react-dom'
+
+  cockatiel@3.2.1: {}
+
   code-block-writer@13.0.3: {}
 
   color-convert@2.0.1:
@@ -10955,12 +15500,18 @@ snapshots:
 
   commander@10.0.1: {}
 
+  commander@11.1.0: {}
+
+  commander@12.1.0: {}
+
   commander@13.1.0: {}
 
   commander@14.0.3: {}
 
   commander@5.1.0: {}
 
+  commander@6.2.1: {}
+
   commander@7.2.0: {}
 
   commander@8.3.0: {}
@@ -10987,6 +15538,19 @@ snapshots:
       tree-kill: 1.2.2
       yargs: 17.7.2
 
+  conf@10.2.0:
+    dependencies:
+      ajv: 8.18.0
+      ajv-formats: 2.1.1(ajv@8.18.0)
+      atomically: 1.7.0
+      debounce-fn: 4.0.0
+      dot-prop: 6.0.1
+      env-paths: 2.2.1
+      json-schema-typed: 7.0.3
+      onetime: 5.1.2
+      pkg-up: 3.1.0
+      semver: 7.7.4
+
   confbox@0.1.8: {}
 
   confbox@0.2.4: {}
@@ -11002,6 +15566,8 @@ snapshots:
 
   content-type@1.0.5: {}
 
+  convert-source-map@1.9.0: {}
+
   convert-source-map@2.0.0: {}
 
   cookie-signature@1.2.2: {}
@@ -11014,6 +15580,10 @@ snapshots:
     dependencies:
       is-what: 5.5.0
 
+  core-js-pure@3.49.0: {}
+
+  core-js@3.18.3: {}
+
   core-util-is@1.0.2:
     optional: true
 
@@ -11032,6 +15602,23 @@ snapshots:
     dependencies:
       layout-base: 2.0.1
 
+  cosmiconfig@7.1.0:
+    dependencies:
+      '@types/parse-json': 4.0.2
+      import-fresh: 3.3.1
+      parse-json: 5.2.0
+      path-type: 4.0.0
+      yaml: 1.10.3
+
+  cosmiconfig@9.0.2(typescript@6.0.2):
+    dependencies:
+      env-paths: 2.2.1
+      import-fresh: 3.3.1
+      js-yaml: 4.1.1
+      parse-json: 5.2.0
+    optionalDependencies:
+      typescript: 6.0.2
+
   crc-32@1.2.2: {}
 
   crc32-stream@4.0.3:
@@ -11060,6 +15647,8 @@ snapshots:
 
   css-what@6.2.2: {}
 
+  cssesc@3.0.0: {}
+
   cssom@0.5.0: {}
 
   cssstyle@4.6.0:
@@ -11284,9 +15873,17 @@ snapshots:
 
   dayjs@1.11.21: {}
 
-  debug@4.4.3:
+  debounce-fn@4.0.0:
+    dependencies:
+      mimic-fn: 3.1.0
+
+  debug@4.4.3(supports-color@8.1.1):
     dependencies:
       ms: 2.1.3
+    optionalDependencies:
+      supports-color: 8.1.1
+
+  decamelize@4.0.0: {}
 
   decimal.js@10.6.0:
     optional: true
@@ -11299,6 +15896,15 @@ snapshots:
     dependencies:
       mimic-response: 3.1.0
 
+  dedent@1.7.2(babel-plugin-macros@3.1.0):
+    optionalDependencies:
+      babel-plugin-macros: 3.1.0
+
+  deep-extend@0.6.0:
+    optional: true
+
+  deepmerge@4.3.1: {}
+
   default-browser-id@5.0.1: {}
 
   default-browser@5.5.0:
@@ -11318,6 +15924,8 @@ snapshots:
       es-errors: 1.3.0
       gopd: 1.2.0
 
+  define-lazy-prop@2.0.0: {}
+
   define-lazy-prop@3.0.0: {}
 
   define-properties@1.2.1:
@@ -11344,6 +15952,8 @@ snapshots:
 
   detect-libc@2.1.2: {}
 
+  detect-node-es@1.1.0: {}
+
   detect-node@2.1.0:
     optional: true
 
@@ -11351,6 +15961,8 @@ snapshots:
     dependencies:
       dequal: 2.0.3
 
+  diff@7.0.0: {}
+
   diff@8.0.4: {}
 
   diff@9.0.0: {}
@@ -11413,12 +16025,18 @@ snapshots:
       domelementtype: 2.3.0
       domhandler: 5.0.3
 
+  dot-prop@6.0.1:
+    dependencies:
+      is-obj: 2.0.0
+
   dotenv-expand@11.0.7:
     dependencies:
       dotenv: 16.6.1
 
   dotenv@16.6.1: {}
 
+  dotenv@17.4.2: {}
+
   dotenv@8.6.0: {}
 
   dts-resolver@3.0.0: {}
@@ -11435,6 +16053,10 @@ snapshots:
     dependencies:
       safe-buffer: 5.2.1
 
+  editions@6.22.0:
+    dependencies:
+      version-range: 4.15.0
+
   ee-first@1.1.1: {}
 
   ejs@3.1.10:
@@ -11505,6 +16127,11 @@ snapshots:
 
   encodeurl@2.0.0: {}
 
+  encoding-sniffer@0.2.1:
+    dependencies:
+      iconv-lite: 0.6.3
+      whatwg-encoding: 3.1.1
+
   encoding@0.1.13:
     dependencies:
       iconv-lite: 0.6.3
@@ -11526,8 +16153,7 @@ snapshots:
 
   entities@4.5.0: {}
 
-  entities@6.0.1:
-    optional: true
+  entities@6.0.1: {}
 
   entities@7.0.1: {}
 
@@ -11537,6 +16163,10 @@ snapshots:
 
   err-code@2.0.3: {}
 
+  error-ex@1.3.4:
+    dependencies:
+      is-arrayish: 0.2.1
+
   es-abstract@1.24.2:
     dependencies:
       array-buffer-byte-length: 1.0.2
@@ -11710,13 +16340,14 @@ snapshots:
 
   escape-html@1.0.3: {}
 
-  escape-string-regexp@4.0.0:
-    optional: true
+  escape-string-regexp@4.0.0: {}
 
   escape-string-regexp@5.0.0: {}
 
   esprima@4.0.1: {}
 
+  estree-util-is-identifier-name@3.0.0: {}
+
   estree-walker@2.0.2: {}
 
   estree-walker@3.0.3:
@@ -11733,8 +16364,38 @@ snapshots:
     dependencies:
       eventsource-parser: 3.0.6
 
+  execa@5.1.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      get-stream: 6.0.1
+      human-signals: 2.1.0
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+
+  execa@9.6.1:
+    dependencies:
+      '@sindresorhus/merge-streams': 4.0.0
+      cross-spawn: 7.0.6
+      figures: 6.1.0
+      get-stream: 9.0.1
+      human-signals: 8.0.1
+      is-plain-obj: 4.1.0
+      is-stream: 4.0.1
+      npm-run-path: 6.0.0
+      pretty-ms: 9.3.0
+      signal-exit: 4.1.0
+      strip-final-newline: 4.0.0
+      yoctocolors: 2.1.2
+
   exif-parser@0.1.12: {}
 
+  expand-template@2.0.3:
+    optional: true
+
   expect-type@1.3.0: {}
 
   exponential-backoff@3.1.3: {}
@@ -11752,7 +16413,7 @@ snapshots:
       content-type: 1.0.5
       cookie: 0.7.2
       cookie-signature: 1.2.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       depd: 2.0.0
       encodeurl: 2.0.0
       escape-html: 1.0.3
@@ -11789,7 +16450,7 @@ snapshots:
 
   extract-zip@2.0.1:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       get-stream: 5.2.0
       yauzl: 2.10.0
     optionalDependencies:
@@ -11829,8 +16490,18 @@ snapshots:
 
   fast-sha256@1.3.0: {}
 
+  fast-string-truncated-width@3.0.3: {}
+
+  fast-string-width@3.0.2:
+    dependencies:
+      fast-string-truncated-width: 3.0.3
+
   fast-uri@3.1.0: {}
 
+  fast-wrap-ansi@0.2.2:
+    dependencies:
+      fast-string-width: 3.0.2
+
   fastify-plugin@5.1.0: {}
 
   fastify@5.8.5:
@@ -11855,6 +16526,10 @@ snapshots:
     dependencies:
       reusify: 1.1.0
 
+  fault@1.0.4:
+    dependencies:
+      format: 0.2.2
+
   fault@2.0.1:
     dependencies:
       format: 0.2.2
@@ -11874,6 +16549,10 @@ snapshots:
 
   fflate@0.8.2: {}
 
+  figures@6.1.0:
+    dependencies:
+      is-unicode-supported: 2.1.0
+
   file-type@21.3.4:
     dependencies:
       '@tokenizer/inflate': 0.4.1
@@ -11893,7 +16572,7 @@ snapshots:
 
   finalhandler@2.1.1:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       encodeurl: 2.0.0
       escape-html: 1.0.3
       on-finished: 2.4.1
@@ -11908,15 +16587,30 @@ snapshots:
       fast-querystring: 1.1.2
       safe-regex2: 5.1.1
 
+  find-root@1.1.0: {}
+
+  find-up@3.0.0:
+    dependencies:
+      locate-path: 3.0.0
+
   find-up@4.1.0:
     dependencies:
       locate-path: 5.0.0
       path-exists: 4.0.0
 
+  find-up@5.0.0:
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+
+  flat@5.0.2: {}
+
   focus-trap@7.8.0:
     dependencies:
       tabbable: 6.4.0
 
+  follow-redirects@1.16.0: {}
+
   for-each@0.3.5:
     dependencies:
       is-callable: 1.2.7
@@ -11999,6 +16693,12 @@ snapshots:
 
   functions-have-names@1.2.3: {}
 
+  fuse.js@7.5.0: {}
+
+  fuzzysort@3.1.0: {}
+
+  fzf@0.5.2: {}
+
   gauge@4.0.4:
     dependencies:
       aproba: 2.1.0
@@ -12047,6 +16747,10 @@ snapshots:
       hasown: 2.0.3
       math-intrinsics: 1.1.0
 
+  get-nonce@1.0.1: {}
+
+  get-own-enumerable-keys@1.0.0: {}
+
   get-proto@1.0.1:
     dependencies:
       dunder-proto: 1.0.1
@@ -12056,6 +16760,13 @@ snapshots:
     dependencies:
       pump: 3.0.4
 
+  get-stream@6.0.1: {}
+
+  get-stream@9.0.1:
+    dependencies:
+      '@sec-ant/readable-stream': 0.4.1
+      is-stream: 4.0.1
+
   get-symbol-description@1.1.0:
     dependencies:
       call-bound: 1.0.4
@@ -12075,6 +16786,9 @@ snapshots:
       image-q: 4.0.0
       omggif: 1.0.10
 
+  github-from-package@0.0.0:
+    optional: true
+
   glob-parent@5.1.2:
     dependencies:
       is-glob: 4.0.3
@@ -12088,6 +16802,12 @@ snapshots:
       package-json-from-dist: 1.0.1
       path-scurry: 1.11.1
 
+  glob@13.0.6:
+    dependencies:
+      minimatch: 10.2.5
+      minipass: 7.1.3
+      path-scurry: 2.0.2
+
   glob@7.2.3:
     dependencies:
       fs.realpath: 1.0.0
@@ -12129,6 +16849,15 @@ snapshots:
       merge2: 1.4.1
       slash: 3.0.0
 
+  globby@14.1.0:
+    dependencies:
+      '@sindresorhus/merge-streams': 2.3.0
+      fast-glob: 3.3.3
+      ignore: 7.0.6
+      path-type: 6.0.0
+      slash: 5.1.0
+      unicorn-magic: 0.3.0
+
   google-auth-library@10.6.2:
     dependencies:
       base64-js: 1.5.1
@@ -12160,6 +16889,8 @@ snapshots:
 
   graceful-fs@4.2.11: {}
 
+  graphql@16.14.2: {}
+
   gray-matter@4.0.3:
     dependencies:
       js-yaml: 3.14.2
@@ -12197,6 +16928,47 @@ snapshots:
     dependencies:
       function-bind: 1.1.2
 
+  hast-util-from-dom@5.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      hastscript: 9.0.1
+      web-namespaces: 2.0.1
+
+  hast-util-from-html-isomorphic@2.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-from-dom: 5.0.1
+      hast-util-from-html: 2.0.3
+      unist-util-remove-position: 5.0.0
+
+  hast-util-from-html@2.0.3:
+    dependencies:
+      '@types/hast': 3.0.4
+      devlop: 1.1.0
+      hast-util-from-parse5: 8.0.3
+      parse5: 7.3.0
+      vfile: 6.0.3
+      vfile-message: 4.0.3
+
+  hast-util-from-parse5@8.0.3:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      devlop: 1.1.0
+      hastscript: 9.0.1
+      property-information: 7.1.0
+      vfile: 6.0.3
+      vfile-location: 5.0.3
+      web-namespaces: 2.0.1
+
+  hast-util-is-element@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-parse-selector@4.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
   hast-util-to-html@9.0.5:
     dependencies:
       '@types/hast': 3.0.4
@@ -12211,12 +16983,58 @@ snapshots:
       stringify-entities: 4.0.4
       zwitch: 2.0.4
 
+  hast-util-to-jsx-runtime@2.3.6:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.21
+      unist-util-position: 5.0.0
+      vfile-message: 4.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-to-text@4.0.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      hast-util-is-element: 3.0.0
+      unist-util-find-after: 5.0.0
+
   hast-util-whitespace@3.0.0:
     dependencies:
       '@types/hast': 3.0.4
 
+  hastscript@9.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      hast-util-parse-selector: 4.0.0
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+
+  he@1.2.0: {}
+
+  headers-polyfill@5.0.1:
+    dependencies:
+      '@types/set-cookie-parser': 2.4.10
+      set-cookie-parser: 3.1.2
+
+  heic-to@1.5.2: {}
+
   highlight.js@10.7.3: {}
 
+  highlightjs-vue@1.0.0: {}
+
   hono@4.12.14: {}
 
   hookable@5.5.3: {}
@@ -12227,6 +17045,10 @@ snapshots:
     dependencies:
       lru-cache: 6.0.0
 
+  hosted-git-info@7.0.2:
+    dependencies:
+      lru-cache: 10.4.3
+
   html-encoding-sniffer@4.0.0:
     dependencies:
       whatwg-encoding: 3.1.1
@@ -12236,6 +17058,8 @@ snapshots:
 
   html-escaper@3.0.3: {}
 
+  html-url-attributes@3.0.1: {}
+
   html-void-elements@3.0.0: {}
 
   htmlparser2@10.1.0:
@@ -12259,14 +17083,14 @@ snapshots:
     dependencies:
       '@tootallnate/once': 2.0.1
       agent-base: 6.0.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
   http-proxy-agent@7.0.2:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -12278,19 +17102,23 @@ snapshots:
   https-proxy-agent@5.0.1:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
   https-proxy-agent@7.0.6:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
   human-id@4.1.3: {}
 
+  human-signals@2.1.0: {}
+
+  human-signals@8.0.1: {}
+
   humanize-ms@1.2.1:
     dependencies:
       ms: 2.1.3
@@ -12313,10 +17141,21 @@ snapshots:
 
   ignore@5.3.2: {}
 
+  ignore@7.0.6: {}
+
   image-q@4.0.0:
     dependencies:
       '@types/node': 16.9.1
 
+  immediate@3.0.6: {}
+
+  immer@11.1.11: {}
+
+  import-fresh@3.3.1:
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+
   import-lazy@4.0.0: {}
 
   import-meta-resolve@4.2.0: {}
@@ -12327,6 +17166,8 @@ snapshots:
 
   indent-string@4.0.0: {}
 
+  index-to-position@1.2.0: {}
+
   infer-owner@1.0.4: {}
 
   inflight@1.0.6:
@@ -12336,6 +17177,11 @@ snapshots:
 
   inherits@2.0.4: {}
 
+  ini@1.3.8:
+    optional: true
+
+  inline-style-parser@0.2.7: {}
+
   internal-slot@1.1.0:
     dependencies:
       es-errors: 1.3.0
@@ -12346,6 +17192,8 @@ snapshots:
 
   internmap@2.0.3: {}
 
+  intersection-observer@0.12.2: {}
+
   ip-address@10.1.0: {}
 
   ip-address@10.2.0: {}
@@ -12354,12 +17202,21 @@ snapshots:
 
   ipaddr.js@2.4.0: {}
 
+  is-alphabetical@2.0.1: {}
+
+  is-alphanumerical@2.0.1:
+    dependencies:
+      is-alphabetical: 2.0.1
+      is-decimal: 2.0.1
+
   is-array-buffer@3.0.5:
     dependencies:
       call-bind: 1.0.9
       call-bound: 1.0.4
       get-intrinsic: 1.3.0
 
+  is-arrayish@0.2.1: {}
+
   is-async-function@2.1.1:
     dependencies:
       async-function: 1.0.0
@@ -12372,6 +17229,10 @@ snapshots:
     dependencies:
       has-bigints: 1.1.0
 
+  is-binary-path@2.1.0:
+    dependencies:
+      binary-extensions: 2.3.0
+
   is-boolean-object@1.2.2:
     dependencies:
       call-bound: 1.0.4
@@ -12379,6 +17240,10 @@ snapshots:
 
   is-callable@1.2.7: {}
 
+  is-ci@2.0.0:
+    dependencies:
+      ci-info: 2.0.0
+
   is-ci@3.0.1:
     dependencies:
       ci-info: 3.9.0
@@ -12398,6 +17263,10 @@ snapshots:
       call-bound: 1.0.4
       has-tostringtag: 1.0.2
 
+  is-decimal@2.0.1: {}
+
+  is-docker@2.2.1: {}
+
   is-docker@3.0.0: {}
 
   is-extendable@0.1.1: {}
@@ -12426,18 +17295,30 @@ snapshots:
     dependencies:
       is-extglob: 2.1.1
 
+  is-hexadecimal@2.0.1: {}
+
+  is-in-ssh@1.0.0: {}
+
   is-inside-container@1.0.0:
     dependencies:
       is-docker: 3.0.0
 
   is-interactive@1.0.0: {}
 
+  is-interactive@2.0.0: {}
+
+  is-it-type@5.1.3:
+    dependencies:
+      globalthis: 1.0.4
+
   is-lambda@1.0.1: {}
 
   is-map@2.0.3: {}
 
   is-negative-zero@2.0.3: {}
 
+  is-node-process@1.2.0: {}
+
   is-number-object@1.1.1:
     dependencies:
       call-bound: 1.0.4
@@ -12445,6 +17326,14 @@ snapshots:
 
   is-number@7.0.0: {}
 
+  is-obj@2.0.0: {}
+
+  is-obj@3.0.0: {}
+
+  is-path-inside@3.0.3: {}
+
+  is-plain-obj@2.1.0: {}
+
   is-plain-obj@4.1.0: {}
 
   is-potential-custom-element-name@1.0.1:
@@ -12459,12 +17348,18 @@ snapshots:
       has-tostringtag: 1.0.2
       hasown: 2.0.3
 
+  is-regexp@3.1.0: {}
+
   is-set@2.0.3: {}
 
   is-shared-array-buffer@1.0.4:
     dependencies:
       call-bound: 1.0.4
 
+  is-stream@2.0.1: {}
+
+  is-stream@4.0.1: {}
+
   is-string@1.1.1:
     dependencies:
       call-bound: 1.0.4
@@ -12486,6 +17381,10 @@ snapshots:
 
   is-unicode-supported@0.1.0: {}
 
+  is-unicode-supported@1.3.0: {}
+
+  is-unicode-supported@2.1.0: {}
+
   is-weakmap@2.0.2: {}
 
   is-weakref@1.1.1:
@@ -12501,6 +17400,10 @@ snapshots:
 
   is-windows@1.0.2: {}
 
+  is-wsl@2.2.0:
+    dependencies:
+      is-docker: 2.2.1
+
   is-wsl@3.1.1:
     dependencies:
       is-inside-container: 1.0.0
@@ -12515,6 +17418,8 @@ snapshots:
 
   isexe@2.0.0: {}
 
+  isexe@3.1.5: {}
+
   istanbul-lib-coverage@3.2.2: {}
 
   istanbul-lib-report@3.0.1:
@@ -12528,6 +17433,12 @@ snapshots:
       html-escaper: 2.0.2
       istanbul-lib-report: 3.0.1
 
+  istextorbinary@9.5.0:
+    dependencies:
+      binaryextensions: 6.11.0
+      editions: 6.22.0
+      textextensions: 6.11.0
+
   jackspeak@3.4.3:
     dependencies:
       '@isaacs/cliui': 8.0.2
@@ -12580,6 +17491,8 @@ snapshots:
 
   jpeg-js@0.4.4: {}
 
+  js-cookie@3.0.8: {}
+
   js-tokens@10.0.0: {}
 
   js-tokens@4.0.0: {}
@@ -12630,13 +17543,15 @@ snapshots:
 
   json-buffer@3.0.1: {}
 
+  json-parse-even-better-errors@2.3.1: {}
+
   json-schema-ref-resolver@3.0.0:
     dependencies:
       dequal: 2.0.3
 
   json-schema-resolver@3.0.0:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       fast-uri: 3.1.0
       rfdc: 1.4.1
     transitivePeerDependencies:
@@ -12651,6 +17566,8 @@ snapshots:
 
   json-schema-traverse@1.0.0: {}
 
+  json-schema-typed@7.0.3: {}
+
   json-schema-typed@8.0.2: {}
 
   json-stringify-safe@5.0.1:
@@ -12658,6 +17575,8 @@ snapshots:
 
   json5@2.2.3: {}
 
+  jsonc-parser@3.3.1: {}
+
   jsonfile@4.0.0:
     optionalDependencies:
       graceful-fs: 4.2.11
@@ -12668,6 +17587,26 @@ snapshots:
     optionalDependencies:
       graceful-fs: 4.2.11
 
+  jsonwebtoken@9.0.3:
+    dependencies:
+      jws: 4.0.1
+      lodash.includes: 4.3.0
+      lodash.isboolean: 3.0.3
+      lodash.isinteger: 4.0.4
+      lodash.isnumber: 3.0.3
+      lodash.isplainobject: 4.0.6
+      lodash.isstring: 4.0.1
+      lodash.once: 4.1.1
+      ms: 2.1.3
+      semver: 7.7.4
+
+  jszip@3.10.1:
+    dependencies:
+      lie: 3.3.0
+      pako: 1.0.11
+      readable-stream: 2.3.8
+      setimmediate: 1.0.5
+
   jwa@2.0.1:
     dependencies:
       buffer-equal-constant-time: 1.0.1
@@ -12687,6 +17626,12 @@ snapshots:
     dependencies:
       commander: 8.3.0
 
+  keytar@7.9.0:
+    dependencies:
+      node-addon-api: 4.3.0
+      prebuild-install: 7.1.3
+    optional: true
+
   keyv@4.5.4:
     dependencies:
       json-buffer: 3.0.1
@@ -12695,6 +17640,10 @@ snapshots:
 
   kind-of@6.0.3: {}
 
+  kleur@3.0.3: {}
+
+  kleur@4.1.5: {}
+
   layout-base@1.0.2: {}
 
   layout-base@2.0.1: {}
@@ -12705,45 +17654,100 @@ snapshots:
     dependencies:
       readable-stream: 2.3.8
 
+  leven@3.1.0: {}
+
+  lie@3.3.0:
+    dependencies:
+      immediate: 3.0.6
+
   light-my-request@6.6.0:
     dependencies:
       cookie: 1.1.1
       process-warning: 4.0.1
       set-cookie-parser: 2.7.2
 
+  lightningcss-android-arm64@1.30.2:
+    optional: true
+
   lightningcss-android-arm64@1.32.0:
     optional: true
 
+  lightningcss-darwin-arm64@1.30.2:
+    optional: true
+
   lightningcss-darwin-arm64@1.32.0:
     optional: true
 
+  lightningcss-darwin-x64@1.30.2:
+    optional: true
+
   lightningcss-darwin-x64@1.32.0:
     optional: true
 
+  lightningcss-freebsd-x64@1.30.2:
+    optional: true
+
   lightningcss-freebsd-x64@1.32.0:
     optional: true
 
+  lightningcss-linux-arm-gnueabihf@1.30.2:
+    optional: true
+
   lightningcss-linux-arm-gnueabihf@1.32.0:
     optional: true
 
+  lightningcss-linux-arm64-gnu@1.30.2:
+    optional: true
+
   lightningcss-linux-arm64-gnu@1.32.0:
     optional: true
 
+  lightningcss-linux-arm64-musl@1.30.2:
+    optional: true
+
   lightningcss-linux-arm64-musl@1.32.0:
     optional: true
 
+  lightningcss-linux-x64-gnu@1.30.2:
+    optional: true
+
   lightningcss-linux-x64-gnu@1.32.0:
     optional: true
 
+  lightningcss-linux-x64-musl@1.30.2:
+    optional: true
+
   lightningcss-linux-x64-musl@1.32.0:
     optional: true
 
+  lightningcss-win32-arm64-msvc@1.30.2:
+    optional: true
+
   lightningcss-win32-arm64-msvc@1.32.0:
     optional: true
 
+  lightningcss-win32-x64-msvc@1.30.2:
+    optional: true
+
   lightningcss-win32-x64-msvc@1.32.0:
     optional: true
 
+  lightningcss@1.30.2:
+    dependencies:
+      detect-libc: 2.1.2
+    optionalDependencies:
+      lightningcss-android-arm64: 1.30.2
+      lightningcss-darwin-arm64: 1.30.2
+      lightningcss-darwin-x64: 1.30.2
+      lightningcss-freebsd-x64: 1.30.2
+      lightningcss-linux-arm-gnueabihf: 1.30.2
+      lightningcss-linux-arm64-gnu: 1.30.2
+      lightningcss-linux-arm64-musl: 1.30.2
+      lightningcss-linux-x64-gnu: 1.30.2
+      lightningcss-linux-x64-musl: 1.30.2
+      lightningcss-win32-arm64-msvc: 1.30.2
+      lightningcss-win32-x64-msvc: 1.30.2
+
   lightningcss@1.32.0:
     dependencies:
       detect-libc: 2.1.2
@@ -12760,6 +17764,8 @@ snapshots:
       lightningcss-win32-arm64-msvc: 1.32.0
       lightningcss-win32-x64-msvc: 1.32.0
 
+  lines-and-columns@1.2.4: {}
+
   linkedom@0.18.12:
     dependencies:
       css-select: 5.2.2
@@ -12796,10 +17802,19 @@ snapshots:
       pkg-types: 2.3.1
       quansync: 0.2.11
 
+  locate-path@3.0.0:
+    dependencies:
+      p-locate: 3.0.0
+      path-exists: 3.0.0
+
   locate-path@5.0.0:
     dependencies:
       p-locate: 4.1.0
 
+  locate-path@6.0.0:
+    dependencies:
+      p-locate: 5.0.0
+
   lodash-es@4.18.1: {}
 
   lodash.defaults@4.2.0: {}
@@ -12808,10 +17823,24 @@ snapshots:
 
   lodash.flatten@4.4.0: {}
 
+  lodash.includes@4.3.0: {}
+
+  lodash.isboolean@3.0.3: {}
+
+  lodash.isinteger@4.0.4: {}
+
+  lodash.isnumber@3.0.3: {}
+
   lodash.isplainobject@4.0.6: {}
 
+  lodash.isstring@4.0.1: {}
+
+  lodash.once@4.1.1: {}
+
   lodash.startcase@4.4.0: {}
 
+  lodash.truncate@4.4.2: {}
+
   lodash.union@4.6.0: {}
 
   lodash@4.18.1: {}
@@ -12821,6 +17850,11 @@ snapshots:
       chalk: 4.1.2
       is-unicode-supported: 0.1.0
 
+  log-symbols@6.0.0:
+    dependencies:
+      chalk: 5.6.2
+      is-unicode-supported: 1.3.0
+
   log-update@6.1.0:
     dependencies:
       ansi-escapes: 7.3.0
@@ -12833,8 +17867,17 @@ snapshots:
 
   longest-streak@3.1.0: {}
 
+  loose-envify@1.4.0:
+    dependencies:
+      js-tokens: 4.0.0
+
   lowercase-keys@2.0.0: {}
 
+  lowlight@1.20.0:
+    dependencies:
+      fault: 1.0.4
+      highlight.js: 10.7.3
+
   lru-cache@10.4.3: {}
 
   lru-cache@11.3.3: {}
@@ -12920,6 +17963,8 @@ snapshots:
       punycode.js: 2.3.1
       uc.micro: 2.1.0
 
+  markdown-table@3.0.4: {}
+
   markdown-title@1.0.2: {}
 
   marked-terminal@7.3.0(marked@9.1.6):
@@ -12961,6 +18006,15 @@ snapshots:
 
   math-intrinsics@1.1.0: {}
 
+  math-random@2.0.1: {}
+
+  mdast-util-find-and-replace@3.0.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      escape-string-regexp: 5.0.0
+      unist-util-is: 6.0.1
+      unist-util-visit-parents: 6.0.2
+
   mdast-util-from-markdown@2.0.3:
     dependencies:
       '@types/mdast': 4.0.4
@@ -12989,6 +18043,114 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  mdast-util-gfm-autolink-literal@2.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-find-and-replace: 3.0.2
+      micromark-util-character: 2.1.1
+
+  mdast-util-gfm-footnote@2.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+      micromark-util-normalize-identifier: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-table@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      markdown-table: 3.0.4
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm@3.1.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-gfm-autolink-literal: 2.0.1
+      mdast-util-gfm-footnote: 2.1.0
+      mdast-util-gfm-strikethrough: 2.0.0
+      mdast-util-gfm-table: 2.0.0
+      mdast-util-gfm-task-list-item: 2.0.0
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-math@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      longest-streak: 3.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+      unist-util-remove-position: 5.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-expression@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-jsx@3.2.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+      parse-entities: 4.0.2
+      stringify-entities: 4.0.4
+      unist-util-stringify-position: 4.0.0
+      vfile-message: 4.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdxjs-esm@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
   mdast-util-phrasing@4.1.0:
     dependencies:
       '@types/mdast': 4.0.4
@@ -13028,6 +18190,8 @@ snapshots:
 
   merge-descriptors@2.0.0: {}
 
+  merge-stream@2.0.0: {}
+
   merge2@1.4.1: {}
 
   mermaid@11.15.0:
@@ -13080,6 +18244,74 @@ snapshots:
       micromark-util-symbol: 2.0.1
       micromark-util-types: 2.0.2
 
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-footnote@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-table@2.1.1:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm@3.0.0:
+    dependencies:
+      micromark-extension-gfm-autolink-literal: 2.1.0
+      micromark-extension-gfm-footnote: 2.1.0
+      micromark-extension-gfm-strikethrough: 2.1.0
+      micromark-extension-gfm-table: 2.1.1
+      micromark-extension-gfm-tagfilter: 2.0.0
+      micromark-extension-gfm-task-list-item: 2.1.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-math@3.1.0:
+    dependencies:
+      '@types/katex': 0.16.8
+      devlop: 1.1.0
+      katex: 0.16.47
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
   micromark-factory-destination@2.0.1:
     dependencies:
       micromark-util-character: 2.1.1
@@ -13175,7 +18407,7 @@ snapshots:
   micromark@4.0.2:
     dependencies:
       '@types/debug': 4.1.13
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       decode-named-character-reference: 1.3.0
       devlop: 1.1.0
       micromark-core-commonmark: 2.0.3
@@ -13215,12 +18447,16 @@ snapshots:
     dependencies:
       mime-db: 1.54.0
 
+  mime@1.6.0: {}
+
   mime@2.6.0: {}
 
   mime@3.0.0: {}
 
   mimic-fn@2.1.0: {}
 
+  mimic-fn@3.1.0: {}
+
   mimic-function@5.0.1: {}
 
   mimic-response@1.0.1: {}
@@ -13294,6 +18530,9 @@ snapshots:
 
   mitt@3.0.1: {}
 
+  mkdirp-classic@0.5.3:
+    optional: true
+
   mkdirp@1.0.4: {}
 
   mlly@1.8.2:
@@ -13303,12 +18542,65 @@ snapshots:
       pkg-types: 1.3.1
       ufo: 1.6.4
 
+  mocha@11.7.6:
+    dependencies:
+      browser-stdout: 1.3.1
+      chokidar: 4.0.3
+      debug: 4.4.3(supports-color@8.1.1)
+      diff: 7.0.0
+      escape-string-regexp: 4.0.0
+      find-up: 5.0.0
+      glob: 10.5.0
+      he: 1.2.0
+      is-path-inside: 3.0.3
+      js-yaml: 4.1.1
+      log-symbols: 4.1.0
+      minimatch: 9.0.9
+      ms: 2.1.3
+      picocolors: 1.1.1
+      serialize-javascript: 6.0.2
+      strip-json-comments: 3.1.1
+      supports-color: 8.1.1
+      workerpool: 9.3.4
+      yargs: 17.7.2
+      yargs-parser: 21.1.1
+      yargs-unparser: 2.0.0
+
   mri@1.2.0: {}
 
   ms@2.1.3: {}
 
+  msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2):
+    dependencies:
+      '@inquirer/confirm': 6.1.1(@types/node@22.19.17)
+      '@mswjs/interceptors': 0.41.9
+      '@open-draft/deferred-promise': 3.0.0
+      '@types/statuses': 2.0.6
+      cookie: 1.1.1
+      graphql: 16.14.2
+      headers-polyfill: 5.0.1
+      is-node-process: 1.2.0
+      outvariant: 1.4.3
+      path-to-regexp: 6.3.0
+      picocolors: 1.1.1
+      rettime: 0.11.11
+      statuses: 2.0.2
+      strict-event-emitter: 0.5.1
+      tough-cookie: 6.0.2
+      type-fest: 5.8.0
+      until-async: 3.0.2
+      yargs: 17.7.2
+    optionalDependencies:
+      typescript: 6.0.2
+    transitivePeerDependencies:
+      - '@types/node'
+
   muggle-string@0.4.1: {}
 
+  mute-stream@0.0.8: {}
+
+  mute-stream@3.0.0: {}
+
   mz@2.7.0:
     dependencies:
       any-promise: 1.3.0
@@ -13319,10 +18611,18 @@ snapshots:
 
   nanoid@3.3.12: {}
 
+  napi-build-utils@2.0.0:
+    optional: true
+
   negotiator@0.6.4: {}
 
   negotiator@1.0.0: {}
 
+  next-themes@0.4.6(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+
   node-abi@3.92.0:
     dependencies:
       semver: 7.7.4
@@ -13330,6 +18630,9 @@ snapshots:
   node-addon-api@1.7.2:
     optional: true
 
+  node-addon-api@4.3.0:
+    optional: true
+
   node-addon-api@7.1.1: {}
 
   node-api-version@0.2.1:
@@ -13380,6 +18683,11 @@ snapshots:
 
   node-releases@2.0.37: {}
 
+  node-sarif-builder@3.4.0:
+    dependencies:
+      '@types/sarif': 2.1.7
+      fs-extra: 11.3.5
+
   non-layered-tidy-tree-layout@2.0.2:
     optional: true
 
@@ -13387,10 +18695,25 @@ snapshots:
     dependencies:
       abbrev: 1.1.1
 
+  normalize-package-data@6.0.2:
+    dependencies:
+      hosted-git-info: 7.0.2
+      semver: 7.7.4
+      validate-npm-package-license: 3.0.4
+
   normalize-path@3.0.0: {}
 
   normalize-url@6.1.0: {}
 
+  npm-run-path@4.0.1:
+    dependencies:
+      path-key: 3.1.1
+
+  npm-run-path@6.0.0:
+    dependencies:
+      path-key: 4.0.0
+      unicorn-magic: 0.3.0
+
   npmlog@6.0.2:
     dependencies:
       are-we-there-yet: 3.0.1
@@ -13419,6 +18742,8 @@ snapshots:
 
   object-keys@1.1.1: {}
 
+  object-treeify@1.1.33: {}
+
   object.assign@4.1.7:
     dependencies:
       call-bind: 1.0.9
@@ -13471,6 +18796,21 @@ snapshots:
       is-inside-container: 1.0.0
       wsl-utils: 0.1.0
 
+  open@11.0.0:
+    dependencies:
+      default-browser: 5.5.0
+      define-lazy-prop: 3.0.0
+      is-in-ssh: 1.0.0
+      is-inside-container: 1.0.0
+      powershell-utils: 0.1.0
+      wsl-utils: 0.3.1
+
+  open@8.4.2:
+    dependencies:
+      define-lazy-prop: 2.0.0
+      is-docker: 2.2.1
+      is-wsl: 2.2.0
+
   openai@6.34.0(ws@8.20.0)(zod@4.3.6):
     optionalDependencies:
       ws: 8.20.0
@@ -13490,8 +18830,36 @@ snapshots:
       strip-ansi: 6.0.1
       wcwidth: 1.0.1
 
+  ora@8.2.0:
+    dependencies:
+      chalk: 5.6.2
+      cli-cursor: 5.0.0
+      cli-spinners: 2.9.2
+      is-interactive: 2.0.0
+      is-unicode-supported: 2.1.0
+      log-symbols: 6.0.0
+      stdin-discarder: 0.2.2
+      string-width: 7.2.0
+      strip-ansi: 7.2.0
+
   outdent@0.5.0: {}
 
+  outvariant@1.4.3: {}
+
+  ovsx@1.0.2:
+    dependencies:
+      '@vscode/vsce': 3.9.2
+      commander: 6.2.1
+      follow-redirects: 1.16.0
+      is-ci: 2.0.0
+      leven: 3.1.0
+      semver: 7.7.4
+      tmp: 0.2.7
+      yauzl-promise: 4.0.0
+    transitivePeerDependencies:
+      - debug
+      - supports-color
+
   own-keys@1.0.1:
     dependencies:
       get-intrinsic: 1.3.0
@@ -13544,16 +18912,26 @@ snapshots:
     dependencies:
       yocto-queue: 0.1.0
 
+  p-locate@3.0.0:
+    dependencies:
+      p-limit: 2.3.0
+
   p-locate@4.1.0:
     dependencies:
       p-limit: 2.3.0
 
+  p-locate@5.0.0:
+    dependencies:
+      p-limit: 3.1.0
+
   p-map@2.1.0: {}
 
   p-map@4.0.0:
     dependencies:
       aggregate-error: 3.1.0
 
+  p-map@7.0.5: {}
+
   p-retry@4.6.2:
     dependencies:
       '@types/retry': 0.12.0
@@ -13571,6 +18949,10 @@ snapshots:
 
   pako@1.0.11: {}
 
+  parent-module@1.0.1:
+    dependencies:
+      callsites: 3.1.0
+
   parse-bmfont-ascii@1.0.6: {}
 
   parse-bmfont-binary@1.0.6: {}
@@ -13580,10 +18962,48 @@ snapshots:
       xml-parse-from-string: 1.0.1
       xml2js: 0.5.0
 
+  parse-entities@4.0.2:
+    dependencies:
+      '@types/unist': 2.0.11
+      character-entities-legacy: 3.0.0
+      character-reference-invalid: 2.0.1
+      decode-named-character-reference: 1.3.0
+      is-alphanumerical: 2.0.1
+      is-decimal: 2.0.1
+      is-hexadecimal: 2.0.1
+
+  parse-json@5.2.0:
+    dependencies:
+      '@babel/code-frame': 7.29.0
+      error-ex: 1.3.4
+      json-parse-even-better-errors: 2.3.1
+      lines-and-columns: 1.2.4
+
+  parse-json@8.3.0:
+    dependencies:
+      '@babel/code-frame': 7.29.0
+      index-to-position: 1.2.0
+      type-fest: 4.41.0
+
+  parse-ms@4.0.0: {}
+
+  parse-semver@1.1.1:
+    dependencies:
+      semver: 5.7.2
+
   parse5-htmlparser2-tree-adapter@6.0.1:
     dependencies:
       parse5: 6.0.1
 
+  parse5-htmlparser2-tree-adapter@7.1.0:
+    dependencies:
+      domhandler: 5.0.3
+      parse5: 7.3.0
+
+  parse5-parser-stream@7.1.2:
+    dependencies:
+      parse5: 7.3.0
+
   parse5@5.1.1: {}
 
   parse5@6.0.1: {}
@@ -13591,7 +19011,6 @@ snapshots:
   parse5@7.3.0:
     dependencies:
       entities: 6.0.1
-    optional: true
 
   parseurl@1.3.3: {}
 
@@ -13599,12 +19018,16 @@ snapshots:
 
   path-data-parser@0.1.0: {}
 
+  path-exists@3.0.0: {}
+
   path-exists@4.0.0: {}
 
   path-is-absolute@1.0.1: {}
 
   path-key@3.1.1: {}
 
+  path-key@4.0.0: {}
+
   path-parse@1.0.7: {}
 
   path-scurry@1.11.1:
@@ -13612,12 +19035,19 @@ snapshots:
       lru-cache: 10.4.3
       minipass: 7.1.3
 
+  path-scurry@2.0.2:
+    dependencies:
+      lru-cache: 11.3.3
+      minipass: 7.1.3
+
   path-to-regexp@6.3.0: {}
 
   path-to-regexp@8.4.2: {}
 
   path-type@4.0.0: {}
 
+  path-type@6.0.0: {}
+
   pathe@2.0.3: {}
 
   pe-library@0.4.1: {}
@@ -13674,12 +19104,20 @@ snapshots:
       exsolve: 1.1.0
       pathe: 2.0.3
 
+  pkg-up@3.1.0:
+    dependencies:
+      find-up: 3.0.0
+
   plist@3.1.1:
     dependencies:
       '@xmldom/xmldom': 0.9.10
       base64-js: 1.5.1
       xmlbuilder: 15.1.1
 
+  pluralize@2.0.0: {}
+
+  pluralize@8.0.0: {}
+
   pngjs@6.0.0: {}
 
   pngjs@7.0.0: {}
@@ -13693,6 +19131,11 @@ snapshots:
 
   possible-typed-array-names@1.1.0: {}
 
+  postcss-selector-parser@7.1.4:
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+
   postcss@8.5.15:
     dependencies:
       nanoid: 3.3.12
@@ -13709,12 +19152,36 @@ snapshots:
     dependencies:
       commander: 9.5.0
 
+  powershell-utils@0.1.0: {}
+
   preact@10.29.2: {}
 
+  prebuild-install@7.1.3:
+    dependencies:
+      detect-libc: 2.1.2
+      expand-template: 2.0.3
+      github-from-package: 0.0.0
+      minimist: 1.2.8
+      mkdirp-classic: 0.5.3
+      napi-build-utils: 2.0.0
+      node-abi: 3.92.0
+      pump: 3.0.4
+      rc: 1.2.8
+      simple-get: 4.0.1
+      tar-fs: 2.1.5
+      tunnel-agent: 0.6.0
+    optional: true
+
   prettier@2.8.8: {}
 
   pretty-bytes@7.1.0: {}
 
+  pretty-ms@9.3.0:
+    dependencies:
+      parse-ms: 4.0.0
+
+  prismjs@1.30.0: {}
+
   process-nextick-args@2.0.1: {}
 
   process-warning@4.0.1: {}
@@ -13730,6 +19197,17 @@ snapshots:
       err-code: 2.0.3
       retry: 0.12.0
 
+  prompts@2.4.2:
+    dependencies:
+      kleur: 3.0.3
+      sisteransi: 1.0.5
+
+  prop-types@15.7.2:
+    dependencies:
+      loose-envify: 1.4.0
+      object-assign: 4.1.1
+      react-is: 16.13.1
+
   proper-lockfile@4.1.2:
     dependencies:
       graceful-fs: 4.2.11
@@ -13788,6 +19266,73 @@ snapshots:
 
   quick-lru@5.1.1: {}
 
+  radix-ui@1.6.2(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      '@radix-ui/primitive': 1.1.5
+      '@radix-ui/react-accessible-icon': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-accordion': 1.2.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-alert-dialog': 1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-arrow': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-aspect-ratio': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-avatar': 1.2.2(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-checkbox': 1.3.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-collapsible': 1.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-collection': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.2.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context-menu': 2.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-dialog': 1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-dropdown-menu': 2.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-focus-guards': 1.1.4(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-focus-scope': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-form': 0.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-hover-card': 1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-label': 2.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-menu': 2.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-menubar': 1.1.20(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-navigation-menu': 1.2.18(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-one-time-password-field': 0.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-password-toggle-field': 0.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-popover': 1.1.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-popper': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-progress': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-radio-group': 1.4.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-scroll-area': 1.2.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-select': 2.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-separator': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slider': 1.4.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.3.0(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-switch': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-tabs': 1.1.17(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-toast': 1.2.19(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-toggle': 1.1.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-toggle-group': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-toolbar': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-tooltip': 1.2.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-effect-event': 0.0.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-escape-keydown': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-is-hydrated': 0.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-size': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-visually-hidden': 1.2.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  randombytes@2.1.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
   range-parser@1.2.1: {}
 
   raw-body@3.0.2:
@@ -13797,13 +19342,71 @@ snapshots:
       iconv-lite: 0.7.2
       unpipe: 1.0.0
 
+  rc-config-loader@4.1.4:
+    dependencies:
+      debug: 4.4.3(supports-color@8.1.1)
+      js-yaml: 4.1.1
+      json5: 2.2.3
+      require-from-string: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  rc@1.2.8:
+    dependencies:
+      deep-extend: 0.6.0
+      ini: 1.3.8
+      minimist: 1.2.8
+      strip-json-comments: 2.0.1
+    optional: true
+
   react-dom@19.2.5(react@19.2.5):
     dependencies:
       react: 19.2.5
       scheduler: 0.27.0
 
+  react-fast-compare@3.2.2: {}
+
+  react-is@16.13.1: {}
+
+  react-markdown@10.1.0(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/react': 19.2.14
+      devlop: 1.1.0
+      hast-util-to-jsx-runtime: 2.3.6
+      html-url-attributes: 3.0.1
+      mdast-util-to-hast: 13.2.1
+      react: 19.2.5
+      remark-parse: 11.0.0
+      remark-rehype: 11.1.2
+      unified: 11.0.5
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - supports-color
+
   react-refresh@0.17.0: {}
 
+  react-remove-scroll-bar@2.3.8(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      react-style-singleton: 2.2.3(@types/react@19.2.14)(react@19.2.5)
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  react-remove-scroll@2.7.2(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      react-remove-scroll-bar: 2.3.8(@types/react@19.2.14)(react@19.2.5)
+      react-style-singleton: 2.2.3(@types/react@19.2.14)(react@19.2.5)
+      tslib: 2.8.1
+      use-callback-ref: 1.3.3(@types/react@19.2.14)(react@19.2.5)
+      use-sidecar: 1.1.3(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+
   react-router-dom@7.14.1(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
     dependencies:
       react: 19.2.5
@@ -13818,14 +19421,54 @@ snapshots:
     optionalDependencies:
       react-dom: 19.2.5(react@19.2.5)
 
+  react-scroll-to-bottom@4.2.0(@babel/core@7.29.0)(react@19.2.5):
+    dependencies:
+      '@babel/runtime-corejs3': 7.29.7
+      '@emotion/css': 11.1.3(@babel/core@7.29.0)
+      classnames: 2.3.1
+      core-js: 3.18.3
+      math-random: 2.0.1
+      prop-types: 15.7.2
+      react: 19.2.5
+      simple-update-in: 2.2.0
+    transitivePeerDependencies:
+      - '@babel/core'
+      - supports-color
+
+  react-style-singleton@2.2.3(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      get-nonce: 1.0.1
+      react: 19.2.5
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  react-syntax-highlighter@16.1.1(react@19.2.5):
+    dependencies:
+      '@babel/runtime': 7.29.2
+      highlight.js: 10.7.3
+      highlightjs-vue: 1.0.0
+      lowlight: 1.20.0
+      prismjs: 1.30.0
+      react: 19.2.5
+      refractor: 5.0.0
+
   react@19.2.5: {}
 
   read-binary-file-arch@1.0.6:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
+  read-pkg@9.0.1:
+    dependencies:
+      '@types/normalize-package-data': 2.4.4
+      normalize-package-data: 6.0.2
+      parse-json: 8.3.0
+      type-fest: 4.41.0
+      unicorn-magic: 0.1.0
+
   read-yaml-file@1.1.0:
     dependencies:
       graceful-fs: 4.2.11
@@ -13833,6 +19476,10 @@ snapshots:
       pify: 4.0.1
       strip-bom: 3.0.0
 
+  read@1.0.7:
+    dependencies:
+      mute-stream: 0.0.8
+
   readable-stream@2.3.8:
     dependencies:
       core-util-is: 1.0.3
@@ -13853,10 +19500,22 @@ snapshots:
     dependencies:
       minimatch: 5.1.9
 
+  readdirp@3.6.0:
+    dependencies:
+      picomatch: 2.3.2
+
   readdirp@4.1.2: {}
 
   real-require@0.2.0: {}
 
+  recast@0.23.12:
+    dependencies:
+      ast-types: 0.16.1
+      esprima: 4.0.1
+      source-map: 0.6.1
+      tiny-invariant: 1.3.3
+      tslib: 2.8.1
+
   reflect.getprototypeof@1.0.10:
     dependencies:
       call-bind: 1.0.9
@@ -13868,6 +19527,13 @@ snapshots:
       get-proto: 1.0.1
       which-builtin-type: 1.2.1
 
+  refractor@5.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/prismjs': 1.26.6
+      hastscript: 9.0.1
+      parse-entities: 4.0.2
+
   regex-recursion@6.0.2:
     dependencies:
       regex-utilities: 2.3.0
@@ -13896,6 +19562,16 @@ snapshots:
       gopd: 1.2.0
       set-function-name: 2.0.2
 
+  rehype-katex@7.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/katex': 0.16.8
+      hast-util-from-html-isomorphic: 2.0.0
+      hast-util-to-text: 4.0.2
+      katex: 0.16.47
+      unist-util-visit-parents: 6.0.2
+      vfile: 6.0.3
+
   remark-frontmatter@5.0.0:
     dependencies:
       '@types/mdast': 4.0.4
@@ -13905,6 +19581,26 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  remark-gfm@4.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-gfm: 3.1.0
+      micromark-extension-gfm: 3.0.0
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-math@6.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-math: 3.0.0
+      micromark-extension-math: 3.1.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
   remark-parse@11.0.0:
     dependencies:
       '@types/mdast': 4.0.4
@@ -13914,6 +19610,14 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  remark-rehype@11.1.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      mdast-util-to-hast: 13.2.1
+      unified: 11.0.5
+      vfile: 6.0.3
+
   remark-stringify@11.0.0:
     dependencies:
       '@types/mdast': 4.0.4
@@ -13937,8 +19641,14 @@ snapshots:
     dependencies:
       pe-library: 0.4.1
 
+  reselect@5.2.0: {}
+
+  resize-observer-polyfill@1.5.1: {}
+
   resolve-alpn@1.2.1: {}
 
+  resolve-from@4.0.0: {}
+
   resolve-from@5.0.0: {}
 
   resolve-pkg-maps@1.0.0: {}
@@ -13970,6 +19680,8 @@ snapshots:
 
   retry@0.13.1: {}
 
+  rettime@0.11.11: {}
+
   reusify@1.1.0: {}
 
   rfdc@1.4.1: {}
@@ -14139,7 +19851,7 @@ snapshots:
 
   router@2.2.0:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       depd: 2.0.0
       is-promise: 4.0.0
       parseurl: 1.3.3
@@ -14213,8 +19925,22 @@ snapshots:
 
   scheduler@0.27.0: {}
 
+  screenfull@5.2.0: {}
+
   search-insights@2.17.3: {}
 
+  secretlint@10.2.2:
+    dependencies:
+      '@secretlint/config-creator': 10.2.2
+      '@secretlint/formatter': 10.2.2
+      '@secretlint/node': 10.2.2
+      '@secretlint/profiler': 10.2.2
+      debug: 4.4.3(supports-color@8.1.1)
+      globby: 14.1.0
+      read-pkg: 9.0.1
+    transitivePeerDependencies:
+      - supports-color
+
   section-matter@1.0.0:
     dependencies:
       extend-shallow: 2.0.1
@@ -14225,13 +19951,15 @@ snapshots:
   semver-compare@1.0.0:
     optional: true
 
+  semver@5.7.2: {}
+
   semver@6.3.1: {}
 
   semver@7.7.4: {}
 
   send@1.2.1:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       encodeurl: 2.0.0
       escape-html: 1.0.3
       etag: 1.8.1
@@ -14250,6 +19978,10 @@ snapshots:
       type-fest: 0.13.1
     optional: true
 
+  serialize-javascript@6.0.2:
+    dependencies:
+      randombytes: 2.1.0
+
   serve-static@2.2.1:
     dependencies:
       encodeurl: 2.0.0
@@ -14263,6 +19995,8 @@ snapshots:
 
   set-cookie-parser@2.7.2: {}
 
+  set-cookie-parser@3.1.2: {}
+
   set-function-length@1.2.2:
     dependencies:
       define-data-property: 1.1.4
@@ -14285,8 +20019,54 @@ snapshots:
       es-errors: 1.3.0
       es-object-atoms: 1.1.1
 
+  setimmediate@1.0.5: {}
+
   setprototypeof@1.2.0: {}
 
+  shadcn@3.8.5(@types/node@22.19.17)(babel-plugin-macros@3.1.0)(typescript@6.0.2):
+    dependencies:
+      '@antfu/ni': 25.0.0
+      '@babel/core': 7.29.0
+      '@babel/parser': 7.29.7
+      '@babel/plugin-transform-typescript': 7.29.7(@babel/core@7.29.0)
+      '@babel/preset-typescript': 7.29.7(@babel/core@7.29.0)
+      '@dotenvx/dotenvx': 1.75.1
+      '@modelcontextprotocol/sdk': 1.29.0(zod@3.25.76)
+      '@types/validate-npm-package-name': 4.0.2
+      browserslist: 4.28.2
+      commander: 14.0.3
+      cosmiconfig: 9.0.2(typescript@6.0.2)
+      dedent: 1.7.2(babel-plugin-macros@3.1.0)
+      deepmerge: 4.3.1
+      diff: 8.0.4
+      execa: 9.6.1
+      fast-glob: 3.3.3
+      fs-extra: 11.3.5
+      fuzzysort: 3.1.0
+      https-proxy-agent: 7.0.6
+      kleur: 4.1.5
+      msw: 2.15.0(@types/node@22.19.17)(typescript@6.0.2)
+      node-fetch: 3.3.2
+      open: 11.0.0
+      ora: 8.2.0
+      postcss: 8.5.15
+      postcss-selector-parser: 7.1.4
+      prompts: 2.4.2
+      recast: 0.23.12
+      stringify-object: 5.0.0
+      tailwind-merge: 3.6.0
+      ts-morph: 26.0.0
+      tsconfig-paths: 4.2.0
+      validate-npm-package-name: 7.0.2
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.2(zod@3.25.76)
+    transitivePeerDependencies:
+      - '@cfworker/json-schema'
+      - '@types/node'
+      - babel-plugin-macros
+      - supports-color
+      - typescript
+
   shebang-command@2.0.0:
     dependencies:
       shebang-regex: 3.0.0
@@ -14393,8 +20173,22 @@ snapshots:
 
   signal-exit@4.1.0: {}
 
+  simple-concat@1.0.1:
+    optional: true
+
+  simple-get@4.0.1:
+    dependencies:
+      decompress-response: 6.0.0
+      once: 1.4.0
+      simple-concat: 1.0.1
+    optional: true
+
   simple-git-hooks@2.13.1: {}
 
+  simple-invariant@2.0.1: {}
+
+  simple-update-in@2.2.0: {}
+
   simple-update-notifier@2.0.0:
     dependencies:
       semver: 7.7.4
@@ -14408,12 +20202,16 @@ snapshots:
       '@sinonjs/samsam': 10.0.2
       diff: 9.0.0
 
+  sisteransi@1.0.5: {}
+
   skin-tone@2.0.0:
     dependencies:
       unicode-emoji-modifier-base: 1.0.0
 
   slash@3.0.0: {}
 
+  slash@5.1.0: {}
+
   slice-ansi@3.0.0:
     dependencies:
       ansi-styles: 4.3.0
@@ -14421,6 +20219,12 @@ snapshots:
       is-fullwidth-code-point: 3.0.0
     optional: true
 
+  slice-ansi@4.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      astral-regex: 2.0.0
+      is-fullwidth-code-point: 3.0.0
+
   slice-ansi@7.1.2:
     dependencies:
       ansi-styles: 6.2.3
@@ -14438,7 +20242,7 @@ snapshots:
   socks-proxy-agent@7.0.0:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
       socks: 2.8.9
     transitivePeerDependencies:
       - supports-color
@@ -14452,6 +20256,11 @@ snapshots:
     dependencies:
       atomic-sleep: 1.0.0
 
+  sonner@2.0.7(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+
   source-map-js@1.2.1: {}
 
   source-map-support@0.5.21:
@@ -14459,6 +20268,8 @@ snapshots:
       buffer-from: 1.1.2
       source-map: 0.6.1
 
+  source-map@0.5.7: {}
+
   source-map@0.6.1: {}
 
   space-separated-tokens@2.0.2: {}
@@ -14468,6 +20279,20 @@ snapshots:
       cross-spawn: 7.0.6
       signal-exit: 4.1.0
 
+  spdx-correct@3.2.0:
+    dependencies:
+      spdx-expression-parse: 3.0.1
+      spdx-license-ids: 3.0.23
+
+  spdx-exceptions@2.5.0: {}
+
+  spdx-expression-parse@3.0.1:
+    dependencies:
+      spdx-exceptions: 2.5.0
+      spdx-license-ids: 3.0.23
+
+  spdx-license-ids@3.0.23: {}
+
   speakingurl@14.0.1: {}
 
   split2@4.2.0: {}
@@ -14499,6 +20324,8 @@ snapshots:
 
   std-env@4.0.0: {}
 
+  stdin-discarder@0.2.2: {}
+
   stop-iteration-iterator@1.1.0:
     dependencies:
       es-errors: 1.3.0
@@ -14524,6 +20351,8 @@ snapshots:
       - solid-js
       - vue
 
+  strict-event-emitter@0.5.1: {}
+
   string-argv@0.3.2: {}
 
   string-width@4.2.3:
@@ -14585,6 +20414,12 @@ snapshots:
       character-entities-html4: 2.1.0
       character-entities-legacy: 3.0.0
 
+  stringify-object@5.0.0:
+    dependencies:
+      get-own-enumerable-keys: 1.0.0
+      is-obj: 3.0.0
+      is-regexp: 3.1.0
+
   strip-ansi@6.0.1:
     dependencies:
       ansi-regex: 5.0.1
@@ -14597,15 +20432,38 @@ snapshots:
 
   strip-bom@3.0.0: {}
 
+  strip-final-newline@2.0.0: {}
+
+  strip-final-newline@4.0.0: {}
+
+  strip-json-comments@2.0.1:
+    optional: true
+
+  strip-json-comments@3.1.1: {}
+
   strtok3@10.3.5:
     dependencies:
       '@tokenizer/token': 0.3.0
 
+  structured-source@4.0.0:
+    dependencies:
+      boundary: 2.0.0
+
+  style-to-js@1.1.21:
+    dependencies:
+      style-to-object: 1.0.14
+
+  style-to-object@1.0.14:
+    dependencies:
+      inline-style-parser: 0.2.7
+
+  stylis@4.2.0: {}
+
   stylis@4.4.0: {}
 
   sumchecker@3.0.1:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -14621,6 +20479,8 @@ snapshots:
     dependencies:
       has-flag: 4.0.0
 
+  supports-color@9.4.0: {}
+
   supports-hyperlinks@3.2.0:
     dependencies:
       has-flag: 4.0.0
@@ -14631,12 +20491,36 @@ snapshots:
   symbol-tree@3.2.4:
     optional: true
 
+  systeminformation@5.31.17: {}
+
   tabbable@6.4.0: {}
 
+  table@6.9.0:
+    dependencies:
+      ajv: 8.18.0
+      lodash.truncate: 4.4.2
+      slice-ansi: 4.0.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  tagged-tag@1.0.0: {}
+
+  tailwind-merge@3.6.0: {}
+
+  tailwindcss@4.1.18: {}
+
   tailwindcss@4.2.2: {}
 
   tapable@2.3.2: {}
 
+  tar-fs@2.1.5:
+    dependencies:
+      chownr: 1.1.4
+      mkdirp-classic: 0.5.3
+      pump: 3.0.4
+      tar-stream: 2.2.0
+    optional: true
+
   tar-stream@2.2.0:
     dependencies:
       bl: 4.1.0
@@ -14669,6 +20553,23 @@ snapshots:
 
   term-size@2.2.1: {}
 
+  terminal-link@4.0.0:
+    dependencies:
+      ansi-escapes: 7.3.0
+      supports-hyperlinks: 3.2.0
+
+  test-exclude@6.0.0:
+    dependencies:
+      '@istanbuljs/schema': 0.1.6
+      glob: 7.2.3
+      minimatch: 3.1.5
+
+  text-table@0.2.0: {}
+
+  textextensions@6.11.0:
+    dependencies:
+      editions: 6.22.0
+
   thenify-all@1.6.0:
     dependencies:
       thenify: 3.3.1
@@ -14681,6 +20582,8 @@ snapshots:
     dependencies:
       real-require: 0.2.0
 
+  tiny-invariant@1.3.3: {}
+
   tinybench@2.9.0: {}
 
   tinycolor2@1.6.0: {}
@@ -14699,11 +20602,17 @@ snapshots:
   tldts-core@6.1.86:
     optional: true
 
+  tldts-core@7.4.8: {}
+
   tldts@6.1.86:
     dependencies:
       tldts-core: 6.1.86
     optional: true
 
+  tldts@7.4.8:
+    dependencies:
+      tldts-core: 7.4.8
+
   tmp-promise@3.0.3:
     dependencies:
       tmp: 0.2.7
@@ -14731,6 +20640,10 @@ snapshots:
       tldts: 6.1.86
     optional: true
 
+  tough-cookie@6.0.2:
+    dependencies:
+      tldts: 7.4.8
+
   tr46@0.0.3: {}
 
   tr46@5.1.1:
@@ -14752,11 +20665,22 @@ snapshots:
 
   ts-dedent@2.2.0: {}
 
+  ts-morph@26.0.0:
+    dependencies:
+      '@ts-morph/common': 0.27.0
+      code-block-writer: 13.0.3
+
   ts-morph@28.0.0:
     dependencies:
       '@ts-morph/common': 0.29.0
       code-block-writer: 13.0.3
 
+  tsconfig-paths@4.2.0:
+    dependencies:
+      json5: 2.2.3
+      minimist: 1.2.8
+      strip-bom: 3.0.0
+
   tsdown@0.22.0(@arethetypeswrong/core@0.18.2)(publint@0.3.18)(tsx@4.21.0)(typescript@6.0.2)(unrun@0.2.34(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0))(vue-tsc@3.2.9(typescript@6.0.2)):
     dependencies:
       ansis: 4.2.0
@@ -14824,6 +20748,15 @@ snapshots:
     optionalDependencies:
       fsevents: 2.3.3
 
+  tunnel-agent@0.6.0:
+    dependencies:
+      safe-buffer: 5.2.1
+    optional: true
+
+  tunnel@0.0.6: {}
+
+  tw-animate-css@1.4.0: {}
+
   tweetnacl@0.14.5: {}
 
   type-detect@4.0.8: {}
@@ -14833,6 +20766,12 @@ snapshots:
   type-fest@0.13.1:
     optional: true
 
+  type-fest@4.41.0: {}
+
+  type-fest@5.8.0:
+    dependencies:
+      tagged-tag: 1.0.0
+
   type-is@2.0.1:
     dependencies:
       content-type: 1.0.5
@@ -14872,6 +20811,12 @@ snapshots:
       possible-typed-array-names: 1.1.0
       reflect.getprototypeof: 1.0.10
 
+  typed-rest-client@1.8.11:
+    dependencies:
+      qs: 6.15.1
+      tunnel: 0.0.6
+      underscore: 1.13.8
+
   typescript@5.6.1-rc: {}
 
   typescript@5.9.3: {}
@@ -14900,6 +20845,8 @@ snapshots:
       '@quansync/fs': 1.0.0
       quansync: 1.0.0
 
+  underscore@1.13.8: {}
+
   undici-types@5.26.5: {}
 
   undici-types@6.21.0: {}
@@ -14908,6 +20855,10 @@ snapshots:
 
   unicode-emoji-modifier-base@1.0.0: {}
 
+  unicorn-magic@0.1.0: {}
+
+  unicorn-magic@0.3.0: {}
+
   unified@11.0.5:
     dependencies:
       '@types/unist': 3.0.3
@@ -14926,6 +20877,11 @@ snapshots:
     dependencies:
       imurmurhash: 0.1.4
 
+  unist-util-find-after@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.1
+
   unist-util-is@6.0.1:
     dependencies:
       '@types/unist': 3.0.3
@@ -14934,6 +20890,11 @@ snapshots:
     dependencies:
       '@types/unist': 3.0.3
 
+  unist-util-remove-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-visit: 5.1.0
+
   unist-util-remove@4.0.0:
     dependencies:
       '@types/unist': 3.0.3
@@ -14994,6 +20955,8 @@ snapshots:
       - '@emnapi/runtime'
     optional: true
 
+  until-async@3.0.2: {}
+
   update-browserslist-db@1.2.3(browserslist@4.28.2):
     dependencies:
       browserslist: 4.28.2
@@ -15004,6 +20967,23 @@ snapshots:
     dependencies:
       punycode: 2.3.1
 
+  url-join@4.0.1: {}
+
+  use-callback-ref@1.3.3(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  use-sidecar@1.1.3(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      detect-node-es: 1.1.0
+      react: 19.2.5
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
   use-sync-external-store@1.6.0(react@19.2.5):
     dependencies:
       react: 19.2.5
@@ -15018,8 +20998,21 @@ snapshots:
 
   uuid@14.0.0: {}
 
+  v8-to-istanbul@9.3.0:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      '@types/istanbul-lib-coverage': 2.0.6
+      convert-source-map: 2.0.0
+
+  validate-npm-package-license@3.0.4:
+    dependencies:
+      spdx-correct: 3.2.0
+      spdx-expression-parse: 3.0.1
+
   validate-npm-package-name@5.0.1: {}
 
+  validate-npm-package-name@7.0.2: {}
+
   vary@1.1.2: {}
 
   verror@1.10.1:
@@ -15029,6 +21022,13 @@ snapshots:
       extsprintf: 1.4.1
     optional: true
 
+  version-range@4.15.0: {}
+
+  vfile-location@5.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile: 6.0.3
+
   vfile-message@4.0.3:
     dependencies:
       '@types/unist': 3.0.3
@@ -15039,6 +21039,10 @@ snapshots:
       '@types/unist': 3.0.3
       vfile-message: 4.0.3
 
+  vite-plugin-css-injected-by-js@3.5.2(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)):
+    dependencies:
+      vite: 6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)
+
   vite-plugin-singlefile@2.3.3(rollup@4.60.2)(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)):
     dependencies:
       micromatch: 4.0.8
@@ -15106,14 +21110,14 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  vitepress-plugin-mermaid@2.0.17(mermaid@11.15.0)(vitepress@1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2)):
+  vitepress-plugin-mermaid@2.0.17(mermaid@11.15.0)(vitepress@1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(fuse.js@7.5.0)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2)):
     dependencies:
       mermaid: 11.15.0
-      vitepress: 1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2)
+      vitepress: 1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(fuse.js@7.5.0)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2)
     optionalDependencies:
       '@mermaid-js/mermaid-mindmap': 9.3.0
 
-  vitepress@1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2):
+  vitepress@1.6.4(@algolia/client-search@5.52.1)(@types/node@22.19.17)(fuse.js@7.5.0)(lightningcss@1.32.0)(postcss@8.5.15)(search-insights@2.17.3)(typescript@6.0.2):
     dependencies:
       '@docsearch/css': 3.8.2
       '@docsearch/js': 3.8.2(@algolia/client-search@5.52.1)(search-insights@2.17.3)
@@ -15126,7 +21130,7 @@ snapshots:
       '@vue/devtools-api': 7.7.9
       '@vue/shared': 3.5.35
       '@vueuse/core': 12.8.2(typescript@6.0.2)
-      '@vueuse/integrations': 12.8.2(focus-trap@7.8.0)(typescript@6.0.2)
+      '@vueuse/integrations': 12.8.2(focus-trap@7.8.0)(fuse.js@7.5.0)(typescript@6.0.2)
       focus-trap: 7.8.0
       mark.js: 8.11.1
       minisearch: 7.2.0
@@ -15162,10 +21166,10 @@ snapshots:
       - typescript
       - universal-cookie
 
-  vitest@4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)):
+  vitest@4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3)):
     dependencies:
       '@vitest/expect': 4.1.4
-      '@vitest/mocker': 4.1.4(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
+      '@vitest/mocker': 4.1.4(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@6.4.2(@types/node@22.19.17)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.8.3))
       '@vitest/pretty-format': 4.1.4
       '@vitest/runner': 4.1.4
       '@vitest/snapshot': 4.1.4
@@ -15191,10 +21195,10 @@ snapshots:
     transitivePeerDependencies:
       - msw
 
-  vitest@4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)):
+  vitest@4.1.4(@types/node@22.19.17)(@vitest/coverage-v8@4.1.4)(jsdom@25.0.1)(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)):
     dependencies:
       '@vitest/expect': 4.1.4
-      '@vitest/mocker': 4.1.4(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
+      '@vitest/mocker': 4.1.4(msw@2.15.0(@types/node@22.19.17)(typescript@6.0.2))(vite@8.0.8(@types/node@22.19.17)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
       '@vitest/pretty-format': 4.1.4
       '@vitest/runner': 4.1.4
       '@vitest/snapshot': 4.1.4
@@ -15257,6 +21261,8 @@ snapshots:
     dependencies:
       defaults: 1.0.4
 
+  web-namespaces@2.0.1: {}
+
   web-streams-polyfill@3.3.3: {}
 
   webidl-conversions@3.0.1: {}
@@ -15269,10 +21275,8 @@ snapshots:
   whatwg-encoding@3.1.1:
     dependencies:
       iconv-lite: 0.6.3
-    optional: true
 
-  whatwg-mimetype@4.0.0:
-    optional: true
+  whatwg-mimetype@4.0.0: {}
 
   whatwg-url@14.2.0:
     dependencies:
@@ -15330,6 +21334,10 @@ snapshots:
     dependencies:
       isexe: 2.0.0
 
+  which@4.0.0:
+    dependencies:
+      isexe: 3.1.5
+
   why-is-node-running@2.3.0:
     dependencies:
       siginfo: 2.0.0
@@ -15339,6 +21347,8 @@ snapshots:
     dependencies:
       string-width: 4.2.3
 
+  workerpool@9.3.4: {}
+
   wrap-ansi@7.0.0:
     dependencies:
       ansi-styles: 4.3.0
@@ -15365,6 +21375,11 @@ snapshots:
     dependencies:
       is-wsl: 3.1.1
 
+  wsl-utils@0.3.1:
+    dependencies:
+      is-wsl: 3.1.1
+      powershell-utils: 0.1.0
+
   xml-name-validator@5.0.0:
     optional: true
 
@@ -15390,12 +21405,21 @@ snapshots:
 
   yallist@5.0.0: {}
 
+  yaml@1.10.3: {}
+
   yaml@2.8.3: {}
 
   yargs-parser@20.2.9: {}
 
   yargs-parser@21.1.1: {}
 
+  yargs-unparser@2.0.0:
+    dependencies:
+      camelcase: 6.3.0
+      decamelize: 4.0.0
+      flat: 5.0.2
+      is-plain-obj: 2.1.0
+
   yargs@16.2.0:
     dependencies:
       cliui: 7.0.4
@@ -15416,6 +21440,12 @@ snapshots:
       y18n: 5.0.8
       yargs-parser: 21.1.1
 
+  yauzl-promise@4.0.0:
+    dependencies:
+      '@node-rs/crc32': 1.10.6
+      is-it-type: 5.1.3
+      simple-invariant: 2.0.1
+
   yauzl@2.10.0:
     dependencies:
       buffer-crc32: 0.2.13
@@ -15426,18 +21456,32 @@ snapshots:
       buffer-crc32: 0.2.13
       pend: 1.2.0
 
+  yazl@2.5.1:
+    dependencies:
+      buffer-crc32: 0.2.13
+
   yazl@3.3.1:
     dependencies:
       buffer-crc32: 1.0.0
 
   yocto-queue@0.1.0: {}
 
+  yocto-spinner@1.2.1:
+    dependencies:
+      yoctocolors: 2.1.2
+
+  yoctocolors@2.1.2: {}
+
   zip-stream@4.1.1:
     dependencies:
       archiver-utils: 3.0.4
       compress-commons: 4.1.2
       readable-stream: 3.6.2
 
+  zod-to-json-schema@3.25.2(zod@3.25.76):
+    dependencies:
+      zod: 3.25.76
+
   zod-to-json-schema@3.25.2(zod@4.3.6):
     dependencies:
       zod: 4.3.6
@@ -15446,11 +21490,19 @@ snapshots:
 
   zod@4.3.6: {}
 
-  zustand@4.5.7(@types/react@19.2.14)(react@19.2.5):
+  zustand@4.5.7(@types/react@19.2.14)(immer@11.1.11)(react@19.2.5):
     dependencies:
       use-sync-external-store: 1.6.0(react@19.2.5)
     optionalDependencies:
       '@types/react': 19.2.14
+      immer: 11.1.11
       react: 19.2.5
 
+  zustand@5.0.14(@types/react@19.2.14)(immer@11.1.11)(react@19.2.5)(use-sync-external-store@1.6.0(react@19.2.5)):
+    optionalDependencies:
+      '@types/react': 19.2.14
+      immer: 11.1.11
+      react: 19.2.5
+      use-sync-external-store: 1.6.0(react@19.2.5)
+
   zwitch@2.0.4: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 46b840098..6d5235deb 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -9,8 +9,10 @@ catalog:
   zod: 4.3.6
 
 overrides:
+  "kimi-code>@tailwindcss/vite": "4.1.18"
   "ssh2@1.17.0>cpu-features": "-"
   "ssh2@1.17.0>nan": "-"
+  "kimi-code>tailwindcss": "4.1.18"
 
 # Allow Electron's postinstall to extract its prebuilt binary (needed by
 # apps/kimi-desktop). Other native deps stay unbuilt and rely on their own
diff --git a/vitest.config.ts b/vitest.config.ts
index 08f1e765f..841d39ee3 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -2,7 +2,7 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
-    projects: ['packages/*', 'apps/kimi-code'],
+    projects: ['packages/*', 'apps/kimi-code', 'apps/vscode'],
     coverage: {
       provider: 'v8',
       include: ['packages/*/src/**/*.ts', 'apps/*/src/**/*.ts'],